From d96b1fa89665021b97e62f84081c84366257b259 Mon Sep 17 00:00:00 2001 From: dotCooCoo Date: Mon, 16 Nov 2026 03:15:46 -0800 Subject: [PATCH] Effects: a member the raster budget leaves keeps its random move through Expand Appearance Expand Appearance expanded a group's or layer's evaluated members, and the object of a Crop Marks effect, before giving them new ids. When the raster budget refused the image for such a member that held a random Transform effect, the member stayed unexpanded, but its new id gave that effect a new seed, so the member moved while its effects stayed live. The group, layer or Crop Marks object now stays as it is in that case, as it does when its own raster effects go past the budget. The rollback also removes the images its other members added to the document and gives their charge back to the budget. --- crates/engine/src/cmd/effectcmd.rs | 93 +++++++++++++++++------- crates/engine/src/cmd/effectcmd/tests.rs | 87 ++++++++++++++++++++++ docs/target-app-parity.md | 1 + 3 files changed, 155 insertions(+), 26 deletions(-) diff --git a/crates/engine/src/cmd/effectcmd.rs b/crates/engine/src/cmd/effectcmd.rs index f21adcbc10..5ea3efd950 100644 --- a/crates/engine/src/cmd/effectcmd.rs +++ b/crates/engine/src/cmd/effectcmd.rs @@ -1040,7 +1040,8 @@ impl RasterBudget { /// of their own. Random in a Transform effect takes its seed from the id, and the canvas draws the /// pieces with the ids they have before that. `kept` gets the new id of each object in them that /// had an id `skip` lists before. Returns what each of those other members' expansions lists, by -/// the member's new id. +/// the member's new id. `Err` when such a member still holds a random Transform effect after the +/// raster budget left part of it as it is: its new ids would give that effect another seed. #[allow(clippy::too_many_arguments)] fn expand_pieces( d: &mut Document, @@ -1051,7 +1052,7 @@ fn expand_pieces( kept: &mut Vec, stroke_art: effects::StrokeArt, raster: &mut RasterBudget, -) -> std::collections::HashMap> { +) -> std::result::Result>, OverBudget> { let id = m.id; let mut seen = std::collections::HashSet::from([id]); let mut expanded = std::collections::HashMap::new(); @@ -1065,7 +1066,12 @@ fn expand_pieces( if all || c.id == id { effects::expand_art(d, c, stroke_art); } else if has_seeded(c) && repeats_an_id(c, &seen) { - listed = Some(expand_in_place(d, c, brushes, skip, raster)); + let left = raster.left; + let expanded = expand_in_place(d, c, brushes, skip, raster); + if raster.left > left && has_seeded(c) { + return Err(OverBudget); + } + listed = Some(expanded); } let mut was = vec![]; if !skip.is_empty() { @@ -1086,7 +1092,7 @@ fn expand_pieces( expanded.insert(c.id, listed); } } - expanded + Ok(expanded) } /// `m`, the art a 3D effect expanded into, with each object in it that has effects of its own (a @@ -1301,6 +1307,19 @@ fn carries_copies(n: &Node) -> bool { is_container(n) && effects::outer_effects(n).len() != n.appearance.effects.len() } +/// Does `n`, something in it, or the art of the symbol it places when a color adjustment makes it +/// that art, hold a random Transform effect ([`has_seeded`])? The raster budget can then leave `n` +/// as it is after part of it expanded ([`expand_pieces`], Crop Marks). +fn holds_seeded(d: &Document, n: &Node) -> bool { + has_seeded(n) + || match &n.kind { + NodeKind::SymbolInstance { symbol, .. } if effects::has_adjustment(n) => { + d.symbols.iter().find(|s| s.name == *symbol).is_some_and(|s| has_seeded(&s.art)) + } + _ => false, + } +} + /// [`expand_node`] of `n`, which need not be in `d`: `n` with its appearance expanded, `None` when /// it has nothing to expand. `out` gets the objects whose appearance expands, by places in the walk /// of the expanded `n`, `n`'s first when its own does. The objects `skip` lists are not expanded. @@ -1331,12 +1350,22 @@ fn expanded_node( _ => None, }; // The embedded images before the adjustment and the expansions of the copies - // ([`copies_carrying_raster`]), when the raster budget may yet leave `n` as it is: the - // recolored copies and the images those add then go again. - let images_before = ((effects::has_adjustment(&n) && !rasterfx::raster_fx(&n).is_empty()) || carries_copies(&n)) + // ([`copies_carrying_raster`]) and of the members that hold a random Transform effect, when the + // raster budget may yet leave `n` as it is: the recolored copies and the images those add then + // go again. + let images_before = ((effects::has_adjustment(&n) && !rasterfx::raster_fx(&n).is_empty()) || carries_copies(&n) || holds_seeded(d, &n)) .then(|| d.images.keys().cloned().collect::>()); // What the raster budget had left before those expansions: it gets back what they took. let budget_before = (raster.images, raster.pixels); + // `n` stays as it is: `out` lists nothing of it, and the document and the raster budget lose + // what expanding it added and took. + let leave = |d: &mut Document, out: &mut Vec, raster: &mut RasterBudget| { + out.truncate(listed_before); + if let Some(keys) = &images_before { + d.images.retain(|k, _| keys.contains(k)); + } + (raster.images, raster.pixels) = budget_before; + }; if effects::has_adjustment(&n) && let Some(m) = effects::adjust_in_document(d, &n, symbol_art) { @@ -1352,14 +1381,21 @@ fn expanded_node( let container = is_container(&n); // Crop Marks: the object and its marks become a group. The object expands on its own first, // with `id`: the canvas draws it with that id, which Random in a Transform effect takes its - // seed from. Then the object and the marks get ids of their own. + // seed from. Then the object and the marks get ids of their own. When the raster budget leaves + // a random Transform effect in the object, `n` stays as it is: new ids would give that effect + // another seed. if let Some(mut m) = effects::crop_marks_art(&n) { let mut seen = std::collections::HashSet::from([id]); let mut expanded = vec![]; for (i, c) in m.children_mut().into_iter().flatten().enumerate() { let c = Arc::make_mut(c); if i == 0 { + let left = raster.left; expanded = expand_in_place(d, c, brushes, skip, raster); + if raster.left > left && has_seeded(c) { + leave(d, out, raster); + return None; + } fresh_ids_listed(d, c, &mut seen, &mut expanded); } else { effects::fresh_ids(d, c, &mut seen); @@ -1390,16 +1426,13 @@ fn expanded_node( let copies = copies_carrying_raster(d, &mut n, (brushes, skip), &mut kept, &mut members, (out, &mut listed_n), raster); // Raster effects whose image would go past the budget stay: so does the object, with what is // inside it and its color adjustments (a symbol instance stays an instance of its symbol), and - // so does a group or layer whose copies keep a random Transform effect the budget left. + // so does a group or layer whose copies or members keep a random Transform effect the budget + // left. let Ok(image) = copies.and_then(|copied| { changed |= copied; raster_image(d, &n, raster) }) else { - out.truncate(listed_before); - if let Some(keys) = images_before { - d.images.retain(|k, _| keys.contains(k)); - } - (raster.images, raster.pixels) = budget_before; + leave(d, out, raster); return None; }; let mut v = n.clone(); @@ -1413,18 +1446,20 @@ fn expanded_node( image => { let m = if (container || matches!(n.kind, NodeKind::Text(_))) && (effects::has_solid(&v) || effects::has_revolve(&v)) { // A 3D effect on a group or layer, or on type: the shaded faces of its solids. - effects::expand_leaf(d, &v, &mut stroke_art) + Ok::<_, OverBudget>(effects::expand_leaf(d, &v, &mut stroke_art)) } else if container { // A group's or layer's own fills and strokes become art among its members. - effects::evaluate_container(Some(&*d), &v).map(|mut m| { - members.extend(expand_pieces(d, &mut m, false, brushes, skip, &mut kept, &mut stroke_art, raster)); - m - }) + effects::evaluate_container(Some(&*d), &v) + .map(|mut m| { + members.extend(expand_pieces(d, &mut m, false, brushes, skip, &mut kept, &mut stroke_art, raster)?); + Ok(m) + }) + .transpose() } else if matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. }) && !effects::has_transform_art(&v) && !effects::has_transform_copies(&v) { - effects::expand_leaf(d, &v, &mut stroke_art) + Ok(effects::expand_leaf(d, &v, &mut stroke_art)) } else { // Type, images, symbol instances, live objects (and paths whose Transform effect copies // them, each copy an object of its own, or changes their fills and strokes): through @@ -1440,12 +1475,18 @@ fn expanded_node( let row_raster = image.is_some() && effects::has_instance_row_raster(&n); let outlined = effects::expand_outlined(Some(&*d), &v, symbol.as_ref()) .or_else(|| if row_raster { effects::instance_as_art(Some(&*d), &v, symbol.as_ref()) } else { None }); - outlined.map(|mut m| { - let mut budget = vectorcraft_doc::MAX_SYMBOL_NODES; - expand_nested_instances(d, &mut m, 1, &mut budget, raster); - expand_pieces(d, &mut m, true, brushes, skip, &mut kept, &mut stroke_art, raster); - m - }) + outlined + .map(|mut m| { + let mut budget = vectorcraft_doc::MAX_SYMBOL_NODES; + expand_nested_instances(d, &mut m, 1, &mut budget, raster); + expand_pieces(d, &mut m, true, brushes, skip, &mut kept, &mut stroke_art, raster)?; + Ok(m) + }) + .transpose() + }; + let Ok(m) = m else { + leave(d, out, raster); + return None; }; // A 3D effect's shadow blurred by the light's Softness keeps its blur in the art: it // expands in turn, to an image. diff --git a/crates/engine/src/cmd/effectcmd/tests.rs b/crates/engine/src/cmd/effectcmd/tests.rs index d035c24860..685261d340 100644 --- a/crates/engine/src/cmd/effectcmd/tests.rs +++ b/crates/engine/src/cmd/effectcmd/tests.rs @@ -1189,3 +1189,90 @@ fn copies_the_raster_budget_leaves_keep_their_random_moves() { assert_eq!((budget.images, budget.pixels), (images, u64::MAX), "{images}: the budget gets back what the copies took"); } } + +/// A group whose Transform effect copies its symbol instance, which has a drop shadow and a random +/// Transform effect that takes its seed from the instance's id: each copy's instance has that id. +/// When the raster budget has no image left for a copy's shadow, with none left or with one for the +/// first copy's, the group stays as it is: the copies keep the ids their random moves are drawn +/// with, the group draws as before, and the document holds no image the first copy's expansion +/// made, nor the budget its charge. With the whole budget, the group expands and each object gets +/// an id of its own. +#[test] +fn a_member_the_raster_budget_leaves_keeps_its_random_move() { + let (mut s, id) = session_with_rect(); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + let id = NodeId(s.execute("symbol.new", &json!({"name": "Box"})).unwrap()["id"].as_u64().unwrap()); + let shadow = json!({"x": 10, "y": 0, "blur": 0, "opacity": 100, "mode": "normal", "color": "#00ff00"}); + s.execute("effect.apply", &json!({"ids": [id.0], "effect": "stylize.dropShadow", "params": shadow})).unwrap(); + let random = json!({"moveH": 40, "moveV": 40, "random": true}); + s.execute("effect.apply", &json!({"ids": [id.0], "effect": "distort.transform", "params": random})).unwrap(); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + let g = NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap()); + s.execute("effect.apply", &json!({"ids": [g.0], "effect": "distort.transform", "params": {"moveV": 150, "copies": 1}})).unwrap(); + let draw = |d: &vectorcraft_doc::Document| { + vectorcraft_render::Renderer::new().render(d, 400, 400, vectorcraft_geom::Affine::IDENTITY, &Default::default()).pixels + }; + for images in [0, 1, 1_024] { + let mut d = s.doc().unwrap().doc.as_ref().clone(); + let before = d.node(g).cloned().unwrap(); + assert!(effects::outer_effects(&before).len() == before.appearance.effects.len(), "the copies carry no shadow of the group's"); + let art = effects::evaluate_container(Some(&d), &before).unwrap(); + let mut instances = 0; + art.walk(&mut |n| instances += usize::from(n.id == id && super::has_seeded(n))); + assert!(instances >= 2, "{images}: each copy's instance has the id and its random effect: {instances}"); + let (drawn, keys) = (draw(&d), d.images.keys().cloned().collect::>()); + + let mut budget = super::RasterBudget { images, pixels: u64::MAX, left: 0 }; + let mut out = vec![]; + super::expand_node(&mut d, g, &[], &mut out, &mut budget); + if images < 2 { + assert!(budget.left > 0, "{images}: a shadow is left"); + assert!(out.is_empty(), "{images}: nothing expands: {out:?}"); + assert_eq!(d.node(g), Some(&before), "{images}: the group stays as it is"); + assert!(draw(&d) == drawn, "{images}: the group draws as before"); + assert_eq!(d.images.keys().cloned().collect::>(), keys, "{images}: no image is added"); + assert_eq!((budget.images, budget.pixels), (images, u64::MAX), "{images}: the budget gets back what the copies took"); + } else { + assert_eq!(budget.left, 0, "no shadow is left"); + assert!(!out.is_empty(), "the group expands"); + let (mut ids, mut count, mut seeded) = (std::collections::HashSet::new(), 0, false); + d.node(g).unwrap().walk(&mut |n| { + ids.insert(n.id); + count += 1; + seeded |= super::has_seeded(n); + }); + assert_eq!(ids.len(), count, "each object has an id of its own"); + assert!(!seeded, "no random Transform effect is left"); + } + } +} + +/// An object with Crop Marks, a drop shadow and a random Transform effect that takes its seed from +/// the object's id stays as it is when the raster budget has no image left for its shadow: the +/// object keeps its id and its random move, and draws as before. +#[test] +fn crop_marks_the_raster_budget_leaves_keep_their_random_move() { + let (mut s, id) = session_with_rect(); + let shadow = json!({"x": 10, "y": 0, "blur": 0, "opacity": 100, "mode": "normal", "color": "#00ff00"}); + s.execute("effect.apply", &json!({"ids": [id.0], "effect": "stylize.dropShadow", "params": shadow})).unwrap(); + let random = json!({"moveH": 40, "moveV": 40, "random": true}); + s.execute("effect.apply", &json!({"ids": [id.0], "effect": "distort.transform", "params": random})).unwrap(); + s.execute("effect.apply", &json!({"ids": [id.0], "effect": "cropMarks", "params": {}})).unwrap(); + let draw = |d: &vectorcraft_doc::Document| { + vectorcraft_render::Renderer::new().render(d, 400, 400, vectorcraft_geom::Affine::IDENTITY, &Default::default()).pixels + }; + let mut d = s.doc().unwrap().doc.as_ref().clone(); + let before = d.node(id).cloned().unwrap(); + assert!(effects::crop_marks_art(&before).is_some(), "the object has crop marks"); + let (drawn, keys) = (draw(&d), d.images.keys().cloned().collect::>()); + + let mut budget = super::RasterBudget { images: 0, pixels: u64::MAX, left: 0 }; + let mut out = vec![]; + super::expand_node(&mut d, id, &[], &mut out, &mut budget); + assert!(budget.left > 0, "the shadow is left"); + assert!(out.is_empty(), "nothing expands: {out:?}"); + assert_eq!(d.node(id), Some(&before), "the object stays as it is"); + assert!(draw(&d) == drawn, "the object draws as before"); + assert_eq!(d.images.keys().cloned().collect::>(), keys, "no image is added"); + assert_eq!((budget.images, budget.pixels), (0, u64::MAX), "the budget is as it was"); +} diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index cfe7cced23..c1bbc7bf5c 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -650,6 +650,7 @@ since 2026-10-01. - **Raster effects before a group's or layer's Transform effect that makes copies:** groups and layers can carry effects of their own ([the help page](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/vector-and-raster-effects.html)), and the rule above for paths now covers them as VectorCraft's own rule. Each copy of a group's or layer's own last Transform effect that makes copies carries the Drop Shadow, glow, blur, Feather or pixel filter listed before that effect, made of all the copy's members together, with its sizes scaled by that copy's mean scale and a Drop Shadow's offset turned, reflected and scaled with the copy; a raster effect listed after it paints once around all the copies, and the members' own raster effects in each copy stay as a copying Transform effect leaves them. Before, one shadow was drawn around all the copies at the group's own distances. A clip group's copies each clip, and a layer's ruler guides stay once above the copies. The canvas, the bounds, export with raster effects as images and Expand Appearance draw the same copies, and copies that stop at the effect budget each keep their effects (effects `tests::rasterfollow::each_copy_of_a_groups_or_layers_transform_effect_carries_the_shadow_listed_before_it`, `tests::rasterfollow::a_groups_copying_transform_leaves_member_and_later_shadows_where_they_paint`, `tests::rasterfollow::a_groups_copies_past_the_budget_each_keep_their_shadow`, `tests::rasterfollow::a_layers_guides_stay_once_above_copies_that_carry_its_shadow`, `tests::rasterfollow::a_baked_group_with_type_keeps_a_shadow_on_each_copy`; render `objectfx::each_copy_of_a_groups_or_layers_transform_effect_draws_its_own_shadow`; engine `objexpand::each_copys_shadow_on_a_group_expands_as_the_canvas_draws_it`, `objexpand::each_copys_random_member_expands_as_the_canvas_draws_it`, `pdfraster::each_copys_shadow_on_a_group_flattens_under_that_copy`). Not yet: a compound shape, a Shaper group, and a group or layer with a Pathfinder effect, a 3D effect, Crop Marks, Vector Halftone, a live-effect plug-in that paints what it returns, a perspective or a fill or stroke with geometry effects of its own keep one set of raster effects around their copies. Scores and hours unchanged. - **Rasterize before a Transform effect:** effects apply in the order they are listed, each one taking the result of the one before ([the help page](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-graphic-styles/appearance-attributes-in-illustrator.html)). On a path or compound path, a Transform effect listed after the object's own Rasterize effect now moves the image that Rasterize makes: the image is made of the art before the Transform effect, at the Rasterize effect's resolution and with its room around the art, and the Transform effect scales, turns, reflects and moves the image with its pixel grid. Before, the Transform effect moved the art and Rasterize made a new image of the moved art on a grid square to the page. Keeping the image's pixel grid under the Transform effect is VectorCraft's own rule. A hidden Transform effect, or one with Transform Objects off, leaves the image where it is, and one that scales it to nothing leaves nothing drawn. The canvas, the object's bounds, Expand Appearance and PDF export draw the same image (effects `tests::rasterfollow::rasterize_following_ignores_hidden_and_objects_off`, `tests::rasterfollow::the_image_moves_by_each_transform_about_the_art_it_takes`; render `rasterize::rasterize_then_scale_uses_the_pretransform_pixels`, `rasterize::rasterize_then_rotate_and_reflect_moves_the_pixel_grid`, `rasterize::rasterize_then_nonuniform_scale_and_zero_scale_are_bounded`; engine `rastersettings::expand_rasterize_then_transform_matches_canvas`). Not yet: a Transform effect that makes copies or moves at random, a Transform effect followed by another kind of effect, a fill's or stroke's own Rasterize effect, and Rasterize on type, images, symbol instances and groups keep the earlier behavior. Scores and hours unchanged. - **Raster effects before a Transform effect past the effect budget:** VectorCraft leaves out a Transform effect whose result would pass its geometry budget of 2 million anchors or 8 million lines drawn, and the art stays where it was. The raster effects listed before that Transform effect now stay with the art too: a Drop Shadow keeps its own offset and blur, and the Transform effects after it that fit still move both. Before, the art stayed while the shadow scaled with the Transform effect it did not take. This is VectorCraft's own rule. It applies to a path's own effects and to its fills' and strokes' own, also when the path is in a group whose geometry effects run after its members' own, on the canvas and in its bounds, in export, Expand Appearance, Object › Expand and Outline Stroke, and a hidden shadow keeps its values once shown (effects `tests::rasterfollow::a_transform_past_the_line_budget_moves_the_art_with_its_shadow`, `tests::rasterfollow::only_transforms_that_ran_move_a_preceding_shadow`, `tests::rasterfollow::a_skipped_item_transform_keeps_its_shadow`, `tests::rasterfollow::the_shape_art_of_a_skipped_transform_keeps_its_shadows`, `tests::rasterfollow::a_members_skipped_transform_keeps_its_shadow_under_its_groups_effects`; render `objectfx::a_shadow_before_a_skipped_transform_reaches_as_far_as_it_is_drawn`, `fx::renderer::tests::a_path_paints_from_the_transforms_that_moved_it`; engine `objexpand::a_shadow_before_a_skipped_transform_expands_with_its_own_offset`). Not yet: the shadow of type, an image, a symbol instance or a group whose art a Transform effect leaves in place past the budget still follows that effect. Scores and hours unchanged. +- **Random Transform moves past the image limits of Expand Appearance:** a Transform effect's Random option takes its seed from the object's id, which is VectorCraft's own rule. When Expand Appearance's limits of 1,024 images and 256 megapixels leave the raster effects of an object that a random Transform effect moves, and that object is a member of a group or layer whose own geometry effects or fills and strokes expand, or the object of a Crop Marks effect, the group, layer or object now stays as it is, with its effects, as an object whose own image would pass those limits does. The document keeps none of the images its expansion made, and the limits get them back. Before, the member got a new id, so its random move changed while its effects stayed live. This is VectorCraft's own rule (engine `effectcmd::tests::a_member_the_raster_budget_leaves_keeps_its_random_move`, `effectcmd::tests::crop_marks_the_raster_budget_leaves_keep_their_random_move`). Scores and hours unchanged. - **Raster effects inside an object or group with a Transform effect:** effects applied to a group affect everything in it ([Appearance attributes](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-graphic-styles/appearance-attributes-in-illustrator.html)). How a Transform effect changes the raster effects inside a group or object is VectorCraft's own rule. A group's Transform effect that moves it once now transforms the raster effects of its members, of their fills and strokes, of nested groups and of the art of the linked opacity masks in it, after the members' own Transform effects. A raster effect that a member's own Transform effect with copies or random holds back keeps its value through that effect and still transforms with the group's. VectorCraft applies the same rule to the raster effects of an object's fills and strokes under the object's Transform effect. Sizes scale by the mean scale and a Drop Shadow's offset turns, reflects and scales, with Scale Strokes & Effects on or off. Before, they kept their values, or with Scale Strokes & Effects on scaled by the mean scale with the offset unturned. A group's or object's Transform effect that makes copies or moves at random leaves them as before, except a path's Transform effect that makes copies (see "A fill's or stroke's raster effects on copies"). The canvas, the redraw region, export, Expand Appearance, Object › Expand and Outline Stroke use the same values (effects `tests::rasterfollow`, `group::tests::a_compound_shapes_transform_turns_its_fills_shadow`; render `a_transform_scales_the_shadows_of_fills_and_members_with_the_art`; engine `objexpand::a_fills_shadow_under_the_objects_transform_expands_as_the_canvas_draws_it`, `objexpand::shadows_under_a_groups_or_an_objects_transform_expand_appearance_as_the_canvas_draws_them`, `outlinestroke::a_strokes_shadow_under_the_objects_transform_outlines_as_the_canvas_draws_it`). Scores and hours unchanged. - **A group's geometry effects after its members' own:** effects applied to a group affect everything in it, and effects apply in the order they are listed ([Appearance attributes](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-graphic-styles/appearance-attributes-in-illustrator.html)). Running a group's effects after its members' own is VectorCraft's own rule. The geometry effects of a group or layer (the effects that reshape outlines, such as Distort & Transform, Offset Path and Warp) now reshape what its members draw: the geometry effects of each visible path and compound path in it and of their fills and strokes, and a nested group's own geometry and Pathfinder effects, run first, at any depth. A symbol instance's own geometry effects run after those of its symbol's members in the same way. Before, the group's effects reshaped the members' outlines and the members' own effects ran afterwards: a 100 pt square with its own 10 pt Offset Path in a group with a 50% Transform drew 70 pt wide, and it now draws 60 pt wide. Existing documents with such groups draw differently. The canvas, export, Expand Appearance and the art that Pathfinder operations and compound shapes take from such a group use the same order (effects `group::tests::a_members_own_offset_runs_before_its_groups_scale`, `group::tests::a_members_own_scale_runs_before_its_groups_offset`, `group::tests::a_member_of_a_plain_nested_group_takes_its_own_effects_first`, `group::tests::a_nested_groups_own_effects_run_before_its_groups`, `group::tests::a_nested_groups_pathfinder_runs_before_its_groups_effects`, `group::tests::a_members_fill_effects_run_before_its_groups`, `group::tests::shape_art_of_a_group_applies_its_members_effects_first`, `group::tests::a_symbol_instances_effects_run_after_its_symbols_members_own`, `group::tests::a_baked_group_applies_its_members_effects_first`, `group::tests::a_baked_group_that_keeps_its_type_applies_its_members_effects_first`, `tests::rasterfollow::a_groups_transform_applies_after_its_members_own`; engine `objexpand::a_groups_effects_after_its_members_own_expand_as_the_canvas_draws_them`). Not yet: the own geometry effects of images, symbol instances, paths with a linked opacity mask or a 3D effect, and nested groups with a 3D effect in the group still run after the group's. 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.