Refactor the 'Fill' and 'Stroke' nodes to set "fill" and "stroke" attributes for paints (#4257)

* Allow using any graphics type for fill * Adapt gradient/fill property panels and tools to handle List<T> * Make the initial gradient transform covers the target's bounding box * Introduce AnyGraphicListDyn to avoid combinatorial explosion * Allow using any graphics type for stroke paint * Add FIll node migration * Add `for_each_vector_list_mut` instead of `set_paint_attribute` * Adapt paint flow to read and write attributes instead of legacy Fill/Stroke.color * Fix responsibilities of paint related node input setters * Fix Morph by storing List<Graphic> for attributes rather than the concrete types Store fill/stroke paints as List<Graphic> so Color/Gradient transitions do not hit set_attribute_value_dyn's type-mismatch fallback to default paint. * Preserve paint attributes in vector editing ops * Enhance the clarity between direct and chained fill gradients * Update demo arts * Consolidate Fill node gradient appearance inputs * Fix after the cubic review * Revert "Consolidate Fill node gradient appearance inputs" This reverts commit 9622feb20196e2c4da99e98ca95dcc2e34c2c98e. * Replace AnyGraphicListDyn with generic paint connectors on the Fill and Stroke nodes * Canonicalize paint attribute storage to List<Graphic> with a single write helper * Fix Solidify Stroke missing fills stored in the legacy style * Fix Solidify Stroke producing invisible strokes for legacy-only stroke colors * Fix the initial gradient transform ignoring the bounding box's vertical extent * Step paint at the morph midpoint instead of dropping it for unmixable pairings * Remove migration-stage comments * Clarify the initial gradient transform helper's doc and name * Correct the bake_paint_transforms doc and prune dead tolerance arms * Delete the unused Gradient::lerp * Fix a comment typo * Thread network paths through the legacy gradient bake so nested fills migrate * Restore the legacy fill fallback in Expand Fill and Stroke * Read gradient stops from the node's own input in the Fill properties panel * Use the transform input constant instead of a hardcoded index * Remove the unreachable wired color fallback in the Fill properties solid branch * Narrow the fill overlay redraw check to actual fill inputs * Coalesce the fill setter's graph runs into a single dispatch * Position the Gradient Value node inserted for gradient stops * Bake backup gradient placement during migration * Persist pending gradient bakes so unfinished migrations retry on reopen * Migrate the backup gradient's type and spread method * Harden the gradient-migration pass against document switches and stale bakes * Keep the Fill properties UI for layerless and nested Fill nodes * Leave a wired gradient transform input connected instead of overwriting it * Refuse to start a gradient chain ahead of existing layer content * Decode a Fill node's gradient through one shared reader * Nudge a degenerate bounding box so the Fill gradient transform stays invertible * Broadcast Fill and Stroke paint with a single attribute-column pass * Fix Morph stepping the target's stroke in near the source instead of the target * Tidy conventions: clippy get_first, comment periods, sentence-case test messages * Reattach the gradient orientation doc to its function * Re-save demo artwork --------- Co-authored-by: Keavon Chambers <keavon@keavon.com>
2026-09-15 22:28:10 +08:00 · 2026-07-05 01:08:21 +02:00
parent f82b0a8fca
commit 9f9899cfd0
29 changed files with 1352 additions and 660 deletions
--- a/node-graph/nodes/graphic/src/artboard.rs
+++ b/node-graph/nodes/graphic/src/artboard.rs
@@ -9,7 +9,7 @@ use vector_types::GradientStops;

 /// Constructs a single-element `Artboard[]` with the given content and metadata stored as row attributes.
 #[node_macro::node(category(""))]
-pub async fn create_artboard<T: IntoGraphicList + 'n>(
+pub async fn create_artboard<T: IntoGraphicList>(
 	ctx: impl ExtractAll + CloneVarArgs + Ctx,
 	/// Graphics to include within the artboard.
 	#[implementations(
--- a/node-graph/nodes/graphic/src/graphic.rs
+++ b/node-graph/nodes/graphic/src/graphic.rs
@@ -565,7 +565,7 @@ pub async fn wrap_graphic<T: Into<Graphic> + 'n>(
 /// Converts a list of graphical content into a `Graphic[]` by placing it into an element of a new wrapper `Graphic[]`.
 /// If it is already a `Graphic[]`, it is not wrapped again. Use the 'Wrap Graphic' node if wrapping is always desired.
 #[node_macro::node(category("General"))]
-pub async fn to_graphic<T: IntoGraphicList + 'n>(
+pub async fn to_graphic<T: IntoGraphicList>(
 	_: impl Ctx,
 	#[implementations(
 		List<Graphic>,
@@ -620,7 +620,7 @@ pub async fn flatten_graphic(_: impl Ctx, content: List<Graphic>, fully_flatten:

 /// Converts a `Graphic[]` into a `Vector[]` by deeply flattening any vector content it contains, and discarding any non-vector content.
 #[node_macro::node(category("Vector"))]
-pub async fn flatten_vector<T: IntoGraphicList + 'n + Send + Clone>(_: impl Ctx, #[implementations(List<Graphic>, List<Vector>)] content: T) -> List<Vector> {
+pub async fn flatten_vector<T: IntoGraphicList>(_: impl Ctx, #[implementations(List<Graphic>, List<Vector>)] content: T) -> List<Vector> {
 	let graphic_list = content.into_graphic_list();
 	let mut output: List<Vector> = graphic_list.clone().into_flattened_list();

@@ -653,25 +653,25 @@ pub async fn flatten_vector<T: IntoGraphicList + 'n + Send + Clone>(_: impl Ctx,

 /// Converts a `Graphic[]` into a `Raster[]` by deeply flattening any raster content it contains, and discarding any non-raster content.
 #[node_macro::node(category("Raster"))]
-pub async fn flatten_raster<T: IntoGraphicList + 'n + Send + Clone>(_: impl Ctx, #[implementations(List<Graphic>, List<Raster<CPU>>)] content: T) -> List<Raster<CPU>> {
+pub async fn flatten_raster<T: IntoGraphicList>(_: impl Ctx, #[implementations(List<Graphic>, List<Raster<CPU>>)] content: T) -> List<Raster<CPU>> {
 	content.into_flattened_list()
 }

 /// Converts a `Graphic[]` into a `Color[]` by deeply flattening any color content it contains, and discarding any non-color content.
 #[node_macro::node(category("General"))]
-pub async fn flatten_color<T: IntoGraphicList + 'n + Send + Clone>(_: impl Ctx, #[implementations(List<Graphic>, List<Color>)] content: T) -> List<Color> {
+pub async fn flatten_color<T: IntoGraphicList>(_: impl Ctx, #[implementations(List<Graphic>, List<Color>)] content: T) -> List<Color> {
 	content.into_flattened_list()
 }

 /// Converts a `Graphic[]` into a `GradientStops[]` by deeply flattening any gradient content it contains, and discarding any non-gradient content.
 #[node_macro::node(category("General"))]
-pub async fn flatten_gradient<T: IntoGraphicList + 'n + Send + Clone>(_: impl Ctx, #[implementations(List<Graphic>, List<GradientStops>)] content: T) -> List<GradientStops> {
+pub async fn flatten_gradient<T: IntoGraphicList>(_: impl Ctx, #[implementations(List<Graphic>, List<GradientStops>)] content: T) -> List<GradientStops> {
 	content.into_flattened_list()
 }

 /// Constructs a gradient from a `Color[]`, where the colors are evenly distributed as gradient stops across the range from 0 to 1.
 #[node_macro::node(category("Color"))]
-fn colors_to_gradient<T: IntoGraphicList + 'n + Send + Clone>(_: impl Ctx, #[implementations(List<Graphic>, List<Color>)] colors: T) -> List<GradientStops> {
+fn colors_to_gradient<T: IntoGraphicList>(_: impl Ctx, #[implementations(List<Graphic>, List<Color>)] colors: T) -> List<GradientStops> {
 	let colors = colors.into_flattened_list::<Color>();
 	let total_colors = colors.len();

--- a/node-graph/nodes/path-bool/src/lib.rs
+++ b/node-graph/nodes/path-bool/src/lib.rs
@@ -1,21 +1,22 @@
-use core_types::list::{Item, List};
+use core_types::list::{ATTR_FILL, Item, List};
 use core_types::uuid::NodeId;
 use core_types::{
 	ATTR_BLEND_MODE, ATTR_CLIPPING_MASK, ATTR_EDITOR_LAYER_PATH, ATTR_EDITOR_MERGED_LAYERS, ATTR_GRADIENT_TYPE, ATTR_OPACITY, ATTR_OPACITY_FILL, ATTR_SPREAD_METHOD, ATTR_TRANSFORM, BlendMode, Color,
 	Ctx,
 };
 use glam::{DAffine2, DVec2};
-use graphic_types::vector_types::gradient::{Gradient, GradientSpreadMethod, GradientType};
+use graphic_types::graphic::{bake_paint_transforms, set_paint_attribute};
+use graphic_types::vector_types::gradient::{GradientSpreadMethod, GradientType};
 use graphic_types::vector_types::subpath::{ManipulatorGroup, Subpath};
 use graphic_types::vector_types::vector::PointId;
 use graphic_types::vector_types::vector::algorithms::merge_by_distance::MergeByDistanceExt;
-use graphic_types::vector_types::vector::style::Fill;
 use graphic_types::{Graphic, Vector};
 use linesweeper::topology::Topology;
 use linesweeper::{BinaryOp, FillRule, binary_op};
 use smallvec::SmallVec;
 use vector_types::kurbo::{Affine, BezPath, CubicBez, Line, ParamCurve, PathSeg, Point, QuadBez};
 pub use vector_types::vector::misc::BooleanOperation;
+use vector_types::vector::style::Fill;

 // TODO: Fix boolean ops to work by removing .transform() and .one_instance_*() calls,
 // TODO: since before we used a Vec of single-item `List`s and now we use a single `List`
@@ -23,7 +24,7 @@ pub use vector_types::vector::misc::BooleanOperation;

 /// Combines the geometric forms of one or more closed paths into a new vector path that results from cutting or joining the paths by the chosen method.
 #[node_macro::node(category("Vector: Modifier"), memoize)]
-async fn boolean_operation<I: graphic_types::IntoGraphicList + 'n + Send + Clone>(
+async fn boolean_operation<I: graphic_types::IntoGraphicList>(
 	_: impl Ctx,
 	/// The `List` of vector paths to perform the boolean operation on. Nested `List`s are automatically flattened.
 	#[implementations(List<Graphic>, List<Vector>)]
@@ -143,12 +144,15 @@ fn boolean_operation_on_vector_list(vector: &List<Vector>, boolean_operation: Bo
 		let copy_from_transform: DAffine2 = vector.attribute_cloned_or_default(ATTR_TRANSFORM, index);
 		// The boolean op bakes input transforms into the output geometry, so the result item carries no transform of its own
 		attributes.insert(ATTR_TRANSFORM, DAffine2::IDENTITY);
+
+		bake_paint_transforms(&mut attributes, copy_from_transform);
+
 		let copy_from = vector.element(index).unwrap();
 		let mut element = Vector {
 			style: copy_from.style.clone(),
 			..Default::default()
 		};
-		// An absolute gradient lives in the geometry's space, so bake the same transform into it to track the baked points
+		// Legacy Fill fallback: An absolute gradient lives in the geometry's space, so bake the same transform into it to track the baked points
 		if let Fill::Gradient(gradient) = element.style.fill_mut()
 			&& gradient.absolute
 		{
@@ -204,15 +208,16 @@ fn flatten_vector(graphic_list: &List<Graphic>) -> List<Vector> {
 						let mut subpath = Subpath::new_rectangle(DVec2::ZERO, DVec2::ONE);
 						subpath.apply_transform(transform);

-						let mut element = Vector::from_subpath(subpath);
-						element.style.set_fill(Fill::Solid(Color::BLACK));
+						let element = Vector::from_subpath(subpath);

-						Item::new_from_element(element)
+						let mut item = Item::new_from_element(element)
 							.with_attribute(ATTR_BLEND_MODE, blend_mode)
 							.with_attribute(ATTR_OPACITY, opacity)
 							.with_attribute(ATTR_OPACITY_FILL, fill)
 							.with_attribute(ATTR_CLIPPING_MASK, clip)
-							.with_attribute(ATTR_EDITOR_LAYER_PATH, layer)
+							.with_attribute(ATTR_EDITOR_LAYER_PATH, layer);
+						set_paint_attribute(item.attributes_mut(), ATTR_FILL, List::new_from_element(Color::BLACK));
+						item
 					};

 					// Apply the parent graphic's transform to each raster element, preserving each item's layer
@@ -236,15 +241,16 @@ fn flatten_vector(graphic_list: &List<Graphic>) -> List<Vector> {
 						let mut subpath = Subpath::new_rectangle(DVec2::ZERO, DVec2::ONE);
 						subpath.apply_transform(transform);

-						let mut element = Vector::from_subpath(subpath);
-						element.style.set_fill(Fill::Solid(Color::BLACK));
+						let element = Vector::from_subpath(subpath);

-						Item::new_from_element(element)
+						let mut item = Item::new_from_element(element)
 							.with_attribute(ATTR_BLEND_MODE, blend_mode)
 							.with_attribute(ATTR_OPACITY, opacity)
 							.with_attribute(ATTR_OPACITY_FILL, fill)
 							.with_attribute(ATTR_CLIPPING_MASK, clip)
-							.with_attribute(ATTR_EDITOR_LAYER_PATH, layer)
+							.with_attribute(ATTR_EDITOR_LAYER_PATH, layer);
+						set_paint_attribute(item.attributes_mut(), ATTR_FILL, List::new_from_element(Color::BLACK));
+						item
 					};

 					// Apply the parent graphic's transform to each raster element, preserving each item's layer
@@ -278,9 +284,10 @@ fn flatten_vector(graphic_list: &List<Graphic>) -> List<Vector> {
 				Graphic::Color(color) => color
 					.into_iter()
 					.map(|row| {
-						let (color, attributes) = row.into_parts();
+						let (color, mut attributes) = row.into_parts();
+						set_paint_attribute(&mut attributes, ATTR_FILL, List::new_from_element(color));
+
 						let mut element = Vector::default();
-						element.style.set_fill(Fill::Solid(color));
 						element.style.set_stroke_transform(DAffine2::IDENTITY);

 						Item::from_parts(element, attributes)
@@ -289,19 +296,21 @@ fn flatten_vector(graphic_list: &List<Graphic>) -> List<Vector> {
 				Graphic::Gradient(gradient) => gradient
 					.into_iter()
 					.map(|row| {
-						let (stops, attributes) = row.into_parts();
+						let (stops, mut attributes) = row.into_parts();
+
+						let mut gradient_paint = List::new_from_element(stops);
+						if let Some(transform) = attributes.remove::<DAffine2>(ATTR_TRANSFORM) {
+							gradient_paint.set_attribute(ATTR_TRANSFORM, 0, transform);
+						}
+						if let Some(gradient_type) = attributes.remove::<GradientType>(ATTR_GRADIENT_TYPE) {
+							gradient_paint.set_attribute(ATTR_GRADIENT_TYPE, 0, gradient_type);
+						}
+						if let Some(spread_method) = attributes.remove::<GradientSpreadMethod>(ATTR_SPREAD_METHOD) {
+							gradient_paint.set_attribute(ATTR_SPREAD_METHOD, 0, spread_method);
+						}
+						set_paint_attribute(&mut attributes, ATTR_FILL, gradient_paint);
+
 						let mut element = Vector::default();
-						// Convert the gradient's transform to absolute endpoints, matching `From<List<GradientStops>> for Fill`
-						let transform = attributes.get::<DAffine2>(ATTR_TRANSFORM).cloned().unwrap_or_default();
-						element.style.set_fill(Fill::Gradient(Gradient {
-							stops,
-							gradient_type: attributes.get::<GradientType>(ATTR_GRADIENT_TYPE).cloned().unwrap_or_default(),
-							spread_method: attributes.get::<GradientSpreadMethod>(ATTR_SPREAD_METHOD).cloned().unwrap_or_default(),
-							start: transform.transform_point2(DVec2::ZERO),
-							end: transform.transform_point2(DVec2::X),
-							absolute: true,
-							transform: DAffine2::IDENTITY,
-						}));
 						element.style.set_stroke_transform(DAffine2::IDENTITY);

 						Item::from_parts(element, attributes)
--- a/node-graph/nodes/vector/src/vector_nodes.rs
+++ b/node-graph/nodes/vector/src/vector_nodes.rs
@@ -3,22 +3,24 @@ use core::f64::consts::{PI, TAU};
 use core::hash::{Hash, Hasher};
 use core_types::blending::BlendMode;
 use core_types::bounds::{BoundingBox, RenderBoundingBox};
-use core_types::list::{ATTR_FILL, ATTR_STROKE, Item, List, ListDyn};
+use core_types::list::{ATTR_FILL, ATTR_STROKE, Item, ItemAttributeValues, List, ListDyn};
 use core_types::registry::types::{Angle, Length, Multiplier, Percentage, PixelLength, Progression, SeedValue};
 use core_types::transform::{Footprint, Transform};
 use core_types::uuid::NodeId;
 use core_types::{
-	ATTR_BLEND_MODE, ATTR_CLIPPING_MASK, ATTR_EDITOR_LAYER_PATH, ATTR_EDITOR_MERGED_LAYERS, ATTR_OPACITY, ATTR_OPACITY_FILL, ATTR_TRANSFORM, CloneVarArgs, Color, Context, Ctx, ExtractAll,
-	OwnedContextImpl,
+	ATTR_BLEND_MODE, ATTR_CLIPPING_MASK, ATTR_EDITOR_LAYER_PATH, ATTR_EDITOR_MERGED_LAYERS, ATTR_GRADIENT_TYPE, ATTR_OPACITY, ATTR_OPACITY_FILL, ATTR_SPREAD_METHOD, ATTR_TRANSFORM, CloneVarArgs,
+	Color, Context, Ctx, ExtractAll, OwnedContextImpl,
 };
 use glam::{DAffine2, DMat2, DVec2};
 use graphic_types::Vector;
+use graphic_types::graphic::{bake_paint_transforms, fill_graphic_list_at, has_paint_at, is_paint_present, set_paint_attribute, set_paint_attribute_at, stroke_graphic_list_at};
 use graphic_types::raster_types::{CPU, GPU, Raster};
 use graphic_types::{Graphic, IntoGraphicList};
 use kurbo::simplify::{SimplifyOptions, simplify_bezpath};
 use kurbo::{Affine, BezPath, DEFAULT_ACCURACY, Line, ParamCurve, ParamCurveArclen, PathEl, PathSeg, Shape};
 use rand::{Rng, SeedableRng};
 use std::collections::hash_map::DefaultHasher;
+use vector_types::gradient::{build_transform_with_y_preservation, initial_gradient_transform_for_bounding_box};
 use vector_types::subpath::{BezierHandles, ManipulatorGroup};
 use vector_types::vector::PointDomain;
 use vector_types::vector::algorithms::bezpath_algorithms::{self, TValue, eval_pathseg_euclidean, evaluate_bezpath, split_bezpath, tangent_on_bezpath};
@@ -29,14 +31,17 @@ use vector_types::vector::misc::{
 	CentroidType, ExtrudeJoiningAlgorithm, HandleId, InterpolationDistribution, MergeByDistanceAlgorithm, PointSpacingType, RowsOrColumns, bezpath_from_manipulator_groups,
 	bezpath_to_manipulator_groups, handles_to_segment, is_linear, point_to_dvec2, segment_to_handles,
 };
-use vector_types::vector::style::{Fill, Gradient, GradientStops, PaintOrder, Stroke, StrokeAlign, StrokeCap, StrokeJoin};
+use vector_types::vector::style::{GradientStops, PaintOrder, Stroke, StrokeAlign, StrokeCap, StrokeJoin};
 use vector_types::vector::{FillId, PointId, RegionId, SegmentDomain, SegmentId, StrokeId, VectorExt};
+use vector_types::{GradientSpreadMethod, GradientType};

 /// Implemented for types that contain vector items reachable via mutable access.
 /// Used for the fill and stroke nodes so they can apply to either `List<Graphic>` or `List<Vector>`.
 trait VectorListIterMut {
 	fn for_each_vector_mut(&mut self, f: impl FnMut(&mut Vector, DAffine2));

+	fn for_each_vector_list_mut(&mut self, f: impl FnMut(&mut List<Vector>));
+
 	fn vector_count(&self) -> usize;
 }

@@ -51,6 +56,14 @@ impl VectorListIterMut for List<Graphic> {
 		}
 	}

+	fn for_each_vector_list_mut(&mut self, mut f: impl FnMut(&mut List<Vector>)) {
+		for graphic in self.iter_element_values_mut() {
+			if let Some(vector_list) = graphic.as_vector_mut() {
+				f(vector_list);
+			};
+		}
+	}
+
 	fn vector_count(&self) -> usize {
 		self.iter_element_values().filter_map(|element| element.as_vector()).map(|list| list.len()).sum()
 	}
@@ -64,6 +77,10 @@ impl VectorListIterMut for List<Vector> {
 		}
 	}

+	fn for_each_vector_list_mut(&mut self, mut f: impl FnMut(&mut List<Vector>)) {
+		f(self);
+	}
+
 	fn vector_count(&self) -> usize {
 		self.len()
 	}
@@ -109,26 +126,29 @@ where
 	let mut rng = rand::rngs::StdRng::seed_from_u64(seed.into());

 	let mut i: usize = 0;
-	content.for_each_vector_mut(|vector, _transform| {
-		let factor = match randomize {
-			true => rng.random::<f64>(),
-			false => match repeat_every {
-				0 => i as f64 / (length - 1).max(1) as f64,
-				1 => 0.,
-				_ => i as f64 % repeat_every as f64 / (repeat_every - 1) as f64,
-			},
-		};
+	content.for_each_vector_list_mut(|vector_list| {
+		for index in 0..vector_list.len() {
+			let factor = match randomize {
+				true => rng.random::<f64>(),
+				false => match repeat_every {
+					0 => i as f64 / (length - 1).max(1) as f64,
+					1 => 0.,
+					_ => i as f64 % repeat_every as f64 / (repeat_every - 1) as f64,
+				},
+			};

-		let color = gradient.evaluate(factor);
+			let color = gradient.evaluate(factor);
+			let paint = List::new_from_element(color).into_graphic_list();

-		if fill {
-			vector.style.set_fill(Fill::Solid(color));
+			if fill {
+				set_paint_attribute_at(vector_list, index, ATTR_FILL, paint.clone());
+			}
+			if stroke && vector_list.element(index).and_then(|vector| vector.style.stroke()).is_some() {
+				set_paint_attribute_at(vector_list, index, ATTR_STROKE, paint.clone());
+			}
+
+			i += 1;
 		}
-		if stroke && let Some(stroke) = vector.style.stroke().and_then(|stroke| stroke.with_color(&Some(color))) {
-			vector.style.set_stroke(stroke);
-		}
-
-		i += 1;
 	});

 	content
@@ -136,41 +156,77 @@ where

 /// Applies a fill style to the vector content, giving an appearance to the area within the interior of the geometry.
 #[node_macro::node(category("Vector: Style"), path(graphene_core::vector), properties("fill_properties"))]
-async fn fill<F: Into<Fill> + 'n + Send, V: VectorListIterMut + 'n + Send>(
+async fn fill<V: VectorListIterMut + 'n + Send, F: IntoGraphicList + 'n + Send + 'static>(
 	_: impl Ctx,
 	/// The content with vector paths to apply the fill style to.
 	#[implementations(
-		List<Vector>,
-		List<Vector>,
-		List<Vector>,
-		List<Vector>,
-		List<Graphic>,
-		List<Graphic>,
-		List<Graphic>,
-		List<Graphic>,
+		List<Vector>, List<Vector>, List<Vector>, List<Vector>, List<Vector>, List<Vector>,
+		List<Graphic>, List<Graphic>, List<Graphic>, List<Graphic>, List<Graphic>, List<Graphic>,
 	)]
 	mut content: V,
 	/// The fill to paint the path with.
 	#[default(Color::BLACK)]
 	#[implementations(
-		Fill,
-		List<Color>,
-		List<GradientStops>,
-		Gradient,
-		Fill,
-		List<Color>,
-		List<GradientStops>,
-		Gradient,
+		List<Graphic>, List<Vector>, List<Color>, List<GradientStops>, List<Raster<CPU>>, List<Raster<GPU>>,
+		List<Graphic>, List<Vector>, List<Color>, List<GradientStops>, List<Raster<CPU>>, List<Raster<GPU>>,
 	)]
-	fill: F,
+	mut fill: F,
 	_backup_color: List<Color>,
-	_backup_gradient: Gradient,
+	_backup_gradient: List<GradientStops>,
+	_gradient_type: GradientType,
+	_spread_method: GradientSpreadMethod,
+	_transform: Option<DAffine2>,
 ) -> V {
-	let fill: Fill = fill.into();
-	content.for_each_vector_mut(|vector, _transform| {
-		vector.style.set_fill(fill.clone());
-	});
+	if let Some(gradient) = (&mut fill as &mut dyn std::any::Any).downcast_mut::<List<GradientStops>>() {
+		if gradient.iter_attribute_values::<GradientType>(ATTR_GRADIENT_TYPE).is_none() {
+			for value in gradient.iter_attribute_values_mut_or_default::<GradientType>(ATTR_GRADIENT_TYPE) {
+				*value = _gradient_type;
+			}
+		}

+		if gradient.iter_attribute_values::<GradientSpreadMethod>(ATTR_SPREAD_METHOD).is_none() {
+			for value in gradient.iter_attribute_values_mut_or_default::<GradientSpreadMethod>(ATTR_SPREAD_METHOD) {
+				*value = _spread_method;
+			}
+		}
+
+		if gradient.iter_attribute_values::<DAffine2>(ATTR_TRANSFORM).is_none() {
+			let transform = _transform.unwrap_or_else(|| {
+				// Construct a transform that covers the bounding box of the paint target
+				let mut bounds: Option<[DVec2; 2]> = None;
+				content.for_each_vector_mut(|vector, _| {
+					if let Some([min, max]) = vector.bounding_box() {
+						bounds = Some(match bounds {
+							Some([bmin, bmax]) => [bmin.min(min), bmax.max(max)],
+							None => [min, max],
+						});
+					}
+				});
+
+				// Nudge a degenerate axis so the gradient transform stays invertible, matching the editor's `nonzero_bounding_box`
+				let [min, mut max] = bounds.unwrap_or([DVec2::ZERO, DVec2::ONE]);
+				if max.x - min.x < 1e-10 {
+					max.x = min.x + 1.;
+				}
+				if max.y - min.y < 1e-10 {
+					max.y = min.y + 1.;
+				}
+				initial_gradient_transform_for_bounding_box([min, max])
+			});
+
+			for value in gradient.iter_attribute_values_mut_or_default::<DAffine2>(ATTR_TRANSFORM) {
+				*value = transform;
+			}
+		}
+	}
+
+	let fill = fill.into_graphic_list();
+	content.for_each_vector_list_mut(|vector_list| {
+		// Broadcast the same paint to every item, scanning the attribute column once instead of per index
+		for slot in vector_list.iter_attribute_values_mut_or_default::<List<Graphic>>(ATTR_FILL) {
+			*slot = fill.clone();
+		}
+	});
 	content
 }

@@ -195,14 +251,41 @@ impl IntoF64Vec for String {

 /// Applies a stroke style to the vector content, giving an appearance to the area within the outline of the geometry.
 #[node_macro::node(category("Vector: Style"), path(graphene_core::vector), properties("stroke_properties"))]
-async fn stroke<V, L: IntoF64Vec>(
+async fn stroke<V, L: IntoF64Vec, P: IntoGraphicList + 'n + Send + 'static>(
 	_: impl Ctx,
 	/// The content with vector paths to apply the stroke style to.
-	#[implementations(List<Vector>, List<Vector>, List<Vector>, List<Graphic>, List<Graphic>, List<Graphic>)]
+	#[implementations(
+		List<Vector>, List<Vector>, List<Vector>,
+		List<Vector>, List<Vector>, List<Vector>,
+		List<Vector>, List<Vector>, List<Vector>,
+		List<Vector>, List<Vector>, List<Vector>,
+		List<Vector>, List<Vector>, List<Vector>,
+		List<Vector>, List<Vector>, List<Vector>,
+		List<Graphic>, List<Graphic>, List<Graphic>,
+		List<Graphic>, List<Graphic>, List<Graphic>,
+		List<Graphic>, List<Graphic>, List<Graphic>,
+		List<Graphic>, List<Graphic>, List<Graphic>,
+		List<Graphic>, List<Graphic>, List<Graphic>,
+		List<Graphic>, List<Graphic>, List<Graphic>,
+	)]
 	mut content: List<V>,
-	/// The stroke color.
+	/// The stroke paint.
 	#[default(Color::BLACK)]
-	color: List<Color>,
+	#[implementations(
+		List<Graphic>, List<Graphic>, List<Graphic>,
+		List<Vector>, List<Vector>, List<Vector>,
+		List<Color>, List<Color>, List<Color>,
+		List<GradientStops>, List<GradientStops>, List<GradientStops>,
+		List<Raster<CPU>>, List<Raster<CPU>>, List<Raster<CPU>>,
+		List<Raster<GPU>>, List<Raster<GPU>>, List<Raster<GPU>>,
+		List<Graphic>, List<Graphic>, List<Graphic>,
+		List<Vector>, List<Vector>, List<Vector>,
+		List<Color>, List<Color>, List<Color>,
+		List<GradientStops>, List<GradientStops>, List<GradientStops>,
+		List<Raster<CPU>>, List<Raster<CPU>>, List<Raster<CPU>>,
+		List<Raster<GPU>>, List<Raster<GPU>>, List<Raster<GPU>>,
+	)]
+	paint: P,
 	/// The stroke thickness.
 	#[unit(" px")]
 	#[default(2.)]
@@ -220,7 +303,20 @@ async fn stroke<V, L: IntoF64Vec>(
 	/// The order to paint the stroke on top of the fill, or the fill on top of the stroke.
 	paint_order: PaintOrder,
 	/// The stroke dash lengths. Each length forms a distance in a pattern where the first length is a dash, the second is a gap, and so on. If the list is an odd length, the pattern repeats with solid-gap roles reversed.
-	#[implementations(List<f64>, f64, String, List<f64>, f64, String)]
+	#[implementations(
+		List<f64>, f64, String,
+		List<f64>, f64, String,
+		List<f64>, f64, String,
+		List<f64>, f64, String,
+		List<f64>, f64, String,
+		List<f64>, f64, String,
+		List<f64>, f64, String,
+		List<f64>, f64, String,
+		List<f64>, f64, String,
+		List<f64>, f64, String,
+		List<f64>, f64, String,
+		List<f64>, f64, String,
+	)]
 	dash_lengths: L,
 	/// The phase offset distance from the starting point of the dash pattern.
 	#[unit(" px")]
@@ -232,7 +328,8 @@ where
 	let dash_lengths = dash_lengths.into_vec().into_iter().map(|length| length.max(0.)).collect();

 	let stroke = Stroke {
-		color: color.element(0).copied(),
+		// TODO: Remove once the deprecated `Stroke.color` field is deleted in favor of the `ATTR_STROKE` attribute
+		color: None,
 		weight,
 		dash_lengths,
 		dash_offset,
@@ -250,6 +347,13 @@ where
 		vector.style.set_stroke(stroke);
 	});

+	let paint = paint.into_graphic_list();
+	content.for_each_vector_list_mut(|vector_list| {
+		// Broadcast the same paint to every item, scanning the attribute column once instead of per index
+		for slot in vector_list.iter_attribute_values_mut_or_default::<List<Graphic>>(ATTR_STROKE) {
+			*slot = paint.clone();
+		}
+	});
 	content
 }

@@ -1156,15 +1260,21 @@ async fn offset_path(_: impl Ctx, content: List<Vector>, distance: f64, join: St
 }

 #[node_macro::node(category("Vector: Modifier"), path(core_types::vector))]
-async fn solidify_stroke<T: IntoGraphicList + 'n + Send + Clone>(_: impl Ctx, #[implementations(List<Graphic>, List<Vector>)] content: T) -> List<Vector> {
+async fn solidify_stroke<T: IntoGraphicList>(_: impl Ctx, #[implementations(List<Graphic>, List<Vector>)] content: T) -> List<Vector> {
 	// TODO: Make this node support stroke align, which it currently ignores

 	let graphic_list = content.into_graphic_list();
 	let flattened: List<Vector> = graphic_list.clone().into_flattened_list();

+	// A fill exists when the canonical attribute carries paint or, matching the renderer's fallback, when the legacy `style.fill` does
+	let has_fills: Vec<bool> = (0..flattened.len())
+		.map(|index| has_paint_at(&flattened, index, ATTR_FILL) || flattened.element(index).is_some_and(|vector| !vector.style.fill().is_none()))
+		.collect();
+
 	let mut output: List<Vector> = flattened
 		.into_iter()
-		.flat_map(|row| {
+		.zip(has_fills)
+		.flat_map(|(row, has_fill)| {
 			let (mut vector, attributes) = row.into_parts();

 			let stroke = vector.style.stroke().clone().unwrap_or_default();
@@ -1197,7 +1307,7 @@ async fn solidify_stroke<T: IntoGraphicList + 'n + Send + Clone>(_: impl Ctx, #[
 			let stroke_options_default = kurbo::StrokeOpts::default();
 			let stroke_options_stable = kurbo::StrokeOpts::default().stable_dash_order(true);

-			// 0.25 is balanced between performace and accuracy of the curve.
+			// 0.25 is balanced between performance and accuracy of the curve.
 			const STROKE_TOLERANCE: f64 = 0.25;

 			for mut path in bezpaths {
@@ -1214,14 +1324,7 @@ async fn solidify_stroke<T: IntoGraphicList + 'n + Send + Clone>(_: impl Ctx, #[
 				solidified_stroke.append_bezpath(solidified);
 			}

-			// We set the solidified stroke's fill to the stroke's color and without a stroke.
-			if let Some(stroke) = vector.style.stroke() {
-				solidified_stroke.style.set_fill(Fill::solid_or_none(stroke.color));
-			}
-
 			// If the original vector has a fill, preserve it as a separate item with the stroke cleared.
-			let has_attr_fill = attributes.keys().any(|k| k == ATTR_FILL);
-			let has_fill = has_attr_fill || !vector.style.fill().is_none();
 			let fill_row = has_fill.then(|| {
 				vector.style.clear_stroke();
 				let mut fill_attributes = attributes.clone();
@@ -1235,6 +1338,13 @@ async fn solidify_stroke<T: IntoGraphicList + 'n + Send + Clone>(_: impl Ctx, #[
 			stroke_attributes.remove::<List<Graphic>>(ATTR_FILL);
 			stroke_attributes.rename(ATTR_STROKE, ATTR_FILL);

+			// Fall back to the legacy stroke color when no canonical stroke paint attribute was carried over
+			if !stroke_attributes.get::<List<Graphic>>(ATTR_FILL).is_some_and(is_paint_present)
+				&& let Some(color) = stroke.color
+			{
+				set_paint_attribute(&mut stroke_attributes, ATTR_FILL, List::new_from_element(color));
+			}
+
 			let stroke_row = Item::from_parts(solidified_stroke, stroke_attributes);

 			// Ordering based on the paint order. The first item in the `List` is rendered below the second.
@@ -1331,12 +1441,14 @@ async fn map_points(ctx: impl Ctx + CloneVarArgs + ExtractAll, content: List<Vec

 // TODO: Rename to "Combine Paths" and make this happen per-element instead of flattening every element into a single path. The migration for this should then become a Flatten Vector -> Combine Paths pair of nodes.
 #[node_macro::node(category("Vector"), path(graphene_core::vector))]
-pub async fn flatten_path<T: IntoGraphicList + 'n + Send>(_: impl Ctx, #[implementations(List<Graphic>, List<Vector>)] content: T) -> List<Vector> {
+pub async fn flatten_path<T: IntoGraphicList>(_: impl Ctx, #[implementations(List<Graphic>, List<Vector>)] content: T) -> List<Vector> {
 	let graphic_list = content.into_graphic_list();
 	let flattened = graphic_list.clone().into_flattened_list::<Vector>();

 	// Create a `List` with one empty `Vector` element, then get a mutable reference to it which we append flattened subpaths to
 	let mut output_list = List::new_from_element(Vector::default());
+	let mut primary_source = None;
+
 	let output = output_list.element_mut(0).unwrap();

 	// Concatenate every vector element's subpaths into the single output compound path
@@ -1349,11 +1461,30 @@ pub async fn flatten_path<T: IntoGraphicList + 'n + Send>(_: impl Ctx, #[impleme
 		(index, node_id).hash(&mut hasher);
 		let collision_hash_seed = hasher.finish();

-		output.concat(element, flattened.attribute_cloned_or_default(ATTR_TRANSFORM, index), collision_hash_seed);
+		let source_transform = flattened.attribute_cloned_or_default(ATTR_TRANSFORM, index);
+		output.concat(element, source_transform, collision_hash_seed);

 		// TODO: Make this instead use the first encountered style
 		// Use the last encountered style as the output style
 		output.style = element.style.clone();
+
+		primary_source = Some((index, source_transform));
+	}
+
+	if let Some((primary, source_transform)) = primary_source {
+		let source_attributes = flattened.clone_item_attributes(primary);
+		let mut attributes = ItemAttributeValues::new();
+
+		attributes.insert_cloned_from(&source_attributes, ATTR_FILL);
+		attributes.insert_cloned_from(&source_attributes, ATTR_STROKE);
+		bake_paint_transforms(&mut attributes, source_transform);
+
+		let output = std::mem::take(output_list.element_mut(0).unwrap());
+		output_list = List::new_from_item(Item::from_parts(output, attributes));
+
+		// Adopt the last input item's layer so the editor can also bucket clicks under a contributing child layer
+		let layer_path: List<NodeId> = flattened.attribute_cloned_or_default(ATTR_EDITOR_LAYER_PATH, primary);
+		output_list.set_attribute(ATTR_EDITOR_LAYER_PATH, 0, layer_path);
 	}

 	// Preserve a reference to the original upstream `List<Graphic>` so the renderer can recurse into it
@@ -1361,13 +1492,6 @@ pub async fn flatten_path<T: IntoGraphicList + 'n + Send>(_: impl Ctx, #[impleme
 	// This is the same mechanism Boolean Operation uses to keep its inputs editable after the merge.
 	output_list.set_attribute(ATTR_EDITOR_MERGED_LAYERS, 0, graphic_list);

-	// Adopt the last input item's layer so the editor can also bucket clicks under a contributing child layer
-	if !flattened.is_empty() {
-		let primary = flattened.len() - 1;
-		let layer_path: List<NodeId> = flattened.attribute_cloned_or_default(ATTR_EDITOR_LAYER_PATH, primary);
-		output_list.set_attribute(ATTR_EDITOR_LAYER_PATH, 0, layer_path);
-	}
-
 	output_list
 }

@@ -2064,7 +2188,7 @@ async fn offset_points(
 ///
 /// *Progression* morphs through all objects. Interpolation is linear unless *Path* geometry is provided to control the trajectory between key objects. The **Origins to Polyline** node may be used to create a path with anchor points corresponding to each object. Other nodes can modify its path segments.
 #[node_macro::node(category("Vector: Modifier"), path(core_types::vector))]
-async fn morph<I: IntoGraphicList + 'n + Send + Clone>(
+async fn morph<I: IntoGraphicList>(
 	_: impl Ctx,
 	/// The vector objects to interpolate between. Mixed graphic content is deeply flattened to keep only vector elements.
 	#[implementations(List<Graphic>, List<Vector>)]
@@ -2177,6 +2301,79 @@ async fn morph<I: IntoGraphicList + 'n + Send + Clone>(
 		}
 	}

+	fn lerp_gradient_transform(gradient_list_a: &List<GradientStops>, gradient_list_b: &List<GradientStops>, time: f64) -> DAffine2 {
+		let transform_a = gradient_list_a.attribute_cloned_or_default::<DAffine2>(ATTR_TRANSFORM, 0);
+		let transform_b = gradient_list_b.attribute_cloned_or_default::<DAffine2>(ATTR_TRANSFORM, 0);
+
+		let start_a = transform_a.translation;
+		let end_a = transform_a.translation + transform_a.matrix2.x_axis;
+		let start_b = transform_b.translation;
+		let end_b = transform_b.translation + transform_b.matrix2.x_axis;
+
+		let start = start_a.lerp(start_b, time);
+		let end = end_a.lerp(end_b, time);
+
+		let metadata_source_transform = if time < 0.5 { transform_a } else { transform_b };
+		build_transform_with_y_preservation(metadata_source_transform, start, end)
+	}
+
+	// Lerp between two graphics. Solid color and gradient pairings interpolate; all other pairings step at the midpoint.
+	fn lerp_graphic(a: Option<&List<Graphic>>, b: Option<&List<Graphic>>, time: f64) -> Option<List<Graphic>> {
+		let transparent = List::new_from_element(Color::TRANSPARENT).into_graphic_list();
+
+		let a = a.filter(|graphic_list| is_paint_present(graphic_list));
+		let b = b.filter(|graphic_list| is_paint_present(graphic_list));
+
+		let (a, b) = match (a, b) {
+			(None, None) => return None,
+			(Some(a), None) => (a, &transparent),
+			(None, Some(b)) => (&transparent, b),
+			(Some(a), Some(b)) => (a, b),
+		};
+
+		// This keeps the gradient metadata attributes
+		let gradient_with_stops = |mut gradient_list: List<GradientStops>, stops: GradientStops| -> Graphic {
+			if let Some(target) = gradient_list.element_mut(0) {
+				*target = stops;
+			} else {
+				gradient_list.push(Item::new_from_element(stops));
+			}
+			Graphic::Gradient(gradient_list)
+		};
+
+		let graphic = match (a.element(0), b.element(0)) {
+			(Some(Graphic::Color(color_list_a)), Some(Graphic::Color(color_list_b))) => color_list_a
+				.element(0)
+				.zip(color_list_b.element(0))
+				.map(|(color_a, color_b)| Graphic::from(color_a.lerp(color_b, time as f32))),
+			(Some(Graphic::Color(color_list_a)), Some(Graphic::Gradient(gradient_list_b))) => color_list_a.element(0).zip(gradient_list_b.element(0)).map(|(color_a, stops_b)| {
+				let mut solid_to_gradient = stops_b.clone();
+				solid_to_gradient.color.iter_mut().for_each(|color| *color = *color_a);
+				let stops = solid_to_gradient.lerp(stops_b, time);
+				gradient_with_stops(gradient_list_b.clone(), stops)
+			}),
+			(Some(Graphic::Gradient(gradient_list_a)), Some(Graphic::Color(color_list_b))) => gradient_list_a.element(0).zip(color_list_b.element(0)).map(|(stops_a, color_b)| {
+				let mut gradient_to_solid = stops_a.clone();
+				gradient_to_solid.color.iter_mut().for_each(|color| *color = *color_b);
+				let stops = stops_a.lerp(&gradient_to_solid, time);
+				gradient_with_stops(gradient_list_a.clone(), stops)
+			}),
+			(Some(Graphic::Gradient(gradient_list_a)), Some(Graphic::Gradient(gradient_list_b))) => gradient_list_a.element(0).zip(gradient_list_b.element(0)).map(|(stops_a, stops_b)| {
+				let stops = stops_a.lerp(stops_b, time);
+				let metadata_source = if time < 0.5 { gradient_list_a } else { gradient_list_b };
+
+				let mut gradient_list = metadata_source.clone();
+				gradient_list.set_attribute(ATTR_TRANSFORM, 0, lerp_gradient_transform(gradient_list_a, gradient_list_b, time));
+
+				gradient_with_stops(gradient_list, stops)
+			}),
+			// Pairings beyond solid colors and gradients (raster, vector, or mixed) can't be interpolated, so step at the midpoint
+			_ => return Some(if time < 0.5 { a.clone() } else { b.clone() }),
+		};
+
+		graphic.map(List::new_from_element)
+	}
+
 	// Preserve original `List<Graphic>` as upstream data so this group layer's nested layers can be edited by the tools.
 	let mut graphic_list_content = content.clone().into_graphic_list();

@@ -2435,9 +2632,35 @@ async fn morph<I: IntoGraphicList + 'n + Send + Clone>(
 		return List::new_from_item(Item::from_parts(endpoint_element.clone(), attributes));
 	}

-	let mut vector = Vector {
-		style: source_element.style.lerp(&target_element.style, time),
-		..Default::default()
+	let mut vector = Vector::default();
+	vector.style.stroke = match (source_element.style.stroke.as_ref(), target_element.style.stroke.as_ref()) {
+		(Some(a), Some(b)) => Some(a.lerp(b, time)),
+		(Some(a), None) => {
+			if time < 0.5 {
+				Some(a.clone())
+			} else {
+				None
+			}
+		}
+		(None, Some(b)) => {
+			if time < 0.5 {
+				None
+			} else {
+				Some(b.clone())
+			}
+		}
+		(None, None) => None,
+	};
+
+	let fill_paint = {
+		let source = fill_graphic_list_at(&content, source_index);
+		let target = fill_graphic_list_at(&content, target_index);
+		lerp_graphic(source.as_deref(), target.as_deref(), time)
+	};
+	let stroke_paint = {
+		let source = stroke_graphic_list_at(&content, source_index);
+		let target = stroke_graphic_list_at(&content, target_index);
+		lerp_graphic(source.as_deref(), target.as_deref(), time)
 	};

 	// Work directly with manipulator groups, bypassing the BezPath intermediate representation.
@@ -2588,16 +2811,23 @@ async fn morph<I: IntoGraphicList + 'n + Send + Clone>(
 	let primary_index = if time < 0.5 { source_index } else { target_index };
 	let layer_path: List<NodeId> = content.attribute_cloned_or_default(ATTR_EDITOR_LAYER_PATH, primary_index);

-	List::new_from_item(
-		Item::new_from_element(vector)
-			.with_attribute(ATTR_TRANSFORM, lerped_transform)
-			.with_attribute(ATTR_BLEND_MODE, lerped_blend_mode)
-			.with_attribute(ATTR_OPACITY, lerped_opacity)
-			.with_attribute(ATTR_OPACITY_FILL, lerped_fill)
-			.with_attribute(ATTR_CLIPPING_MASK, lerped_clip)
-			.with_attribute(ATTR_EDITOR_LAYER_PATH, layer_path)
-			.with_attribute(ATTR_EDITOR_MERGED_LAYERS, graphic_list_content),
-	)
+	let mut item = Item::new_from_element(vector)
+		.with_attribute(ATTR_TRANSFORM, lerped_transform)
+		.with_attribute(ATTR_BLEND_MODE, lerped_blend_mode)
+		.with_attribute(ATTR_OPACITY, lerped_opacity)
+		.with_attribute(ATTR_OPACITY_FILL, lerped_fill)
+		.with_attribute(ATTR_CLIPPING_MASK, lerped_clip)
+		.with_attribute(ATTR_EDITOR_LAYER_PATH, layer_path)
+		.with_attribute(ATTR_EDITOR_MERGED_LAYERS, graphic_list_content);
+
+	if let Some(fill) = fill_paint {
+		item.set_attribute(ATTR_FILL, fill);
+	}
+	if let Some(stroke) = stroke_paint {
+		item.set_attribute(ATTR_STROKE, stroke);
+	}
+
+	List::new_from_item(item)
 }

 fn bevel_algorithm(mut vector: Vector, transform: DAffine2, distance: f64) -> Vector {
@@ -3207,6 +3437,36 @@ mod test {
 		assert!((morphed.attribute_cloned_or_default::<DAffine2>(ATTR_TRANSFORM, 0).translation - DVec2::new(-50., -50.)).length() < 1e-3);
 	}

+	#[tokio::test]
+	async fn morph_interpolates_fill() {
+		let rect = || {
+			let mut v = Vector::default();
+			v.append_bezpath(Rect::new(0., 0., 100., 100.).to_path(DEFAULT_ACCURACY));
+			v
+		};
+
+		let item_a = Item::new_from_element(rect())
+			.with_attribute(ATTR_TRANSFORM, DAffine2::IDENTITY)
+			.with_attribute(ATTR_FILL, List::new_from_element(Color::RED).into_graphic_list());
+		let item_b = Item::new_from_element(rect())
+			.with_attribute(ATTR_TRANSFORM, DAffine2::from_translation((-100., -100.).into()))
+			.with_attribute(ATTR_FILL, List::new_from_element(Color::BLUE).into_graphic_list());
+
+		let mut content = List::new_from_item(item_a);
+		content.push(item_b);
+
+		let morphed = super::morph(Footprint::default(), content, 0.5, false, InterpolationDistribution::default(), List::default()).await;
+
+		let fill = fill_graphic_list_at(&morphed, 0).expect("Morph should keep the fill paint at the midpoint");
+
+		// Interpolated color between red and blue should have >0 value on both R and B
+		let Some(Graphic::Color(colors)) = fill.element(0) else {
+			panic!("Expected a solid color fill, got {:?}", fill.element(0));
+		};
+		let color = *colors.element(0).expect("Color present");
+		assert!(color.r() > 0. && color.b() > 0., "Fill should be a red-to-blue blend, got {color:?}");
+	}
+
 	#[track_caller]
 	fn contains_segment(vector: Vector, target: PathSeg) {
 		let segments = vector.segment_iter().map(|x| x.1);