Warp: the Warp effects bend an image's pixels with its frame

A Warp effect on an image, or on a group that holds one, bent the image's
frame but drew the pixels unbent, cut by the bent frame. The image now
bends with the frame as a raster mesh warp, as an envelope bends it: after
the last effect in the list, the image is cut into 10 x 10 cells of two
triangles, each a clipped piece of the image under its own affine map,
through every Warp it took and the Transform moves between them. Effects
after a Warp reshape only the frame, and a placed gradient on a group
that holds the image follows the group's bounds as the pieces draw them.
The image itself is unchanged, so editing or removing the warp redraws
it. The images stay unbent when their pieces would make the art pass 2
million objects, and an image stays unbent when its clipping frame keeps
its shape because the warp would pass the effects' anchor budget.

- SVG export writes the image once and draws the pieces with <use> when a
  group holds pieces of one image clipped by triangles. PDF, EPS, .ai and
  PNG exports write the bent pieces.
- Envelopes: a grayscale image's fill color now colorizes the pieces an
  envelope cuts. Before, the pieces drew the gray image.
- Geometry effects: an image under any geometry effect keeps its fill
  color and its smoothing setting. Before, it drew the gray image,
  smoothed.

Docs: Warp params text, docs/mcp.md, docs/target-app-parity.md.

crates/doc/src/live.rs

@@ -60,7 +60,7 @@ pub use envelope::{
 pub(crate) use expand::max_outset;
 pub use expand::{
     Hooks, MAX_GENERATED, Outliner, PatternTiles, affine_near, expand_deep, expand_deep_hooks, expand_live, expand_live_hooks, expand_live_with,
-    expanded_group, expanded_group_hooks, is_live, mesh_quad_nodes, subtree_has_live,
+    expanded_group, expanded_group_hooks, is_live, mesh_quad_nodes, mesh_warp_cost, mesh_warp_image, subtree_has_live,
 };
 #[cfg(test)]
 use mesh::grid_eval;

crates/doc/src/live/expand.rs

@@ -178,29 +178,46 @@ fn affine_between(s: [Point; 3], d: [Point; 3]) -> Option<Affine> {
     a.is_finite().then_some(a)
 }
 
-/// Image `n` (`im`) pushed through the warp as a raster mesh warp: its frame cut into
-/// `w.cells`² cells of two triangles, each a clip group showing the image under the affine map
-/// that takes the triangle where the warp takes its corners (with Preserve Shape Using
-/// Transparency, the image masked by the triangle; with Anti-Alias off, drawn without smoothing).
-/// Each piece reaches a little past its edges (at most half a point) so neighbours overlap and no
-/// seams show.
+/// Image `n` (`im`) pushed through the envelope's warp as a raster mesh warp ([`mesh_warp_image`]
+/// with `w.cells` cells, Preserve Shape Using Transparency and Anti-Alias as the envelope's
+/// options say).
 fn warp_image(n: &Node, im: &ImageObject, w: &Warper) -> Node {
     let k = w.cells.max(1);
-    // Two triangles a cell, three objects each; an image an inner envelope already cut into
-    // pieces is cut again here, so the pieces count against [`MAX_GENERATED`]. Past it, the image
-    // is left out.
-    if !Generating::charge(k.saturating_mul(k).saturating_mul(6)) {
+    // An image an inner envelope already cut into pieces is cut again here, so the pieces count
+    // against [`MAX_GENERATED`]. Past it, the image is left out.
+    if !Generating::charge(mesh_warp_cost(k)) {
         let mut g = n.clone();
         g.kind = NodeKind::Group { children: vec![], clip: false };
         return g;
     }
+    mesh_warp_image(n, im, w.f, k, !w.options.anti_alias, w.options.preserve_shape == PreserveShape::Transparency)
+}
+
+/// How many objects [`mesh_warp_image`] makes of one image with `cells` rows and columns: two
+/// triangles a cell, three objects each.
+pub fn mesh_warp_cost(cells: usize) -> usize {
+    let k = cells.max(1);
+    k.saturating_mul(k).saturating_mul(6)
+}
+
+/// Image `n` (`im`) pushed through point map `f` as a raster mesh warp: its frame cut into
+/// `cells`² cells of two triangles, each a clip group showing the image under the affine map
+/// that takes the triangle where `f` takes its corners (with `masked`, the image masked by the
+/// triangle instead; with `pixelated`, drawn without smoothing). Each piece reaches a little past
+/// its edges (at most half a point) so neighbors overlap and no seams show. Each piece keeps the
+/// color `n` colorizes a grayscale image with. The result is a group with `n`'s id, name,
+/// transparency, opacity mask and appearance.
+pub fn mesh_warp_image(n: &Node, im: &ImageObject, f: &dyn Fn(Point) -> Point, cells: usize, pixelated: bool, masked: bool) -> Node {
+    let k = cells.max(1);
+    // A grayscale image's fill color colorizes each piece; the group of pieces takes none.
+    let colorize = n.extras().colorize.clone();
     let (pw, ph) = (im.width as f64, im.height as f64);
     let at = |i: usize, j: usize| Point::new(pw * i as f64 / k as f64, ph * j as f64 / k as f64);
     let mut pieces = Vec::with_capacity(2 * k * k);
     for j in 0..k {
         for i in 0..k {
             let s = [at(i, j), at(i + 1, j), at(i + 1, j + 1), at(i, j + 1)];
-            let d = s.map(|p| (w.f)(im.xf * p));
+            let d = s.map(|p| f(im.xf * p));
             for t in [[0, 1, 2], [0, 2, 3]] {
                 let (st, dt) = (t.map(|v| s[v]), t.map(|v| d[v]));
                 let Some(xf) = affine_between(st, dt) else { continue };
@@ -216,8 +233,9 @@ fn warp_image(n: &Node, im: &ImageObject, w: &Warper) -> Node {
                     .collect();
                 let shape = PathData::single(SubPath::polyline(&tri, true));
                 let mut image = Node::new(n.id, NodeKind::Image(Box::new(ImageObject { xf, ..im.clone() })));
-                image.extras_mut().pixelated = !w.options.anti_alias;
-                if w.options.preserve_shape == PreserveShape::Transparency {
+                image.extras_mut().pixelated = pixelated;
+                image.extras_mut().colorize = colorize.clone();
+                if masked {
                     // Preserve Shape Using Transparency: the triangle is the piece's alpha (a
                     // white opacity mask) instead of its clipping path.
                     let white = Node::path(n.id, shape, Appearance::basic(Paint::solid(Color::WHITE), Paint::None, 0.0));
@@ -234,6 +252,9 @@ fn warp_image(n: &Node, im: &ImageObject, w: &Warper) -> Node {
     }
     let mut g = n.clone();
     g.kind = NodeKind::Group { children: pieces, clip: false };
+    if let Some(e) = g.extras_if_any() {
+        e.colorize = None;
+    }
     g
 }
 

crates/effects/src/catalog.rs

@@ -112,7 +112,7 @@ fn lengths_of(id: &str) -> Lengths {
     }
 }
 
-const WARP_DOC: &str = "{bend: % (-100..100, 50; with a bend or a distortion, placed gradients move and scale from the object's bounds to its warped bounds), horizontal: % distortion (0), vertical: % distortion (0), orientation: \"horizontal\"|\"vertical\", version: 0|1 (the map: 1 bends each style as one Bézier patch over the bounds, which new and imported warps get; 0, or none, is VectorCraft's earlier map, which warps saved without a version keep)}";
+const WARP_DOC: &str = "{bend: % (-100..100, 50; with a bend or a distortion, placed gradients move and scale from the object's bounds to its warped bounds, and images bend as 10 × 10 cells of two triangles unless the pieces would make the art pass 2,000,000 objects or the image's frame keeps its shape past the anchor budget), horizontal: % distortion (0), vertical: % distortion (0), orientation: \"horizontal\"|\"vertical\", version: 0|1 (the map: 1 bends each style as one Bézier patch over the bounds, which new and imported warps get; 0, or none, is VectorCraft's earlier map, which warps saved without a version keep)}";
 
 const DT: &[&str] = &["Effect", "Distort & Transform"];
 

crates/effects/src/reshape.rs

@@ -4,19 +4,22 @@
 //! Geometry effects reach them through outlines: [`outline_art`] turns the object into plain paths
 //! (glyph outlines, the evaluated live object, the symbol's art) and [`reshape`] runs each effect
 //! over all of them as one piece, with the whole art's bounds as the effect's reference box, so a
-//! warp bends a line of type as a whole. An image is clipped by its reshaped frame. Raster effects
-//! (shadows, glows, blur, feather) stay on the result for the renderer and exporters. Type without
+//! warp bends a line of type as a whole. An image is clipped by its reshaped frame, and a Warp
+//! effect bends its pixels with the frame ([`cut_warped_images`]). Raster effects (shadows, glows, blur,
+//! feather) stay on the result for the renderer and exporters. Type without
 //! inline graphics whose own fills or strokes have geometry effects is outlined too: each of those
 //! effects reshapes the whole outline that its fill or stroke paints. An image's own fills and
 //! strokes paint only the shape that a Convert to Shape or Outline Object effect on them gives
 //! them ([`image_rows`]).
 
 use std::collections::HashSet;
+use std::rc::Rc;
 use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
 use vectorcraft_doc::live::Hooks;
-use vectorcraft_doc::{Appearance, AppearanceItem, Document, Effect, Node, NodeId, NodeKind};
-use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Rect, Shape, shapes};
+use vectorcraft_doc::{Appearance, AppearanceItem, Document, Effect, ImageObject, Node, NodeId, NodeKind};
+use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect, Shape, shapes};
 
 use crate::{Budget, GeomContext, OutlineHook, apply_one, is_geometry, merged_params};
 
@@ -548,7 +551,14 @@ fn as_art_opts(
     let mut art = match &n.kind {
         NodeKind::Image(im) => {
             let frame = shapes::rectangle(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)).transformed(im.xf);
-            let image = Node::new(n.id, n.kind.clone());
+            let mut image = Node::new(n.id, n.kind.clone());
+            // Its pixels draw as the image's do: colorized by a grayscale image's fill color, and
+            // smoothed or not.
+            {
+                let mut e = image.extras_mut();
+                e.colorize = n.extras().colorize.clone();
+                e.pixelated = n.extras().pixelated;
+            }
             let clipped = || {
                 let mut clip = Node::path(n.id, frame.clone(), Appearance::default());
                 if let NodeKind::Path { clipping, .. } = &mut clip.kind {
@@ -632,9 +642,9 @@ pub(crate) fn geometry_effects(n: &Node) -> Vec<&Effect> {
 
 /// Apply `fx` to every path under `art` as one piece: each effect takes the whole art's bounds as
 /// its reference box and the art's seed (a random Transform moves the pieces together). Images and
-/// symbol instances follow a Transform effect the same way ([`transform_placed`]); other geometry
-/// effects leave them as they are (a raster follows a non-affine map only as a mesh warp). The
-/// paths keep to one [`Budget::EFFECTS`] together (or to what they cost, when that is more): a path
+/// symbol instances follow a Transform effect the same way ([`transform_placed`]), and images
+/// follow a Warp effect as a raster mesh warp ([`cut_warped_images`]); other geometry effects leave them
+/// as they are. The paths keep to one [`Budget::EFFECTS`] together (or to what they cost, when that is more): a path
 /// whose effect would pass what the others leave of it keeps its shape. The swatches and patterns
 /// that live-effect plug-ins painting their pieces name are looked up in `doc`, and a deferred one
 /// is listed by its index in `owner`, the effect list `fx` was taken from ([`reshape_leaves_apart`]).
@@ -705,8 +715,9 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
     let max = budget.at_least(used);
     // Read before the effects run: a path's own copies don't make it art of several objects.
     let copy_whole = copies_whole(art);
+    let mut warped = WarpedImages::new();
     for e in fx {
-        let Some(bounds) = art.geometric_bounds() else { break };
+        let Some(bounds) = warped.bounds(art) else { break };
         let params = merged_params(&e.id, &e.params);
         // Where a live-effect plug-in sits, which it is listed by when it is deferred.
         let effect = owner.iter().position(|x| std::ptr::eq(x, *e)).or_else(|| listed.iter().position(|x| std::ptr::eq(*x, *e)));
@@ -739,10 +750,21 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
         }
         let mut groups = vec![];
         if follows {
-            group_marks(art, &mut vec![], &HashSet::new(), &mut groups);
+            group_marks(art, &mut vec![], &HashSet::new(), None, &mut groups);
+            // The images earlier Warps bend are measured by their pieces only when a group's
+            // gradient needs the bounds.
+            if !groups.is_empty()
+                && let Some(images) = warped.when_cut(art)
+            {
+                groups.clear();
+                group_marks(art, &mut vec![], &HashSet::new(), Some(images), &mut groups);
+            }
         }
-        // The ids of the paths that kept their shape (past the budget).
+        // The ids of the paths that kept their shape (past the budget), and their places in the
+        // order [`for_each_leaf`] visits the paths.
         let mut kept_ids = HashSet::new();
+        let mut kept_leaves = HashSet::new();
+        let mut leaf_at = 0usize;
         let transform = (e.id == "distort.transform").then(|| {
             let (m, copies) = crate::distort::transform_map(bounds, &params, seed);
             let options = crate::distort::TransformOptions::of(&params);
@@ -757,6 +779,8 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
             continue;
         }
         for_each_leaf(art, &mut |leaf| {
+            let at = leaf_at;
+            leaf_at += 1;
             let Some((path, rule)) = leaf_geometry(leaf) else { return };
             // What the other paths leave of the budget.
             let before = Budget::of(&path);
@@ -789,6 +813,7 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
             let stage = effect.map(|effect| vectorcraft_plugins::deferred::Stage { object: seed, effect, item: None });
             let Some(out) = apply_one(&e.id, &params, &path, bounds, &GeomContext { seed, stage, ..GeomContext::of(leaf) }, room) else {
                 kept_ids.insert(leaf.id);
+                kept_leaves.insert(at);
                 return;
             };
             used = used.minus(before).plus(Budget::of(&out));
@@ -804,6 +829,16 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
         if boxes {
             rebase_leaves(art, &mut leaves.into_iter());
         }
+        // Warp bends images too: each one's pixels follow the warp's map over the same box. The
+        // images are cut into pieces once, after the last effect ([`cut_warped_images`]). An image
+        // whose clipping frame kept its shape (past the budget) keeps its pixels as they are.
+        if let Some(style) = e.id.strip_prefix("warp.").and_then(crate::warp::WarpStyle::from_id)
+            && crate::warp::bends(&e.id, &params)
+        {
+            let f: WarpMap = Rc::from(crate::warp::warp_map(bounds, style, &params));
+            warped.reserve(art);
+            mark_warped_images(art, &f, &kept_leaves, false, &mut 0, &mut warped);
+        }
         if let Some((m, copies, options, _)) = transform
             && options.objects
         {
@@ -816,14 +851,16 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
         // follow their bounds under Free Distort and Warp (they stay when no path changed them).
         // Each stays 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;
+        let images = if groups.is_empty() { None } else { warped.when_cut(art) };
+        let held = (!groups.is_empty() || !kept_ids.is_empty()) && group_marks(art, &mut vec![], &kept_ids, images, &mut after).1;
         if !groups.is_empty() {
             carry_groups(art, groups, after, &|from, to| crate::Carry::of(&e.id, &params, bounds, from, to, seed));
         }
         if follows && !held {
-            whole.push(crate::Carry::of(&e.id, &params, bounds, Some(bounds), art.geometric_bounds(), seed));
+            whole.push(crate::Carry::of(&e.id, &params, bounds, Some(bounds), warped.bounds(art), seed));
         }
     }
+    cut_warped_images(art, &warped);
     whole
 }
 
@@ -1445,17 +1482,25 @@ 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 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) {
+/// [`GroupMark`] describes goes into `out`, reached from `n` through `at`. An image that `images`
+/// lists is measured by the pieces it will be cut into ([`WarpedImages::image_bounds`]).
+fn group_marks(
+    n: &Node,
+    at: &mut Vec<usize>,
+    kept: &HashSet<NodeId>,
+    images: Option<&WarpedImages>,
+    out: &mut Vec<GroupMark>,
+) -> (Option<Rect>, bool) {
     match &n.kind {
         NodeKind::Path { guide: false, .. } | NodeKind::Compound { .. } => (n.geometric_bounds(), kept.contains(&n.id)),
+        NodeKind::Image(_) => (images.map_or_else(|| n.geometric_bounds(), |w| w.image_bounds(n)), false),
         NodeKind::Group { children, clip } | NodeKind::Layer { children, clip, .. } if !n.extras().type_outlines => {
             let layer = matches!(n.kind, NodeKind::Layer { .. });
             let skip = children.len().saturating_sub(n.editing_children().len());
             let (mut bounds, mut held) = (None, false);
             for (i, c) in children.iter().enumerate() {
                 at.push(i);
-                let (b, h) = group_marks(c, at, kept, out);
+                let (b, h) = group_marks(c, at, kept, images, out);
                 if is_member_group(c) && (c.appearance.has_positioned_gradient() || c.appearance.has_unplaced_gradient()) {
                     out.push((at.clone(), b, h));
                 }
@@ -1590,6 +1635,225 @@ pub(crate) fn transform_placed_within(n: &mut Node, m: Affine, copies: usize, ma
     copy_placed(n, m, copies, &mut room);
 }
 
+/// Rows and columns of the pieces a Warp effect cuts an image into (VectorCraft's own number).
+pub(crate) const WARP_IMAGE_CELLS: usize = 10;
+
+/// A Warp effect's point map, shared by the images it bends.
+pub(crate) type WarpMap = Rc<dyn Fn(Point) -> Point>;
+
+/// One image a Warp effect bent: the image's own key, and each warp it took with the placement
+/// the image had when it took it, in order.
+type WarpedImage = (String, Vec<(WarpMap, Affine)>);
+
+/// The images Warp effects bend while [`reshape_leaves_apart`] runs the effects. Each such image's
+/// key is replaced by a key of this table ([`WarpedImages::add`]), which a copy a later Transform
+/// effect makes keeps. The images are cut into pieces once, after the last effect
+/// ([`cut_warped_images`]): the effects after a Warp reshape the image's frame, not each piece,
+/// and a later Warp or Transform moves the one set of pieces.
+pub(crate) struct WarpedImages {
+    /// What this table's keys start with: no image key in the art starts with it
+    /// ([`WarpedImages::reserve`]).
+    prefix: String,
+    /// The prefix was checked against the art's image keys.
+    reserved: bool,
+    images: Vec<WarpedImage>,
+}
+
+impl WarpedImages {
+    pub(crate) fn new() -> Self {
+        static TABLES: AtomicUsize = AtomicUsize::new(0);
+        Self { prefix: format!("\0warp{}:", TABLES.fetch_add(1, Ordering::Relaxed)), reserved: false, images: vec![] }
+    }
+
+    /// Before the first image of `art` is marked: lengthen the prefix until no image key in `art`
+    /// starts with it, so no key from the document is read as one of this table's.
+    pub(crate) fn reserve(&mut self, art: &Node) {
+        if self.reserved {
+            return;
+        }
+        self.reserved = true;
+        let mut keys = vec![];
+        art.walk(&mut |c| {
+            if let NodeKind::Image(im) = &c.kind {
+                keys.push(im.key.clone());
+            }
+        });
+        while keys.iter().any(|k| k.starts_with(self.prefix.as_str())) {
+            self.prefix.push(':');
+        }
+    }
+
+    /// What this table's keys start with.
+    #[cfg(test)]
+    pub(crate) fn prefix(&self) -> &str {
+        &self.prefix
+    }
+
+    /// The image that `key`, a key of this table, stands for.
+    fn get(&self, key: &str) -> Option<&WarpedImage> {
+        self.images.get(key.strip_prefix(self.prefix.as_str())?.parse::<usize>().ok()?)
+    }
+
+    /// Record that the image with key `key`, placed by `xf`, takes warp `f`; returns the image's
+    /// new key.
+    fn add(&mut self, key: &str, xf: Affine, f: &WarpMap) -> String {
+        let (own, mut warps) = self.get(key).cloned().unwrap_or_else(|| (key.to_string(), vec![]));
+        warps.push((f.clone(), xf));
+        self.images.push((own, warps));
+        format!("{}{}", self.prefix, self.images.len() - 1)
+    }
+
+    /// Does the art `n` have room, within `max` nodes, for the pieces of every image under it that
+    /// this table lists?
+    fn fits(&self, n: &Node, max: usize) -> bool {
+        let mut count = 0usize;
+        n.walk(&mut |c| {
+            if let NodeKind::Image(im) = &c.kind
+                && self.get(&im.key).is_some()
+            {
+                count += 1;
+            }
+        });
+        vectorcraft_doc::live::mesh_warp_cost(WARP_IMAGE_CELLS).saturating_mul(count) <= max.saturating_sub(n.count())
+    }
+
+    /// The geometric bounds of `art` as it draws after the effects so far: each image this table
+    /// lists measured by the pieces the warps and moves it took would cut it into, when the art
+    /// has room for them ([`cut_warped_images`]).
+    pub(crate) fn bounds(&self, art: &Node) -> Option<Rect> {
+        if self.images.is_empty() || !self.fits(art, crate::distort::MAX_COPY_OBJECTS) {
+            return art.geometric_bounds();
+        }
+        // The pieces the images would be cut into now: each group of pieces is shown or hidden as
+        // its image is, and hidden objects are left out of a layer's bounds.
+        let mut probe = art.clone();
+        restore_warped_images(&mut probe, self, true);
+        probe.geometric_bounds()
+    }
+
+    /// The geometric bounds of image `n`: when this table lists it, measured by the pieces the
+    /// warps and moves it took would cut it into.
+    fn image_bounds(&self, n: &Node) -> Option<Rect> {
+        let NodeKind::Image(im) = &n.kind else { return n.geometric_bounds() };
+        if self.get(&im.key).is_none() {
+            return n.geometric_bounds();
+        }
+        let mut probe = Node::group(n.id, vec![Arc::new(n.clone())]);
+        restore_warped_images(&mut probe, self, true);
+        probe.geometric_bounds()
+    }
+
+    /// This table when the art `art` has room for the pieces of the images it lists, so that a
+    /// measure of the art takes them bent ([`WarpedImages::bounds`]); `None` otherwise.
+    fn when_cut(&self, art: &Node) -> Option<&Self> {
+        (!self.images.is_empty() && self.fits(art, crate::distort::MAX_COPY_OBJECTS)).then_some(self)
+    }
+}
+
+/// Record in `warped` that each image under `n` takes warp `f`, walking the groups and layers
+/// [`for_each_leaf`] walks and counting the paths it passes in `at`. `kept` holds the places of
+/// the paths that kept their shape (past the budget), in the order [`for_each_leaf`] visits the
+/// paths of the art: an image in a clip group whose clipping art holds one (`held`) does not take
+/// the warp.
+pub(crate) fn mark_warped_images(n: &mut Node, f: &WarpMap, kept: &HashSet<usize>, held: bool, at: &mut usize, warped: &mut WarpedImages) {
+    let (NodeKind::Group { children, clip } | NodeKind::Layer { children, clip, .. }) = &mut n.kind else { return };
+    let mut held = held;
+    // A clip group's first member is its clipping art: when a path in it kept its shape, it and
+    // the members it clips keep theirs.
+    if *clip && let Some(first) = children.first() {
+        let start = *at;
+        held |= (start..start + leaf_count(first)).any(|p| kept.contains(&p));
+    }
+    for c in children.iter_mut() {
+        match &c.kind {
+            NodeKind::Path { guide: false, .. } | NodeKind::Compound { .. } => *at += 1,
+            NodeKind::Group { .. } | NodeKind::Layer { .. } => mark_warped_images(Arc::make_mut(c), f, kept, held, at, warped),
+            NodeKind::Image(_) if !held => {
+                if let NodeKind::Image(im) = &mut Arc::make_mut(c).kind {
+                    im.key = warped.add(&im.key, im.xf, f);
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+/// Give each image under `n` that `warped` lists its own key back, and cut it into the pieces of
+/// a raster mesh warp ([`vectorcraft_doc::live::mesh_warp_image`], each piece drawn as the image
+/// is, smoothed or not) through the warps it took and the moves between and after them
+/// ([`warped_map`]). The art keeps to [`crate::distort::MAX_COPY_OBJECTS`] nodes: when the pieces
+/// would pass it, no image is cut. An image whose placement has no inverse is not cut either.
+fn cut_warped_images(n: &mut Node, warped: &WarpedImages) {
+    cut_warped_images_within(n, warped, crate::distort::MAX_COPY_OBJECTS);
+}
+
+/// [`cut_warped_images`] with the art keeping to `max` nodes.
+pub(crate) fn cut_warped_images_within(n: &mut Node, warped: &WarpedImages, max: usize) {
+    if warped.images.is_empty() {
+        return;
+    }
+    let cut = warped.fits(n, max);
+    restore_warped_images(n, warped, cut);
+}
+
+/// The walk of [`cut_warped_images`]: each listed image gets its key back, and with `cut` is cut
+/// into pieces.
+fn restore_warped_images(n: &mut Node, warped: &WarpedImages, cut: bool) {
+    let Some(children) = n.children_mut() else { return };
+    for c in children.iter_mut() {
+        let NodeKind::Image(im) = &c.kind else {
+            if c.children().is_some() {
+                restore_warped_images(Arc::make_mut(c), warped, cut);
+            }
+            continue;
+        };
+        let Some((key, warps)) = warped.get(&im.key) else { continue };
+        let mut image = (**c).clone();
+        let NodeKind::Image(own) = &mut image.kind else { continue };
+        own.key = key.clone();
+        // The pieces start from the image as it was placed when it took its first warp.
+        let first = warps.first().map(|(_, at)| ImageObject { xf: *at, ..(**own).clone() });
+        let map = warped_map(warps, own.xf);
+        *c = Arc::new(match (first, map) {
+            (Some(first), Some(map)) if cut => {
+                let pixelated = image.extras().pixelated;
+                vectorcraft_doc::live::mesh_warp_image(&image, &first, &*map, WARP_IMAGE_CELLS, pixelated, false)
+            }
+            _ => image,
+        });
+    }
+}
+
+/// The map that takes a point of an image placed by the first of `warps`' placements to where the
+/// warps and the moves between them take it, for an image now placed by `placed`: each warp in
+/// turn, then the move from the placement the image had when it took that warp to the one it had
+/// at the next, or to `placed` after the last. `None` when a placement has no inverse.
+fn warped_map(warps: &[(WarpMap, Affine)], placed: Affine) -> Option<Box<dyn Fn(Point) -> Point>> {
+    let mut steps: Vec<(WarpMap, Affine)> = Vec::with_capacity(warps.len());
+    for (i, (f, at)) in warps.iter().enumerate() {
+        let det = at.determinant();
+        if !det.is_finite() || det == 0.0 {
+            return None;
+        }
+        let next = warps.get(i + 1).map_or(placed, |(_, at)| *at);
+        let m = next * at.inverse();
+        if !m.is_finite() {
+            return None;
+        }
+        steps.push((f.clone(), m));
+    }
+    Some(Box::new(move |p| steps.iter().fold(p, |q, (f, m)| *m * f(q))))
+}
+
+/// How many paths [`for_each_leaf`] visits in `n`.
+fn leaf_count(n: &Node) -> usize {
+    match &n.kind {
+        NodeKind::Path { guide: false, .. } | NodeKind::Compound { .. } => 1,
+        NodeKind::Group { children, .. } | NodeKind::Layer { children, .. } => children.iter().map(|c| leaf_count(c)).sum(),
+        _ => 0,
+    }
+}
+
 /// An object that a Transform effect places through its transform rather than reshapes: an image
 /// (pixel space to document) or a symbol instance (the symbol's art to document).
 fn is_placed(n: &Node) -> bool {

crates/effects/src/tests.rs

@@ -369,6 +369,317 @@ fn stacked_transform_copies_stay_within_the_image_budget() {
     assert_eq!(count(&evaluate_container(None, &g).unwrap()), 1001);
 }
 
+/// A 40 × 40 px image placed at (0, 0) at one point a pixel, with id `id`.
+fn warp_test_image(id: u64) -> std::sync::Arc<Node> {
+    use vectorcraft_doc::{ImageObject, NodeId};
+    let im = ImageObject { key: "k".into(), width: 40, height: 40, xf: Affine::IDENTITY, link: None, placement: Default::default(), pixels: None };
+    std::sync::Arc::new(Node::new(NodeId(id), NodeKind::Image(Box::new(im))))
+}
+
+/// How many images `art` holds, and the keys they have.
+fn warp_test_images(art: &Node) -> (usize, std::collections::BTreeSet<String>) {
+    let (mut n, mut keys) = (0, std::collections::BTreeSet::new());
+    art.walk(&mut |c| {
+        if let NodeKind::Image(im) = &c.kind {
+            n += 1;
+            keys.insert(im.key.clone());
+        }
+    });
+    (n, keys)
+}
+
+#[test]
+fn warped_images_stay_within_the_object_budget() {
+    use std::rc::Rc;
+    use std::sync::Arc;
+
+    use vectorcraft_doc::NodeId;
+    let lift: crate::reshape::WarpMap = Rc::new(|p: Point| Point::new(p.x, p.y - p.x * 0.1));
+    let cost = vectorcraft_doc::live::mesh_warp_cost(crate::reshape::WARP_IMAGE_CELLS);
+    let none = std::collections::HashSet::new();
+    let k = || std::collections::BTreeSet::from(["k".to_string()]);
+    let warp = |art: &mut Node, warps: usize| {
+        let mut warped = crate::reshape::WarpedImages::new();
+        for _ in 0..warps {
+            crate::reshape::mark_warped_images(art, &lift, &none, false, &mut 0, &mut warped);
+        }
+        warped
+    };
+    // The art has room for one image's pieces only: neither image is cut, and each gets its own
+    // key back.
+    let mut art = Node::group(NodeId(1), vec![warp_test_image(2), warp_test_image(3)]);
+    let warped = warp(&mut art, 1);
+    let max = art.count() + cost;
+    crate::reshape::cut_warped_images_within(&mut art, &warped, max);
+    assert_eq!(warp_test_images(&art), (2, k()));
+    // With room for both, each is cut into 200 pieces once, however many warps it took.
+    let mut art = Node::group(NodeId(1), vec![warp_test_image(2), warp_test_image(3)]);
+    let warped = warp(&mut art, 3);
+    let max = art.count() + 2 * cost;
+    crate::reshape::cut_warped_images_within(&mut art, &warped, max);
+    assert_eq!(warp_test_images(&art), (400, k()));
+    // Images clipped by their frames: the second frame (the second path) kept its shape, so its
+    // image stays whole, and the first is cut. The third's frame is a group of two paths, the
+    // second of them kept, with an image after them, and its image sits in a group of its own:
+    // both stay whole too.
+    let frame = |id: u64| Arc::new(Node::path(NodeId(id), shapes::rectangle(Rect::new(0.0, 0.0, 40.0, 40.0)), Default::default()));
+    let clip_group = |id: u64, children: Vec<Arc<Node>>| Arc::new(Node::new(NodeId(id), NodeKind::Group { children, clip: true }));
+    let nested = clip_group(
+        4,
+        vec![
+            Arc::new(Node::group(NodeId(4), vec![frame(4), frame(4), warp_test_image(5)])),
+            Arc::new(Node::group(NodeId(4), vec![warp_test_image(4)])),
+        ],
+    );
+    let mut art =
+        Node::group(NodeId(1), vec![clip_group(2, vec![frame(2), warp_test_image(2)]), clip_group(3, vec![frame(3), warp_test_image(3)]), nested]);
+    let (mut at, mut warped) = (0, crate::reshape::WarpedImages::new());
+    crate::reshape::mark_warped_images(&mut art, &lift, &std::collections::HashSet::from([1, 3]), false, &mut at, &mut warped);
+    assert_eq!(at, 4);
+    crate::reshape::cut_warped_images_within(&mut art, &warped, usize::MAX);
+    assert_eq!(warp_test_images(&art), (203, k()));
+}
+
+/// An image key from the document that looks like a key of the table is not read as one, and a
+/// hidden image stays out of the bounds the later effects take, as it does before it is warped.
+#[test]
+fn warped_images_keep_document_keys_and_hidden_images_apart() {
+    use std::rc::Rc;
+    use std::sync::Arc;
+
+    use vectorcraft_doc::NodeId;
+    let lift: crate::reshape::WarpMap = Rc::new(|p: Point| Point::new(p.x, p.y - p.x * 0.1));
+    let none = std::collections::HashSet::new();
+    let mut warped = crate::reshape::WarpedImages::new();
+    let lookalike = format!("{}0", warped.prefix());
+    let mut b = (*warp_test_image(3)).clone();
+    if let NodeKind::Image(im) = &mut b.kind {
+        im.key = lookalike.clone();
+    }
+    let mut art = Node::group(NodeId(1), vec![warp_test_image(2), Arc::new(b)]);
+    warped.reserve(&art);
+    crate::reshape::mark_warped_images(&mut art, &lift, &none, false, &mut 0, &mut warped);
+    crate::reshape::cut_warped_images_within(&mut art, &warped, usize::MAX);
+    assert_eq!(warp_test_images(&art), (400, std::collections::BTreeSet::from(["k".to_string(), lookalike])));
+    // A layer of a 10 × 10 square and a hidden 40 × 40 image: the warped image is not measured.
+    let square = Arc::new(Node::path(NodeId(4), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::default()));
+    let mut hidden = (*warp_test_image(5)).clone();
+    hidden.visible = false;
+    let mut layer = Node::layer(NodeId(6), "Layer 1", vectorcraft_doc::LayerColor::Preset(0));
+    if let Some(children) = layer.children_mut() {
+        *children = vec![square, Arc::new(hidden)];
+    }
+    let before = layer.geometric_bounds();
+    let mut warped = crate::reshape::WarpedImages::new();
+    warped.reserve(&layer);
+    crate::reshape::mark_warped_images(&mut layer, &lift, &none, false, &mut 0, &mut warped);
+    assert_eq!(warped.bounds(&layer), before);
+    // A shown image is measured by the pieces it is cut into.
+    let mut art = Node::group(NodeId(1), vec![warp_test_image(2)]);
+    let mut warped = crate::reshape::WarpedImages::new();
+    warped.reserve(&art);
+    crate::reshape::mark_warped_images(&mut art, &lift, &none, false, &mut 0, &mut warped);
+    let measured = warped.bounds(&art);
+    crate::reshape::cut_warped_images_within(&mut art, &warped, usize::MAX);
+    assert_eq!(measured, art.geometric_bounds());
+    assert!(measured.is_some_and(|b| b.y0 < -3.9), "{measured:?}");
+    // An image placed at a tiny scale (a placement with a tiny determinant) is cut too; one placed
+    // with no area is not.
+    for (scale, pieces) in [(1e-7, 200), (0.0, 1)] {
+        let mut image = (*warp_test_image(2)).clone();
+        if let NodeKind::Image(im) = &mut image.kind {
+            im.xf = Affine::scale(scale);
+        }
+        let mut art = Node::group(NodeId(1), vec![Arc::new(image)]);
+        let mut warped = crate::reshape::WarpedImages::new();
+        crate::reshape::mark_warped_images(&mut art, &lift, &none, false, &mut 0, &mut warped);
+        crate::reshape::cut_warped_images_within(&mut art, &warped, usize::MAX);
+        assert_eq!(warp_test_images(&art).0, pieces, "{scale}");
+    }
+}
+
+/// An image whose frame keeps its shape because the warp would pass the anchor budget keeps its
+/// pixels as they are; within the budget, both bend.
+#[test]
+fn an_image_whose_frame_passes_the_budget_stays_whole() {
+    use std::sync::Arc;
+
+    use vectorcraft_doc::NodeId;
+    let clipped = || {
+        let mut frame = Node::path(NodeId(1), shapes::rectangle(Rect::new(0.0, 0.0, 40.0, 40.0)), Appearance::default());
+        if let NodeKind::Path { clipping, .. } = &mut frame.kind {
+            *clipping = true;
+        }
+        Node::new(NodeId(1), NodeKind::Group { children: vec![Arc::new(frame), warp_test_image(1)], clip: true })
+    };
+    let arc = fx("warp.arc", json!({"bend": 50, "version": 1}));
+    let k = || std::collections::BTreeSet::from(["k".to_string()]);
+    let mut art = clipped();
+    crate::reshape::reshape_leaves_within(&mut art, &[&arc], Budget { anchors: 0, lines: 0 }, None);
+    assert_eq!(art.children().and_then(|c| c.first()).and_then(|c| c.path_data()).map(|p| p.anchor_count()), Some(4));
+    assert_eq!(warp_test_images(&art), (1, k()));
+    let mut art = clipped();
+    crate::reshape::reshape_leaves_within(&mut art, &[&arc], Budget::EFFECTS, None);
+    assert!(art.children().and_then(|c| c.first()).and_then(|c| c.path_data()).is_some_and(|p| p.anchor_count() > 4));
+    assert_eq!(warp_test_images(&art), (200, k()));
+}
+
+/// The first image under `n` (the first piece of a cut image).
+fn first_image(n: &Node) -> Option<vectorcraft_doc::ImageObject> {
+    let mut first = None;
+    n.walk(&mut |c| {
+        if first.is_none()
+            && let NodeKind::Image(im) = &c.kind
+        {
+            first = Some((**im).clone());
+        }
+    });
+    first
+}
+
+#[test]
+fn effects_after_a_warp_reshape_an_images_frame_and_not_its_pieces() {
+    let image = |effects: Vec<Effect>| {
+        let mut n = (*warp_test_image(1)).clone();
+        n.appearance.effects = effects;
+        n
+    };
+    // Each piece's clipping path, and the image's frame (the outer clip group's clipping path).
+    let clips = |art: &Node| {
+        let (mut pieces, mut frame) = (vec![], None);
+        art.walk(&mut |c| {
+            if let NodeKind::Group { children, clip: true } = &c.kind
+                && let Some(path) = children.first().and_then(|p| p.path_data())
+            {
+                if matches!(children.get(1).map(|i| &i.kind), Some(NodeKind::Image(_))) && path.anchor_count() == 3 {
+                    pieces.push(path.anchor_count());
+                } else if frame.is_none() {
+                    frame = Some(path.anchor_count());
+                }
+            }
+        });
+        (pieces, frame)
+    };
+    let arc = fx("warp.arc", json!({"bend": 50, "version": 1}));
+    for after in [
+        fx("distort.roughen", json!({"size": 5, "detail": 10})),
+        fx("stylize.roundCorners", json!({"radius": 5})),
+        fx("path.offsetPath", json!({"offset": -2})),
+    ] {
+        let art = crate::reshape::reshape(None, &image(vec![arc.clone(), after.clone()]), None).unwrap();
+        let (pieces, frame) = clips(&art);
+        assert_eq!(pieces.len(), 200, "{}", after.id);
+        assert!(frame.is_some_and(|n| n > 4), "{}: {frame:?}", after.id);
+        assert_eq!(warp_test_images(&art), (200, std::collections::BTreeSet::from(["k".to_string()])), "{}", after.id);
+    }
+    // Two warps cut the image once, through both maps; a Transform after them moves the pieces.
+    let flag = fx("warp.flag", json!({"bend": 30, "version": 1}));
+    let mv = fx("distort.transform", json!({"moveH": 100, "moveV": 0}));
+    let art = crate::reshape::reshape(None, &image(vec![arc.clone(), flag.clone()]), None).unwrap();
+    assert_eq!(warp_test_images(&art).0, 200);
+    let moved = crate::reshape::reshape(None, &image(vec![arc.clone(), flag.clone(), mv]), None).unwrap();
+    assert_eq!(warp_test_images(&moved).0, 200);
+    let box1 = Rect::new(0.0, 0.0, 40.0, 40.0);
+    let f1 = crate::warp::warp_map(box1, crate::warp::WarpStyle::Arc, &merged_params("warp.arc", &arc.params));
+    // The flag bends the box the arc leaves, which the arc's frame measures.
+    let box2 = crate::reshape::reshape(None, &image(vec![arc.clone()]), None).unwrap().geometric_bounds().unwrap();
+    let f2 = crate::warp::warp_map(box2, crate::warp::WarpStyle::Flag, &merged_params("warp.flag", &flag.params));
+    // The first piece's corners: the pixels (0, 0), (4, 0) and (4, 4).
+    for (art, by) in [(&art, 0.0), (&moved, 100.0)] {
+        let piece = first_image(art).unwrap();
+        for p in [Point::new(0.0, 0.0), Point::new(4.0, 0.0), Point::new(4.0, 4.0)] {
+            let want = f2(f1(p)) + vectorcraft_geom::Vec2::new(by, 0.0);
+            assert!((piece.xf * p).distance(want) < 1e-6, "{p:?}: {:?} {want:?}", piece.xf * p);
+        }
+    }
+}
+
+/// A warp with no version (VectorCraft's earlier map) bends an image's pixels with that map, as it
+/// bends the frame.
+#[test]
+fn an_images_pixels_take_the_map_their_warps_version_names() {
+    for version in [json!(null), json!(0), json!(1)] {
+        let mut params = json!({"bend": 50});
+        if !version.is_null() {
+            params["version"] = version.clone();
+        }
+        let mut n = (*warp_test_image(1)).clone();
+        n.appearance.effects = vec![fx("warp.arc", params.clone())];
+        let art = crate::reshape::reshape(None, &n, None).unwrap();
+        let f = crate::warp::warp_map(Rect::new(0.0, 0.0, 40.0, 40.0), crate::warp::WarpStyle::Arc, &merged_params("warp.arc", &params));
+        let piece = first_image(&art).unwrap();
+        for p in [Point::new(0.0, 0.0), Point::new(4.0, 0.0), Point::new(4.0, 4.0)] {
+            assert!((piece.xf * p).distance(f(p)) < 1e-6, "{version}: {p:?}");
+        }
+        // The frame has an anchor where the map takes each corner.
+        let frame = art.children().and_then(|c| c.first()).and_then(|c| c.path_data()).unwrap();
+        for corner in [Point::new(0.0, 0.0), Point::new(40.0, 0.0), Point::new(40.0, 40.0), Point::new(0.0, 40.0)] {
+            let near = frame.subpaths.iter().flat_map(|s| &s.anchors).any(|a| a.p.distance(f(corner)) < 1e-6);
+            assert!(near, "{version}: {corner:?}");
+        }
+    }
+}
+
+/// Under a group's Warp effect, a nested group's own placed gradient follows the nested group's
+/// bounds to where its image's pieces draw them.
+#[test]
+fn a_nested_groups_gradient_follows_its_warped_image() {
+    use std::sync::Arc;
+
+    use vectorcraft_color::{Color, Gradient, GradientGeom, GradientKind, GradientPaint, GradientStop, Paint};
+    use vectorcraft_doc::{Appearance, AppearanceItem, FillLayer, NodeId};
+    let stops = vec![GradientStop::new(0.0, Color::rgb(1.0, 0.0, 0.0)), GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0))];
+    let geom = GradientGeom { start: (5.0, 20.0).into(), end: (35.0, 20.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 mut inner = Node::group(NodeId(5), vec![warp_test_image(1)]);
+    inner.appearance.items.push(AppearanceItem::Fill(FillLayer::new(placed)));
+    let square = Node::path(NodeId(2), shapes::rectangle(Rect::new(60.0, 0.0, 100.0, 40.0)), Appearance::default());
+    let mut g = Node::group(NodeId(10), vec![Arc::new(inner), Arc::new(square)]);
+    g.appearance.effects.push(fx("warp.arc", json!({"bend": 50, "version": 1})));
+    let art = crate::group::evaluate_container(None, &g).unwrap();
+    assert_eq!(warp_test_images(&art).0, 200);
+    let (from, mut to) = (Rect::new(0.0, 0.0, 40.0, 40.0), None);
+    art.walk(&mut |c| {
+        if c.id == NodeId(5) && to.is_none() {
+            to = c.geometric_bounds();
+        }
+    });
+    let to = to.unwrap();
+    assert!(to.y0 < from.y0 - 1.0, "the pieces draw the image bent: {to:?}");
+    let follow = |p: Point| Point::new(to.x0 + (p.x - from.x0) / from.width() * to.width(), to.y0 + (p.y - from.y0) / from.height() * to.height());
+    let mut checked = 0;
+    art.walk(&mut |c| {
+        if c.id != NodeId(5) {
+            return;
+        }
+        for item in &c.appearance.items {
+            let Paint::Gradient(gp) = item.paint() else { continue };
+            let got = gp.geom.unwrap();
+            assert!(got.start.distance(follow(geom.start)) < 1e-6 && got.end.distance(follow(geom.end)) < 1e-6, "{got:?} in {to:?}");
+            checked += 1;
+        }
+    });
+    assert!(checked > 0);
+}
+
+/// An image under a geometry effect other than a Warp draws as the image does: colorized by
+/// a grayscale image's fill color, and smoothed or not.
+#[test]
+fn an_image_under_a_geometry_effect_keeps_its_color_and_smoothing() {
+    let mut n = (*warp_test_image(1)).clone();
+    n.appearance.effects = vec![fx("distort.roughen", json!({"size": 5, "detail": 10}))];
+    n.extras_mut().colorize = Some(Box::new(vectorcraft_color::Paint::solid(vectorcraft_color::Color::rgb(1.0, 0.0, 0.0))));
+    n.extras_mut().pixelated = true;
+    let art = crate::reshape::reshape(None, &n, None).unwrap();
+    let mut seen = vec![];
+    art.walk(&mut |c| {
+        if matches!(c.kind, NodeKind::Image(_)) {
+            seen.push((c.extras().colorize.clone(), c.extras().pixelated));
+        }
+    });
+    assert_eq!(seen, vec![(n.extras().colorize.clone(), true)]);
+}
+
 /// What `effects` make of `path` within `budget`.
 fn within(effects: &[Effect], path: &PathData, budget: Budget) -> PathData {
     apply_geometry_within(effects, path, path.bounds().unwrap(), &GeomContext::default(), budget)

crates/effects/src/warp.rs

@@ -20,25 +20,30 @@ pub fn map_version(p: &Value) -> u32 {
 
 /// Apply a warp to `path` using box `b`, making at most `max` anchors ([`map_nonlinear_within`]).
 pub fn warp(path: &PathData, b: Rect, style: WarpStyle, p: &Value, max: usize) -> PathData {
+    let piece = b.width().hypot(b.height()) / 24.0;
+    map_nonlinear_within(path, piece, max, warp_map(b, style, p))
+}
+
+/// The point map a warp of `style` with params `p` applies to box `b`: what [`warp`] moves each
+/// point of a path to.
+pub(crate) fn warp_map(b: Rect, style: WarpStyle, p: &Value) -> Box<dyn Fn(Point) -> Point> {
     let bend = num(p, "bend", 50.0).clamp(-100.0, 100.0) / 100.0;
     let dh = num(p, "horizontal", 0.0).clamp(-100.0, 100.0) / 100.0;
     let dv = num(p, "vertical", 0.0).clamp(-100.0, 100.0) / 100.0;
     let vertical = text(p, "orientation", "horizontal").eq_ignore_ascii_case("vertical");
-    let piece = b.width().hypot(b.height()) / 24.0;
     if uses_net(map_version(p)) {
         let net = WarpNet::new(style, bend, dh, dv, b.width(), b.height(), vertical);
         let (w, h) = (b.width(), b.height());
         // A box with no width or no height takes the middle of the patch along that side.
-        let f = |q: Point| {
+        return Box::new(move |q: Point| {
             let (u, v) = (if w > 0.0 { (q.x - b.x0) / w } else { 0.5 }, if h > 0.0 { (q.y - b.y0) / h } else { 0.5 });
             b.origin() + net.at(u, v).to_vec2()
-        };
-        return map_nonlinear_within(path, piece, max, f);
+        });
     }
     let c = b.center();
     let hw = (b.width() / 2.0).max(1e-9);
     let hh = (b.height() / 2.0).max(1e-9);
-    let f = |q: Point| {
+    Box::new(move |q: Point| {
         let (x, y) = ((q.x - c.x) / hw, (q.y - c.y) / hh);
         let (x2, y2) = if vertical {
             let (a, b2) = warp_point(style, bend, dh, dv, hw / hh, y, x);
@@ -47,8 +52,7 @@ pub fn warp(path: &PathData, b: Rect, style: WarpStyle, p: &Value, max: usize) -
             warp_point(style, bend, dh, dv, hh / hw, x, y)
         };
         Point::new(c.x + x2 * hw, c.y + y2 * hh)
-    };
-    map_nonlinear_within(path, piece, max, f)
+    })
 }
 
 /// Does warp effect `id` with params `p` move any point? Every style leaves the box as it is with

crates/engine/src/tests.rs

@@ -205,6 +205,7 @@ mod typescale;
 mod typeundo;
 mod units;
 mod variables;
+mod warp_images;
 mod webexport;
 mod widthpoints;
 mod widthprofiles;

crates/engine/src/tests/envelope_distort.rs

@@ -154,6 +154,35 @@ fn images_bend_as_a_raster_mesh_warp() {
     assert_eq!(svg.matches("<image").count(), 1, "the pieces share the image's pixels");
 }
 
+#[test]
+fn a_colorized_image_keeps_its_color_in_an_envelope() {
+    let mut s = session();
+    let img = image::GrayImage::from_pixel(4, 4, image::Luma([0]));
+    let mut png = vec![];
+    image::DynamicImage::ImageLuma8(img).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+    let im = s
+        .edit("Place", |d, sel| {
+            d.images.insert("gray".into(), vectorcraft_doc::ImageBlob::png(png));
+            let id = d.alloc_id();
+            let xf = Affine::translate((100.0, 100.0)) * Affine::scale(10.0);
+            let im =
+                vectorcraft_doc::ImageObject { key: "gray".into(), width: 4, height: 4, xf, link: None, placement: Default::default(), pixels: None };
+            d.insert(d.default_layer(), 0, Node::new(id, NodeKind::Image(Box::new(im))))?;
+            sel.set([id]);
+            Ok(id)
+        })
+        .unwrap();
+    s.execute("paint.setFill", &json!({"color": "#ff0000", "ids": [im.0]})).unwrap();
+    sel(&mut s, &[im]);
+    arch(&mut s, 80.0, json!({}));
+    let img = vectorcraft_render::Renderer::new().render_region(&s.doc().unwrap().doc, Rect::new(0.0, 0.0, 200.0, 200.0), 1.0, true);
+    // The black pixels draw in the fill color, in the bent shape.
+    let mid = img.pixel(120, 97);
+    assert!(mid[0] > 200 && mid[1] < 60 && mid[2] < 60, "the middle rose, red: {mid:?}");
+    let inside = img.pixel(120, 120);
+    assert!(inside[0] > 200 && inside[1] < 60 && inside[2] < 60, "red inside: {inside:?}");
+}
+
 /// A selected embedded 2×2 image, 80×80 pt at (100, 100): a red column left of a blue one.
 fn two_color_image(s: &mut Session) -> NodeId {
     let img = image::RgbaImage::from_fn(2, 2, |x, _| if x == 0 { image::Rgba([255, 0, 0, 255]) } else { image::Rgba([0, 0, 255, 255]) });

crates/engine/src/tests/warp_images.rs

@@ -0,0 +1,293 @@
+//! Effect › Warp on placed images: the pixels bend with the frame, in the canvas and in exports.
+
+use serde_json::{Value, json};
+use vectorcraft_doc::live::{WarpNet, WarpStyle, uses_net, warp_version};
+use vectorcraft_doc::{Node, NodeKind};
+use vectorcraft_geom::{Affine, Point, Rect};
+
+use crate::*;
+
+fn session() -> Session {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
+    s
+}
+
+/// The box of the image [`quarters`] places.
+const FRAME: Rect = Rect::new(100.0, 100.0, 180.0, 180.0);
+
+/// The color of the quarter of the image [`quarters`] places that holds (u, v) of its box: red top
+/// left, green top right, blue bottom left, yellow bottom right.
+fn quarter(u: f64, v: f64) -> [u8; 3] {
+    match (u < 0.5, v < 0.5) {
+        (true, true) => [255, 0, 0],
+        (false, true) => [0, 255, 0],
+        (true, false) => [0, 0, 255],
+        (false, false) => [255, 255, 0],
+    }
+}
+
+/// A selected embedded 40×40 px image filling [`FRAME`], each quarter one color ([`quarter`]).
+fn quarters(s: &mut Session) -> NodeId {
+    let img = image::RgbaImage::from_fn(40, 40, |x, y| {
+        let [r, g, b] = quarter(x as f64 / 40.0, y as f64 / 40.0);
+        image::Rgba([r, g, b, 255])
+    });
+    let mut png = vec![];
+    img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+    s.edit("Place", |d, sel| {
+        d.images.insert("quarters".into(), vectorcraft_doc::ImageBlob::png(png));
+        let id = d.alloc_id();
+        let xf = Affine::translate((FRAME.x0, FRAME.y0)) * Affine::scale(2.0);
+        let im = vectorcraft_doc::ImageObject {
+            key: "quarters".into(),
+            width: 40,
+            height: 40,
+            xf,
+            link: None,
+            placement: Default::default(),
+            pixels: None,
+        };
+        d.insert(d.default_layer(), 0, Node::new(id, NodeKind::Image(Box::new(im))))?;
+        sel.set([id]);
+        Ok(id)
+    })
+    .unwrap()
+}
+
+/// Where an Arc warp bending `bend` % takes the point at (u, v) of [`FRAME`].
+fn arced(bend: f64, u: f64, v: f64) -> Point {
+    let net = WarpNet::new(WarpStyle::Arc, bend / 100.0, 0.0, 0.0, FRAME.width(), FRAME.height(), false);
+    FRAME.origin() + net.at(u, v).to_vec2()
+}
+
+/// Points of the image's box: near each quarter's middle and on both sides of the line between
+/// the top and bottom quarters, where a warp that moves the pixels up or down changes the color.
+const SAMPLES: [(f64, f64); 10] =
+    [(0.2, 0.2), (0.8, 0.2), (0.2, 0.8), (0.8, 0.8), (0.4, 0.4), (0.6, 0.4), (0.4, 0.6), (0.6, 0.6), (0.3, 0.62), (0.7, 0.62)];
+
+/// The document drawn over (0, 0)–(400, 400) at one pixel a point, on white.
+fn drawn(s: &Session) -> vectorcraft_render::Rendered {
+    vectorcraft_render::Renderer::new().render_region(&s.doc().unwrap().doc, Rect::new(0.0, 0.0, 400.0, 400.0), 1.0, true)
+}
+
+/// The sample points whose color in `img` at `at(u, v)` is not the image's color at (u, v).
+fn wrong(img: &vectorcraft_render::Rendered, at: &dyn Fn(f64, f64) -> Point) -> Vec<(f64, f64, [u8; 4])> {
+    SAMPLES
+        .iter()
+        .filter_map(|&(u, v)| {
+            let p = at(u, v);
+            let px = img.pixel(p.x.floor() as u32, p.y.floor() as u32);
+            let want = quarter(u, v);
+            let near = (0..3).all(|i| (px[i] as i32 - want[i] as i32).abs() <= 40);
+            (!near).then_some((u, v, px))
+        })
+        .collect()
+}
+
+/// `quarters` with Effect › Warp › Arc at 50 %: the warp the effect holds, checked to be the
+/// Bézier patch [`arced`] follows.
+fn arc_image(s: &mut Session) -> NodeId {
+    let id = quarters(s);
+    s.execute("effect.apply", &json!({"effect": "warp.arc", "params": {"bend": 50}})).unwrap();
+    let n = s.doc().unwrap().doc.node(id).unwrap().clone();
+    let e = &n.appearance.effects[0];
+    assert!(warp_version(&e.params["version"]).is_some_and(uses_net), "{}", e.params);
+    id
+}
+
+fn decoded(v: &Value) -> Vec<u8> {
+    vectorcraft_format::base64_decode(v["dataBase64"].as_str().unwrap()).unwrap()
+}
+
+#[test]
+fn an_images_pixels_bend_with_effect_warp() {
+    let mut s = session();
+    let id = arc_image(&mut s);
+    // The arc lifts the middle of the image: the line between the quarters rises there.
+    assert!(arced(50.0, 0.5, 0.6).y < FRAME.y0 + 0.5 * FRAME.height(), "{:?}", arced(50.0, 0.5, 0.6));
+    let bent = drawn(&s);
+    assert_eq!(wrong(&bent, &|u, v| arced(50.0, u, v)), vec![], "each pixel is drawn where the warp takes it");
+    // Drawn as pieces of the one image, each placed by the warp.
+    let d = &s.doc().unwrap().doc;
+    let art = vectorcraft_render::effects::reshape(Some(d), d.node(id).unwrap(), None).unwrap();
+    let mut pieces = 0;
+    art.walk(&mut |c| pieces += matches!(c.kind, NodeKind::Image(_)) as usize);
+    assert!(pieces >= 100, "{pieces} pieces");
+    // Removing the warp draws the image as it was, in one undo step.
+    let steps = s.doc().unwrap().history.undo.len();
+    s.execute("effect.remove", &json!({"index": 0})).unwrap();
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
+    let plain = |u: f64, v: f64| Point::new(FRAME.x0 + u * FRAME.width(), FRAME.y0 + v * FRAME.height());
+    assert_eq!(wrong(&drawn(&s), &plain), vec![]);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(wrong(&drawn(&s), &|u, v| arced(50.0, u, v)), vec![], "undo brings the bend back");
+}
+
+/// `out`, an export of [`arc_image`]'s document named `name`, opened again: it draws the image
+/// bent.
+fn opens_bent(name: &str, out: &Value) {
+    let mut back = session();
+    back.execute("document.open", &json!({"name": name, "dataBase64": out["dataBase64"]})).unwrap();
+    assert_eq!(wrong(&drawn(&back), &|u, v| arced(50.0, u, v)), vec![], "{name}");
+}
+
+#[test]
+fn a_warped_image_keeps_its_bend_in_svg() {
+    let mut s = session();
+    arc_image(&mut s);
+    let svg = s.execute("document.export", &json!({"format": "svg"})).unwrap();
+    let text = String::from_utf8(decoded(&svg)).unwrap();
+    assert_eq!(text.matches("<image").count(), 1, "the pieces share the image's pixels");
+    opens_bent("warped.svg", &svg);
+}
+
+#[test]
+fn a_warped_image_keeps_its_bend_in_pdf() {
+    let mut s = session();
+    arc_image(&mut s);
+    opens_bent("warped.pdf", &s.execute("document.export", &json!({"format": "pdf", "preserveEditing": false})).unwrap());
+}
+
+#[test]
+fn a_warped_image_keeps_its_bend_in_ai() {
+    let mut s = session();
+    arc_image(&mut s);
+    opens_bent("warped.ai", &s.execute("file.saveCopy", &json!({"format": "ai"})).unwrap());
+}
+
+#[test]
+fn a_warped_image_keeps_its_bend_in_eps() {
+    let mut s = session();
+    arc_image(&mut s);
+    opens_bent("warped.eps", &s.execute("document.exportEps", &json!({"previewFormat": "none", "useArtboards": false})).unwrap());
+}
+
+#[test]
+fn a_warped_image_keeps_its_bend_in_png() {
+    let mut s = session();
+    arc_image(&mut s);
+    let out = s.execute("document.export", &json!({"format": "png"})).unwrap();
+    let png = image::load_from_memory(&decoded(&out)).unwrap().to_rgba8();
+    // The artboard starts at (0, 0) and the export draws one pixel a point.
+    assert_eq!((png.width(), png.height()), (800, 600));
+    for &(u, v) in &SAMPLES {
+        let p = arced(50.0, u, v);
+        let px = png.get_pixel(p.x.floor() as u32, p.y.floor() as u32).0;
+        let want = quarter(u, v);
+        assert!((0..3).all(|i| (px[i] as i32 - want[i] as i32).abs() <= 40), "({u}, {v}) at {p:?}: {px:?}");
+    }
+}
+
+/// A group the user made of two clip groups of the same image, each clipped by a rectangle, writes
+/// the image once for each: only the pieces of a warp share one.
+#[test]
+fn svg_writes_an_image_clipped_twice_in_a_users_group_twice() {
+    let mut s = session();
+    let im = quarters(&mut s);
+    s.edit("Clip twice", |d, _| {
+        let image = d.node(im).cloned().unwrap();
+        let mut clipped = vec![];
+        for x in [FRAME.x0, FRAME.x0 + 40.0] {
+            let mut clip =
+                Node::path(d.alloc_id(), vectorcraft_geom::shapes::rectangle(Rect::new(x, FRAME.y0, x + 30.0, FRAME.y0 + 30.0)), Default::default());
+            if let NodeKind::Path { clipping, .. } = &mut clip.kind {
+                *clipping = true;
+            }
+            let image = Node { id: d.alloc_id(), ..image.clone() };
+            let children = vec![std::sync::Arc::new(clip), std::sync::Arc::new(image)];
+            clipped.push(std::sync::Arc::new(Node::new(d.alloc_id(), NodeKind::Group { children, clip: true })));
+        }
+        let group = Node::group(d.alloc_id(), clipped);
+        d.remove(im)?;
+        d.insert(d.default_layer(), 0, group)?;
+        Ok(())
+    })
+    .unwrap();
+    let svg = s.execute("document.export", &json!({"format": "svg"})).unwrap();
+    let text = String::from_utf8(decoded(&svg)).unwrap();
+    assert_eq!(text.matches("<image").count(), 2, "{text}");
+}
+
+/// Expand Appearance of a warped image gives objects that draw as the canvas did, with ids of
+/// their own, in one undo step.
+#[test]
+fn expand_appearance_of_a_warped_image_draws_as_the_canvas_did() {
+    let mut s = session();
+    let id = arc_image(&mut s);
+    let steps = s.doc().unwrap().history.undo.len();
+    s.execute("effect.expandAppearance", &json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
+    let d = &s.doc().unwrap().doc;
+    let mut ids = std::collections::HashSet::new();
+    let mut images = 0;
+    for layer in &d.layers {
+        layer.walk(&mut |c| {
+            assert!(ids.insert(c.id), "{:?} twice", c.id);
+            images += matches!(c.kind, NodeKind::Image(_)) as usize;
+            assert!(c.appearance.effects.iter().all(|e| !e.id.starts_with("warp.")));
+        });
+    }
+    assert!(images >= 100, "{images} pieces");
+    assert_eq!(wrong(&drawn(&s), &|u, v| arced(50.0, u, v)), vec![]);
+    s.execute("edit.undo", &json!({})).unwrap();
+    let n = s.doc().unwrap().doc.node(id).unwrap();
+    assert!(matches!(n.kind, NodeKind::Image(_)) && n.appearance.effects.len() == 1);
+    assert_eq!(wrong(&drawn(&s), &|u, v| arced(50.0, u, v)), vec![]);
+}
+
+/// A selected embedded grayscale 40×40 px image filling [`FRAME`], black above white, colorized
+/// red by its fill color: red above, nothing below.
+fn red_on_clear(s: &mut Session) -> NodeId {
+    let img = image::GrayImage::from_fn(40, 40, |_, y| image::Luma([if y < 20 { 0 } else { 255 }]));
+    let mut png = vec![];
+    image::DynamicImage::ImageLuma8(img).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+    let id = s
+        .edit("Place", |d, sel| {
+            d.images.insert("gray".into(), vectorcraft_doc::ImageBlob::png(png));
+            let id = d.alloc_id();
+            let xf = Affine::translate((FRAME.x0, FRAME.y0)) * Affine::scale(2.0);
+            let im = vectorcraft_doc::ImageObject {
+                key: "gray".into(),
+                width: 40,
+                height: 40,
+                xf,
+                link: None,
+                placement: Default::default(),
+                pixels: None,
+            };
+            d.insert(d.default_layer(), 0, Node::new(id, NodeKind::Image(Box::new(im))))?;
+            sel.set([id]);
+            Ok(id)
+        })
+        .unwrap();
+    s.execute("paint.setFill", &json!({"color": "#ff0000", "ids": [id.0]})).unwrap();
+    id
+}
+
+#[test]
+fn a_colorized_image_keeps_its_color_when_warped() {
+    let mut s = session();
+    red_on_clear(&mut s);
+    s.execute("effect.apply", &json!({"effect": "warp.arc", "params": {"bend": 50}})).unwrap();
+    let img = drawn(&s);
+    let (red, white) = ([255u8, 0, 0], [255u8, 255, 255]);
+    for (u, v, want) in [(0.5, 0.35, red), (0.2, 0.2, red), (0.5, 0.65, white), (0.8, 0.8, white)] {
+        let p = arced(50.0, u, v);
+        let px = img.pixel(p.x.floor() as u32, p.y.floor() as u32);
+        assert!((0..3).all(|i| (px[i] as i32 - want[i] as i32).abs() <= 40), "({u}, {v}) at {p:?}: {px:?}");
+    }
+}
+
+#[test]
+fn a_warp_on_a_group_bends_the_image_in_it() {
+    let mut s = session();
+    let im = quarters(&mut s);
+    // A group of the image and a line below it as wide as the image: the group's box is the image's.
+    let line = s.execute("shape.line", &json!({"x1": FRAME.x0, "y1": FRAME.y1, "x2": FRAME.x1, "y2": FRAME.y1})).unwrap();
+    let line = NodeId(line["id"].as_u64().unwrap());
+    s.execute("select.set", &json!({"ids": [im.0, line.0]})).unwrap();
+    s.execute("object.group", &json!({})).unwrap();
+    s.execute("effect.apply", &json!({"effect": "warp.arc", "params": {"bend": 50}})).unwrap();
+    assert_eq!(wrong(&drawn(&s), &|u, v| arced(50.0, u, v)), vec![]);
+}

crates/svg/src/export/nodes.rs

@@ -121,6 +121,21 @@ impl Reuse {
     }
 }
 
+/// Are `children` the pieces of a raster mesh warp ([`vectorcraft_doc::live::mesh_warp_image`]):
+/// more than one, each a clip group of a triangle and one and the same image?
+fn image_pieces(children: &[std::sync::Arc<Node>]) -> bool {
+    let mut first: Option<(&str, u32, u32)> = None;
+    children.len() > 1
+        && children.iter().all(|c| {
+            let NodeKind::Group { children, clip: true } = &c.kind else { return false };
+            let [clip, im] = children.as_slice() else { return false };
+            let (NodeKind::Path { path, .. }, NodeKind::Image(im)) = (&clip.kind, &im.kind) else { return false };
+            let triangle = path.subpaths.len() == 1 && path.anchor_count() == 3;
+            let image = (im.key.as_str(), im.width, im.height);
+            triangle && *first.get_or_insert(image) == image
+        })
+}
+
 /// Art about to be written moved by `m.inverse()` (a symbol instance's): map what the canvas
 /// leaves on the page by `m` first, so it stays there. That is every pattern paint's placement
 /// and the art of unlinked opacity masks.
@@ -678,6 +693,10 @@ impl Writer<'_> {
         match &n.kind {
             NodeKind::Layer { template: true, .. } => {}
             NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => {
+                // The pieces a Warp effect cuts an image into share its pixels, as an envelope's do.
+                if image_pieces(children) {
+                    self.share_images(n);
+                }
                 let id = self.id_attr(n);
                 let a = self.attrs(&self.group_props(n));
                 self.line(&format!("<g{id}{a}>"));

docs/mcp.md

@@ -3332,6 +3332,16 @@ that shape, and the effects before it are left out. Its Contents row stands for
 vector exports write those items as paths, and `effect.expandAppearance` turns them into objects in a group with the
 image.
 Use Preview Bounds measures an image by its frame.
+A Warp effect (`warp.arc` … `warp.twist`) on an image, or on a group that holds one, bends the image's pixels with its
+frame: after the last effect in the list, the image is cut into 10 × 10 cells of two triangles, each a clipped piece of
+the image under its own affine map. The cell count is VectorCraft's own. Effects after the Warp reshape only the frame,
+a second Warp bends the same pieces, and a Transform effect moves them. A placed gradient on a group that holds the
+image follows the group's bounds as the pieces draw them. The pieces keep the
+image's fill color when it colorizes a grayscale image, and so do the pieces an envelope cuts. Under any geometry
+effect, an image keeps that color and is drawn with or without smoothing as the image is. SVG writes the image once and
+draws the pieces with `<use>`; PDF, EPS, `.ai` and PNG write the bent pieces. Removing the warp shows the image as it
+was. The images stay unbent when their pieces would make the art pass 2 million objects, and an image stays unbent when
+its clipping frame keeps its shape because the warp would pass the effects' anchor budget.
 
 ```json
 {"name":"run_command","arguments":{"command":"appearance.addFill","params":{"ids":[7]}}}

docs/target-app-parity.md

@@ -591,6 +591,7 @@ since 2026-10-01.
 - **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.
 - **Placed gradients follow the Warp effects:** under each of the fifteen Warp styles with a bend or a distortion, a gradient placed with the Gradient tool moves and scales from the object's bounds before the warp to its bounds after it, as under Free Distort; a stroke's gradient uses those bounds inflated by the stroke. This holds for an object's own Warp and for a fill's or stroke's own, on the canvas and in Object › Expand of the fill. In a group with a Warp effect, each path's and compound path's gradients follow its own bounds, a nested group's own fills and strokes follow the nested group's bounds, and the group's own fills and strokes follow the group's bounds. In the art Pathfinder and compound shapes take, a symbol instance's Warp moves the gradients of its symbol's art by the art's bounds, and a compound shape's Warp moves its gradients by the bounds of its area. A gradient fitted to the object still fits the warped outline, and a warp with no bend and no distortion leaves the gradient exactly in place. Existing documents with a Warp effect on art with a placed gradient draw differently: before, the gradient stayed where it was while the outline changed. How gradients follow the warp is VectorCraft's own rule; what the Warp effects do to the object is described in [Reshaping with effects](https://helpx.adobe.com/illustrator/using/reshaping-objects-effects.html) (effects `tests::warp_bends_when_the_warp_moves_the_outline`, `bake::tests::baked_warps_move_placed_gradients_from_the_bounds_to_the_warped_bounds`, `bake::tests::a_warp_with_no_bend_leaves_a_placed_gradient_exactly_in_place`, `bake::tests::a_fills_and_a_strokes_own_warp_move_its_placed_gradient_with_the_bounds`, `group::tests::a_groups_warp_moves_the_gradients_placed_on_its_paths_by_each_paths_bounds`, `group::tests::a_groups_warp_moves_its_own_a_nested_groups_and_a_compound_paths_gradients_by_their_bounds`, `group::tests::shape_art_moves_the_gradients_of_a_symbol_instances_art_and_a_compound_shape_with_a_warp`; render `objectfx::a_paths_gradient_moves_and_scales_with_its_warped_bounds`; engine `objexpand::a_placed_gradient_moved_by_a_warp_expands_as_the_canvas_draws_it`). Scores and hours unchanged.
 - **Warp as a Bézier patch per style:** each of the fifteen Warp styles bends the object's bounds as one Bézier patch whose control points the style sets from the bend and the size of the bounds; the horizontal distortion then scales each column of control points about its middle and the vertical distortion scales each row. The Warp effects and warp envelopes share the map, and content with no width or no height takes the middle of the patch along that side. New warps, the built-in graphic styles' Warps and warps opened from `.ai` files carry `version` 1 for it. Warps in `.vectorcraft` documents saved before it read as `version` 0 and keep their earlier look, and edits keep a warp's version; a `version` 0 warp saved to `.ai` opens again with `version` 1, since the file holds only its settings. The patches are VectorCraft's own rules; the styles and ranges are those of the Warp options in [Distort and transform effects](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/distort-and-transform-effects-in-illustrator.html) (doc `live::tests::warp_nets_bend_each_style_as_its_own_patch`, `warp_net_arc_edges_are_concentric_circles`, `warp_net_distortion_scales_the_columns_then_the_rows`, `warp_net_takes_any_numbers`, `warp_net_bends_a_huge_box_without_overflowing`, `warp_envelopes_bend_flat_content_as_the_middle_of_the_patch`, `warp_envelopes_write_their_map_version_only_when_it_has_one`, `style_libs::tests::builtin_warp_styles_take_the_nets_map`; effects `tests::a_warp_draws_with_the_map_its_version_names`, `tests::a_warp_bends_a_flat_box_as_the_middle_of_its_patch`, `tests::new_warps_take_the_nets_version`; engine `effectedit::warps_keep_the_map_their_version_names`, `envelope::new_warp_envelopes_take_the_net_and_saved_ones_keep_their_map`; eps `ai_editing::tests::every_effect_a_graphic_style_holds_is_read_back`, `import::ai::tests::a_warp_envelope_opens_live`, `import::ai::tests::warp_envelopes_read_every_style`, `import::ai::style::tests::a_stack_of_fills_with_effects_of_their_own_is_read_as_itself`; ui-egui `dialogs::tests_warp::warp_options_edit_keeps_each_targets_map_version`). Scores and hours unchanged.
+- **Warp effects bend images:** a Warp effect on an image, or on a group that holds one, bends the image's pixels with its frame, as the Warp effect is documented to distort bitmap images in [Reshaping with effects](https://helpx.adobe.com/illustrator/using/reshaping-objects-effects.html): after the last effect, the image is cut into 10 × 10 cells of two triangles, each a clipped piece under its own affine map. Effects after the Warp reshape only the frame, a second Warp bends the same pieces, and warps saved without a version bend the pixels with their earlier map, as they bend the frame. A placed gradient on a group that holds the image follows the group's bounds as the pieces draw them. SVG writes the image once for the pieces; PDF, EPS, `.ai` and PNG write the bent pieces. The images stay unbent when their pieces would make the art pass 2 million objects, and so does an image whose frame keeps its shape past the anchor budget. A grayscale image's fill color now colorizes the pieces of a warp or an envelope, and an image under any geometry effect keeps that color and its smoothing setting. Existing documents with a Warp effect on an image, or on a group that holds one, draw differently: before, the image showed unbent, cut by the bent frame. So do existing documents with a colorized image under an envelope or a geometry effect, or an image drawn without smoothing under a geometry effect: before, those lost the color or the setting. The cell count and the limits are VectorCraft's own (effects `tests::warped_images_stay_within_the_object_budget`, `tests::warped_images_keep_document_keys_and_hidden_images_apart`, `tests::an_image_whose_frame_passes_the_budget_stays_whole`, `tests::effects_after_a_warp_reshape_an_images_frame_and_not_its_pieces`, `tests::an_images_pixels_take_the_map_their_warps_version_names`, `tests::an_image_under_a_geometry_effect_keeps_its_color_and_smoothing`, `tests::a_nested_groups_gradient_follows_its_warped_image`; engine `warp_images::an_images_pixels_bend_with_effect_warp`, `a_warped_image_keeps_its_bend_in_svg`, `a_warped_image_keeps_its_bend_in_pdf`, `a_warped_image_keeps_its_bend_in_ai`, `a_warped_image_keeps_its_bend_in_eps`, `a_warped_image_keeps_its_bend_in_png`, `svg_writes_an_image_clipped_twice_in_a_users_group_twice`, `expand_appearance_of_a_warped_image_draws_as_the_canvas_did`, `a_colorized_image_keeps_its_color_when_warped`, `a_warp_on_a_group_bends_the_image_in_it`, `envelope_distort::a_colorized_image_keeps_its_color_in_an_envelope`). Scores and hours unchanged.
 - **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.
 - **Fitted gradients turn with the Transform effect:** a gradient fitted to the object (not placed with the Gradient tool) turns, reflects and stretches with the object when its Transform effect rotates, reflects or scales it unevenly, as Object › Transform already does: the gradient is fixed to its fit on the geometry the effect takes, then follows the effect and the effects after it as a placed gradient does. Under moves and even scales it draws as a refit does, and a Transform effect that scales the object to nothing across leaves it fitted, with Scale Strokes & Effects or Transform Patterns on too, and on each copy. This holds on the canvas and in Object › Expand of the fill, for an object's own effects, a fill's or stroke's own, and a group's, where the gradients fitted to its paths, to its own fill, to the groups inside it and to its images' and symbol instances' own fills each fix to their own object's fit. Existing documents with such a Transform effect on fitted-gradient art draw differently: before, the gradient refit to the turned outline. The Gradient tool still shows a fitted gradient's vector at its unturned fit. How gradients follow the effect is VectorCraft's own rule; what the 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_fitted_gradient_turns_reflects_and_stretches_with_a_transform_effect`, `bake::tests::a_transform_effect_that_scales_to_nothing_leaves_a_fitted_gradient_fitted`, `group::tests::a_groups_transform_turns_the_gradients_fitted_to_its_members_and_its_own_fill`; render `objectfx::a_fitted_gradient_turns_and_reflects_with_its_transform_on_the_canvas`; engine `objexpand::a_fitted_gradient_turned_by_a_transform_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.