Rename gradient type to gradient form (#4405)

* Rename gradient type to gradient form

* Update the demo art for the gradient form rename

* Say form not type in the Gradient Form node's doc comment

node-graph/graph-craft/src/document/value.rs

@@ -167,15 +167,7 @@ macro_rules! tagged_value {
 					Self::DashPattern(lengths) => Box::new(DashPattern::from(lengths)),
 					Self::BoxCorners(values) => Box::new(BoxCorners::from(values)),
 					Self::Color(color) => Box::new(List::<Color>::new_from_element(color)),
-					Self::GradientRamp(ramp) => {
-						// The ramp's spread method rides the served list as its attribute, as `Item<Gradient>::from` does on master.
-						let spread_method = ramp.spread_method;
-						let mut list = List::<Gradient>::new_from_element(Gradient::from(ramp));
-						if !spread_method.is_default() {
-							list.set_attribute(graphic_types::vector_types::ATTR_SPREAD_METHOD, 0, spread_method);
-						}
-						Box::new(list)
-					}
+					Self::GradientRamp(ramp) => Box::new(List::new_from_item(Item::<Gradient>::from(ramp))),
 					Self::BrushStrokes(strokes) => {
 						let list: List<BrushStroke> = strokes.into_iter().map(core_types::list::Item::new_from_element).collect();
 						Box::new(list)
@@ -221,15 +213,7 @@ macro_rules! tagged_value {
 					Self::DashPattern(lengths) => Arc::new(DashPattern::from(lengths)),
 					Self::BoxCorners(values) => Arc::new(BoxCorners::from(values)),
 					Self::Color(color) => Arc::new(List::<Color>::new_from_element(color)),
-					Self::GradientRamp(ramp) => {
-						// The ramp's spread method rides the served list as its attribute, as `Item<Gradient>::from` does on master.
-						let spread_method = ramp.spread_method;
-						let mut list = List::<Gradient>::new_from_element(Gradient::from(ramp));
-						if !spread_method.is_default() {
-							list.set_attribute(graphic_types::vector_types::ATTR_SPREAD_METHOD, 0, spread_method);
-						}
-						Arc::new(list)
-					}
+					Self::GradientRamp(ramp) => Arc::new(List::new_from_item(Item::<Gradient>::from(ramp))),
 					Self::BrushStrokes(strokes) => {
 						let list: List<BrushStroke> = strokes.into_iter().map(core_types::list::Item::new_from_element).collect();
 						Arc::new(list)
@@ -636,8 +620,8 @@ tagged_value! {
 	StrokeJoin(vector::style::StrokeJoin),
 	StrokeAlign(vector::style::StrokeAlign),
 	PaintOrder(vector::style::PaintOrder),
-	GradientType(vector::style::GradientType),
-	#[serde(alias = "GradientSpreadMethod")] // TODO: Eventually remove this document upgrade code
+	GradientForm(vector::style::GradientForm),
+	#[serde(alias = "GradientSpread")] // TODO: Eventually remove this document upgrade code
 	GradientSpread(vector::style::GradientSpread),
 	ReferencePoint(vector::ReferencePoint),
 	CentroidType(vector::misc::CentroidType),

node-graph/libraries/core-types/src/list.rs

@@ -1161,7 +1161,7 @@ impl<T: CacheHash> CacheHash for List<T> {
 		self.element.cache_hash(state);
 
 		// Hash every attribute attribute (key + values) rather than just the well-known ones, so changes to user-defined keys
-		// (e.g., gradient_type, gradient_spread) invalidate downstream graph caches as expected
+		// (e.g., gradient_form, gradient_spread) invalidate downstream graph caches as expected
 		for (key, attribute) in &self.attributes.attributes {
 			std::hash::Hash::hash(key.as_str(), state);
 			attribute.cache_hash_dyn(state);

node-graph/libraries/graphic-types/src/lib.rs

@@ -32,7 +32,7 @@ pub mod migrations {
 		pub struct LegacyGradient {
 			#[serde(deserialize_with = "crate::migrations::migrate_to_gradient_ramp")]
 			pub stops: GradientRamp,
-			pub gradient_type: vector::style::GradientType,
+			pub gradient_type: vector::style::GradientForm,
 			pub start: DVec2,
 			pub end: DVec2,
 			#[serde(default)]
@@ -54,7 +54,7 @@ pub mod migrations {
 
 				// The legacy radial drew as a circle in the layer's own space; bake the adjustment that, composed with the
 				// endpoint frame, makes the new pipeline reproduce that circle through the (possibly non-uniform) layer transform.
-				let radial_invertible = self.gradient_type == vector::style::GradientType::Radial
+				let radial_invertible = self.gradient_type == vector::style::GradientForm::Radial
 					&& layer_transform.is_finite()
 					&& layer_transform.matrix2.determinant().recip().is_finite()
 					&& direction.length_squared() > 1e-20;

node-graph/libraries/rendering/src/render_ext.rs

@@ -7,8 +7,8 @@ use core_types::list::List;
 use core_types::uuid::generate_uuid;
 use glam::{DAffine2, DVec2};
 use graphic_types::Graphic;
-use graphic_types::vector_types::gradient::GradientType;
-use graphic_types::vector_types::markers::{GradientSpread as GradientSpreadAttr, GradientType as GradientTypeAttr};
+use graphic_types::vector_types::gradient::GradientForm;
+use graphic_types::vector_types::markers::{GradientForm as GradientFormAttr, GradientSpread as GradientSpreadAttr};
 use graphic_types::vector_types::vector::style::{PaintOrder, Stroke, StrokeAlign, StrokeCap, StrokeJoin};
 use std::fmt::Write;
 use vector_types::Gradient;
@@ -108,7 +108,7 @@ pub fn render_gradient_paint<S: core_types::lane::LaneSource<Element = Gradient>
 
 	{
 		let Some(stops) = source.element(0) else { return 0 };
-		let gradient_type: GradientType = source.attr::<GradientTypeAttr>(0);
+		let gradient_form: GradientForm = source.attr::<GradientFormAttr>(0);
 		let local_gradient_transform: DAffine2 = source.attr::<Transform>(0);
 		let gradient_spread: GradientSpread = source.attr::<GradientSpreadAttr>(0);
 
@@ -141,7 +141,7 @@ pub fn render_gradient_paint<S: core_types::lane::LaneSource<Element = Gradient>
 
 		let document_transform = item_transform * local_gradient_transform;
 
-		let placement = gradient_placement(document_transform, gradient_type);
+		let placement = gradient_placement(document_transform, gradient_form);
 		let gradient_transform = format_transform_matrix(element_transform_inverse * placement);
 		let gradient_transform = if gradient_transform.is_empty() {
 			String::new()
@@ -157,15 +157,15 @@ pub fn render_gradient_paint<S: core_types::lane::LaneSource<Element = Gradient>
 
 		let gradient_id = generate_uuid();
 
-		match gradient_type {
-			GradientType::Linear => {
+		match gradient_form {
+			GradientForm::Linear => {
 				let _ = write!(
 					svg_defs,
 					r#"<linearGradient id="{}" gradientUnits="userSpaceOnUse" x1="0" y1="0" x2="1" y2="0"{gradient_spread}{gradient_transform}>{}</linearGradient>"#,
 					gradient_id, stop
 				);
 			}
-			GradientType::Radial => {
+			GradientForm::Radial => {
 				let _ = write!(
 					svg_defs,
 					r#"<radialGradient id="{}" gradientUnits="userSpaceOnUse" cx="0" cy="0" r="1"{gradient_spread}{gradient_transform}>{}</radialGradient>"#,

node-graph/libraries/rendering/src/renderer.rs

@@ -26,8 +26,8 @@ use graphene_resource::Resource;
 use graphic_types::graphic::{PaintColumns, PaintOverlay, PaintReach, has_paint, is_paint_present, paint_graphics, set_paint_attribute, vector_can_reduce_to_clip_path};
 use graphic_types::markers::{EditorMergedLayers, Fill, Stroke};
 use graphic_types::raster_types::{BitmapMut, CPU, GPU, Image, Raster, Texture};
-use graphic_types::vector_types::gradient::{Gradient, GradientType};
-use graphic_types::vector_types::markers::{GradientSpread as GradientSpreadAttr, GradientType as GradientTypeAttr};
+use graphic_types::vector_types::gradient::{Gradient, GradientForm};
+use graphic_types::vector_types::markers::{GradientForm as GradientFormAttr, GradientSpread as GradientSpreadAttr};
 use graphic_types::vector_types::subpath::Subpath;
 use graphic_types::vector_types::vector::click_target::{ClickTarget, FreePoint};
 use graphic_types::vector_types::vector::style::{PaintOrder, RenderMode, StrokeAlign, StrokeCap, StrokeJoin};
@@ -385,10 +385,10 @@ pub(crate) fn transform_is_invertible(transform: DAffine2) -> bool {
 /// non-uniform transform makes an ellipse), while linear is reduced to the equivalent non-sheared gradient line (the
 /// axis projected onto the band normal) so the iso-color bands keep following a sheared transform, which Vello can
 /// represent since it stores only two endpoints.
-pub(crate) fn gradient_placement(transform: DAffine2, gradient_type: GradientType) -> DAffine2 {
-	match gradient_type {
-		GradientType::Radial => transform,
-		GradientType::Linear => {
+pub(crate) fn gradient_placement(transform: DAffine2, gradient_form: GradientForm) -> DAffine2 {
+	match gradient_form {
+		GradientForm::Radial => transform,
+		GradientForm::Linear => {
 			let axis = transform.matrix2.x_axis;
 			let band_normal = transform.matrix2.y_axis.perp();
 			let line = if band_normal.length_squared() > 0. { axis.project_onto(band_normal) } else { axis };
@@ -428,23 +428,23 @@ fn peniko_color_stops(gradient: &Gradient) -> peniko::ColorStops {
 fn create_peniko_gradient_brush<S: LaneSource<Element = Gradient>>(gradient_list: &S, multiplied_transform: &DAffine2) -> Option<(peniko::Brush, DAffine2)> {
 	let stops = gradient_list.element(0)?;
 
-	let gradient_type: GradientType = gradient_list.attr::<GradientTypeAttr>(0);
+	let gradient_form: GradientForm = gradient_list.attr::<GradientFormAttr>(0);
 	let gradient_transform: DAffine2 = gradient_list.attr::<Transform>(0);
 	let gradient_spread: GradientSpread = gradient_list.attr::<GradientSpreadAttr>(0);
 
 	let peniko_stops = peniko_color_stops(stops);
 
 	// The unit gradient is placed by the desheared frame so a non-uniform transform produces the intended ellipse
-	let (start, end, gradient_to_device) = (DVec2::ZERO, DVec2::X, gradient_placement(multiplied_transform * gradient_transform, gradient_type));
+	let (start, end, gradient_to_device) = (DVec2::ZERO, DVec2::X, gradient_placement(multiplied_transform * gradient_transform, gradient_form));
 
 	let brush = peniko::Brush::Gradient(peniko::Gradient {
-		kind: match gradient_type {
-			GradientType::Linear => peniko::LinearGradientPosition {
+		kind: match gradient_form {
+			GradientForm::Linear => peniko::LinearGradientPosition {
 				start: to_point(start),
 				end: to_point(end),
 			}
 			.into(),
-			GradientType::Radial => peniko::RadialGradientPosition {
+			GradientForm::Radial => peniko::RadialGradientPosition {
 				start_center: to_point(start),
 				start_radius: 0.,
 				end_center: to_point(start),
@@ -2328,7 +2328,7 @@ fn render_gradient_svg<S: LaneSource<Element = Gradient>>(source: &S, render: &m
 		let opacity_attr: f64 = source.attr::<Opacity>(index);
 		let opacity_fill_attr: f64 = source.attr::<OpacityFill>(index);
 		let gradient_spread: GradientSpread = source.attr::<GradientSpreadAttr>(index);
-		let gradient_type: GradientType = source.attr::<GradientTypeAttr>(index);
+		let gradient_form: GradientForm = source.attr::<GradientFormAttr>(index);
 		let tag = if thumbnail_rect.is_some() { "rect" } else { "polyline" };
 		render.leaf_tag(tag, |attributes| {
 			if let Some((min, size)) = thumbnail_rect {
@@ -2373,14 +2373,14 @@ fn render_gradient_svg<S: LaneSource<Element = Gradient>>(source: &S, render: &m
 			};
 
 			// The unit gradient line is the +X unit vector in local space, before the item's transform is applied
-			match gradient_type {
-				GradientType::Linear => {
+			match gradient_form {
+				GradientForm::Linear => {
 					let _ = write!(
 						&mut attributes.0.svg_defs,
 						r#"<linearGradient id="{gradient_id}" gradientUnits="userSpaceOnUse" x1="0" y1="0" x2="1" y2="0"{spread_method_attribute}{gradient_transform_attribute}>{stop_string}</linearGradient>"#
 					);
 				}
-				GradientType::Radial => {
+				GradientForm::Radial => {
 					let _ = write!(
 						&mut attributes.0.svg_defs,
 						r#"<radialGradient id="{gradient_id}" gradientUnits="userSpaceOnUse" cx="0" cy="0" r="1"{spread_method_attribute}{gradient_transform_attribute}>{stop_string}</radialGradient>"#
@@ -2412,7 +2412,7 @@ fn render_gradient_vello<S: LaneSource<Element = Gradient>>(source: &S, scene: &
 	for index in 0..source.lane_count() {
 		let Some(gradient) = source.element(index) else { continue };
 		let gradient_spread: GradientSpread = source.attr::<GradientSpreadAttr>(index);
-		let gradient_type: GradientType = source.attr::<GradientTypeAttr>(index);
+		let gradient_form: GradientForm = source.attr::<GradientFormAttr>(index);
 		let transform: DAffine2 = source.attr::<Transform>(index);
 		let blend_mode_attr: BlendMode = source.attr::<BlendModeAttr>(index);
 		let opacity_attr: f64 = source.attr::<Opacity>(index);
@@ -2432,13 +2432,13 @@ fn render_gradient_vello<S: LaneSource<Element = Gradient>>(source: &S, scene: &
 
 		// The unit gradient line is the +X unit vector in local space, before the item's transform is applied.
 		// For radial, the unit-radius circle at the origin scales out to the line's length once the brush transform applies.
-		let kind = match gradient_type {
-			GradientType::Linear => peniko::LinearGradientPosition {
+		let kind = match gradient_form {
+			GradientForm::Linear => peniko::LinearGradientPosition {
 				start: to_point(DVec2::ZERO),
 				end: to_point(DVec2::X),
 			}
 			.into(),
-			GradientType::Radial => peniko::RadialGradientPosition {
+			GradientForm::Radial => peniko::RadialGradientPosition {
 				start_center: to_point(DVec2::ZERO),
 				start_radius: 0.,
 				end_center: to_point(DVec2::ZERO),
@@ -2454,7 +2454,7 @@ fn render_gradient_vello<S: LaneSource<Element = Gradient>>(source: &S, scene: &
 			interpolation_alpha_space: peniko::InterpolationAlphaSpace::Premultiplied,
 			..Default::default()
 		});
-		let brush_transform = kurbo::Affine::new(gradient_placement(gradient_transform, gradient_type).to_cols_array());
+		let brush_transform = kurbo::Affine::new(gradient_placement(gradient_transform, gradient_form).to_cols_array());
 		let rect = kurbo::Rect::from_origin_size(kurbo::Point::ZERO, kurbo::Size::new(1., 1.));
 
 		let mut layer = false;

node-graph/libraries/vector-types/src/gradient.rs

@@ -10,7 +10,7 @@ use glam::{DAffine2, DVec2};
 #[derive(Default, PartialEq, Eq, Clone, Copy, Debug, Hash, graphene_hash::CacheHash, DynAny, node_macro::ChoiceType)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[widget(Radio)]
-pub enum GradientType {
+pub enum GradientForm {
 	#[default]
 	Linear,
 	Radial,

node-graph/libraries/vector-types/src/lib.rs

@@ -9,8 +9,8 @@ pub mod vector;
 
 // Re-export commonly used types at the crate root
 pub use core_types as gcore;
-pub use gradient::{Gradient, GradientRamp, GradientSpread, GradientStop, GradientType};
-pub use markers::{ATTR_EDITOR_CLICK_TARGET, ATTR_GRADIENT_SPREAD, ATTR_GRADIENT_TYPE};
+pub use gradient::{Gradient, GradientForm, GradientRamp, GradientSpread, GradientStop};
+pub use markers::{ATTR_EDITOR_CLICK_TARGET, ATTR_GRADIENT_FORM, ATTR_GRADIENT_SPREAD};
 pub use math::{QuadExt, RectExt};
 pub use subpath::Subpath;
 pub use vector::Vector;

node-graph/libraries/vector-types/src/markers.rs

@@ -7,7 +7,7 @@ core_types::attribute! {
 	/// Gradient's spread behavior past its endpoints (`Pad`, `Reflect`, or `Repeat`).
 	pub GradientSpread("gradient_spread"): crate::gradient::GradientSpread;
 	/// Gradient's shape (`Linear` or `Radial`).
-	pub GradientType("gradient_type"): crate::gradient::GradientType;
+	pub GradientForm("gradient_form"): crate::gradient::GradientForm;
 	/// Optional `Vector` that overrides the item's own geometry for click-target generation.
 	/// Used by the 'Text' node for per-glyph bounding-box rectangles so glyphs are selectable
 	/// by clicking anywhere within their bounds, not just the filled letterform. An absent
@@ -19,11 +19,11 @@ core_types::attribute! {
 // named write or read reaches this crate's enums like any other plain value.
 core_types::named_value! {
 	for crate::gradient::GradientSpread;
-	for crate::gradient::GradientType;
+	for crate::gradient::GradientForm;
 }
 
 pub const ATTR_GRADIENT_SPREAD: &str = GradientSpread::NAME;
-pub const ATTR_GRADIENT_TYPE: &str = GradientType::NAME;
+pub const ATTR_GRADIENT_FORM: &str = GradientForm::NAME;
 pub const ATTR_EDITOR_CLICK_TARGET: &str = EditorClickTarget::NAME;
 
 #[cfg(test)]
@@ -34,7 +34,7 @@ mod tests {
 
 	#[test]
 	fn the_census_carries_this_crates_names() {
-		assert_eq!(info("gradient_type").unwrap().value_type, TypeId::of::<crate::gradient::GradientType>());
+		assert_eq!(info("gradient_form").unwrap().value_type, TypeId::of::<crate::gradient::GradientForm>());
 		assert_eq!(info("gradient_spread").unwrap().value_type, TypeId::of::<crate::gradient::GradientSpread>());
 		assert_eq!(info("editor:click_target").unwrap().value_type, TypeId::of::<Option<&'static crate::Vector>>());
 	}

node-graph/nodes/graphic/src/graphic.rs

@@ -14,7 +14,7 @@ use rand::seq::SliceRandom;
 use raster_types::{CPU, GPU, Raster};
 use std::cmp::Ordering;
 
-use vector_types::gradient::{GradientSpread, GradientType as GradientTypeValue};
+use vector_types::gradient::{GradientForm as GradientFormValue, GradientSpread};
 use vector_types::{Gradient, ReferencePoint};
 
 /// Resolves a signed index over `total` lanes: negatives count from the end,
@@ -721,8 +721,8 @@ attribute_reads! {
 	read_color_attribute: Color => Color;
 	/// Reads a named `BlendMode` attribute, such as `blend_mode`.
 	read_blend_mode_attribute: core_types::blending::BlendMode => core_types::blending::BlendMode;
-	/// Reads a named gradient-shape attribute, such as `gradient_type`.
-	read_gradient_type_attribute: GradientTypeValue => GradientTypeValue;
+	/// Reads a named gradient-shape attribute, such as `gradient_form`.
+	read_gradient_form_attribute: GradientFormValue => GradientFormValue;
 	/// Reads a named gradient-spread attribute, such as `gradient_spread`.
 	read_gradient_spread_attribute: GradientSpread => GradientSpread;
 }

node-graph/nodes/math/src/lib.rs

@@ -12,7 +12,7 @@ use math_parser::value::{Number, Value};
 use rand::{Rng, SeedableRng};
 use std::ops::{Add, Mul, Rem, Sub};
 use vector_types::Gradient;
-use vector_types::markers::{GradientSpread as GradientSpreadAttr, GradientType as GradientTypeAttr};
+use vector_types::markers::{GradientForm as GradientFormAttr, GradientSpread as GradientSpreadAttr};
 
 /// The struct that stores the context for the maths parser.
 /// This is currently just limited to supplying `a` and `b` until we add better node graph support and UI for variadic inputs.
@@ -1203,10 +1203,10 @@ fn gradient_value(_: impl Ctx, _primary: (), #[default(Color::BLACK, Color::WHIT
 	gradient
 }
 
-/// Sets the type (linear or radial) of each gradient in the input list.
+/// Sets the form (linear or radial) of each gradient in the input list.
 #[node_macro::node(category("Gradient"))]
-fn gradient_type(_: impl Ctx, gradient: Gradient, gradient_type: vector_types::GradientType) -> (Gradient, Attr<GradientTypeAttr>) {
-	(gradient, Attr(gradient_type))
+fn gradient_form(_: impl Ctx, gradient: Gradient, gradient_form: vector_types::GradientForm) -> (Gradient, Attr<GradientFormAttr>) {
+	(gradient, Attr(gradient_form))
 }
 
 /// Sets how each gradient in the input list extends past its endpoints: Pad, Reflect, or Repeat.

node-graph/nodes/path-bool/src/lib.rs

@@ -7,11 +7,11 @@ use graphic_types::graphic::{GraphicLevel, PaintColumns, PaintReach, bake_paint_
 use graphic_types::markers::{EditorMergedLayers, Fill, Stroke};
 use graphic_types::raster_types::{CPU, GPU, Raster};
 use graphic_types::vector_types::Gradient;
-use graphic_types::vector_types::gradient::{GradientSpread, GradientType};
+use graphic_types::vector_types::gradient::{GradientForm, GradientSpread};
 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::{ATTR_GRADIENT_SPREAD, ATTR_GRADIENT_TYPE};
+use graphic_types::vector_types::{ATTR_GRADIENT_FORM, ATTR_GRADIENT_SPREAD};
 use graphic_types::{ATTR_FILL, ATTR_STROKE, Graphic, IntoGraphicList, Vector};
 use linesweeper::topology::Topology;
 use linesweeper::{BinaryOp, FillRule, binary_op};
@@ -324,8 +324,8 @@ fn gradient_paint_row(stops: Gradient, mut attributes: core_types::list::ItemAtt
 	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(gradient_form) = attributes.remove::<GradientForm>(ATTR_GRADIENT_FORM) {
+		gradient_paint.set_attribute(ATTR_GRADIENT_FORM, 0, gradient_form);
 	}
 	if let Some(spread_method) = attributes.remove::<GradientSpread>(ATTR_GRADIENT_SPREAD) {
 		gradient_paint.set_attribute(ATTR_GRADIENT_SPREAD, 0, spread_method);

node-graph/nodes/vector/src/vector_nodes.rs

@@ -27,8 +27,8 @@ use kurbo::{Affine, BezPath, DEFAULT_ACCURACY, Line, ParamCurve, ParamCurveArcle
 use rand::{Rng, SeedableRng};
 use std::collections::hash_map::DefaultHasher;
 use std::collections::{HashMap, HashSet};
-use vector_types::ATTR_GRADIENT_TYPE;
-use vector_types::GradientType;
+use vector_types::ATTR_GRADIENT_FORM;
+use vector_types::GradientForm;
 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::algorithms::bezpath_algorithms::{self, TValue, eval_pathseg_euclidean, evaluate_bezpath, split_bezpath, tangent_on_bezpath};
@@ -290,15 +290,15 @@ fn park_paint<'e>(arena: &'e core_types::arena::Arena, paint: List<Graphic<'stat
 
 /// The gradient defaulting the legacy fill performed, applied to the nested
 /// stops list the paint table wraps.
-fn default_gradient_paint(paint: &mut List<Graphic>, bounds: Option<[DVec2; 2]>, gradient_type: GradientType, transform: Option<DAffine2>) {
-	let has_type = paint.iter_attribute_values::<GradientType>(ATTR_GRADIENT_TYPE).is_some();
+fn default_gradient_paint(paint: &mut List<Graphic>, bounds: Option<[DVec2; 2]>, gradient_type: GradientForm, transform: Option<DAffine2>) {
+	let has_type = paint.iter_attribute_values::<GradientForm>(ATTR_GRADIENT_FORM).is_some();
 	let has_transform = paint.iter_attribute_values::<DAffine2>(ATTR_TRANSFORM).is_some();
 	for index in 0..paint.len() {
 		if !matches!(paint.element(index), Some(Graphic::Gradient(_))) {
 			continue;
 		}
 		if !has_type {
-			paint.set_attribute(ATTR_GRADIENT_TYPE, index, gradient_type);
+			paint.set_attribute(ATTR_GRADIENT_FORM, index, gradient_type);
 		}
 		if !has_transform {
 			let transform = transform.unwrap_or_else(|| {
@@ -334,13 +334,13 @@ fn fill<'e>(
 	#[default(Color::BLACK)]
 	fill: IList<Graphic<'static>>,
 	_backup_color: IList<Color>,
-	#[default(Color::BLACK, Color::WHITE)] _backup_gradient: IList<Gradient>,
-	_gradient_type: GradientType,
+	_backup_gradient: IList<Gradient>,
+	_gradient_form: GradientForm,
 	_has_transform: bool,
 	_transform: DAffine2,
 ) -> Result<(Vector, Attr<'e, Fill>), Interrupt> {
 	let mut paint = paint_table(fill);
-	default_gradient_paint(&mut paint, element.bounding_box(), _gradient_type, _has_transform.then_some(_transform));
+	default_gradient_paint(&mut paint, element.bounding_box(), _gradient_form, _has_transform.then_some(_transform));
 	let parked = park_paint(ctx.arena(), paint)?;
 	Ok((element, Attr(Some(parked))))
 }
@@ -354,8 +354,8 @@ fn fill_graphic_leveled<'e>(
 	(element, _content_fill): (Graphic<'static>, Attr<Fill>),
 	#[default(Color::BLACK)] fill: IList<Graphic<'static>>,
 	_backup_color: IList<Color>,
-	#[default(Color::BLACK, Color::WHITE)] _backup_gradient: IList<Gradient>,
-	_gradient_type: GradientType,
+	_backup_gradient: IList<Gradient>,
+	_gradient_form: GradientForm,
 	_has_transform: bool,
 	_transform: DAffine2,
 ) -> Result<(Graphic<'static>, Attr<'e, Fill>), Interrupt> {
@@ -364,7 +364,7 @@ fn fill_graphic_leveled<'e>(
 		_ => None,
 	};
 	let mut paint = paint_table(fill);
-	default_gradient_paint(&mut paint, bounds, _gradient_type, _has_transform.then_some(_transform));
+	default_gradient_paint(&mut paint, bounds, _gradient_form, _has_transform.then_some(_transform));
 	let parked = park_paint(ctx.arena(), paint)?;
 	Ok((element, Attr(Some(parked))))
 }
@@ -1326,55 +1326,49 @@ fn points_to_polyline(_: impl Ctx, mut points: Vector, #[default(true)] closed:
 fn relax_points(
 	_: impl Ctx,
 	/// A vector path or point cloud to relax.
-	source: Vector,
+	mut source: Vector,
 	/// The number of relaxation steps to apply. A fractional value runs the whole steps and then blends partway toward one more step, so the amount of relaxation can be animated smoothly.
 	#[default(1.)]
 	#[hard(0..1000)]
 	iterations: f64,
 ) -> Vector {
-	let mut vector = source;
-
-	let relaxed = crate::voronoi::relax_sites(vector.point_domain.positions(), iterations);
-	for ((_, position), new_position) in vector.point_domain.positions_mut().zip(relaxed) {
+	let relaxed = crate::voronoi::relax_sites(source.point_domain.positions(), iterations);
+	for ((_, position), new_position) in source.point_domain.positions_mut().zip(relaxed) {
 		*position = new_position;
 	}
 
-	vector
+	source
 }
 
 /// Builds a Voronoi diagram from the anchor points. Each point claims the region of space closest to it, and those regions tessellate the plane. Cells around the outside are clipped to the convex hull of the points so the diagram stays finite.
 ///
 /// When Connect Cells is off, every cell becomes its own closed, fillable subpath. When on, the cells share their common points and segments, forming a single connected mesh with no fillable regions.
 #[node_macro::node(category("Vector"), path(core_types::vector))]
-fn voronoi_cells(_: impl Ctx, source: Vector, connect_cells: bool) -> Vector {
-	let mut vector = source;
-
-	let sites = vector.point_domain.positions().to_vec();
+fn voronoi_cells(_: impl Ctx, mut source: Vector, connect_cells: bool) -> Vector {
+	let sites = source.point_domain.positions().to_vec();
 	let cells = crate::voronoi::voronoi_cells(&sites);
 	if !cells.is_empty() {
-		replace_with_polygons(&mut vector, cells, connect_cells);
+		replace_with_polygons(&mut source, cells, connect_cells);
 	}
 
-	vector
+	source
 }
 
 /// Builds a Delaunay triangulation connecting the anchor points. It is the geometric dual of the **Voronoi** node: a mesh of triangles in which no point lies inside any triangle's circumscribed circle.
 ///
 /// When Connect Cells is off, every triangle becomes its own closed, fillable subpath. When on, the triangles share their common points and segments, forming a single connected mesh with no fillable regions.
 #[node_macro::node(category("Vector"), path(core_types::vector))]
-fn triangulate(_: impl Ctx, source: Vector, connect_cells: bool) -> Vector {
-	let mut vector = source;
-
-	let sites = vector.point_domain.positions().to_vec();
+fn triangulate(_: impl Ctx, mut source: Vector, connect_cells: bool) -> Vector {
+	let sites = source.point_domain.positions().to_vec();
 	let triangles = crate::voronoi::delaunay_triangles(&sites);
 	if !triangles.is_empty() {
 		// `delaunator` emits triangle vertices clockwise; reverse to `[a, c, b]` so triangles wind counter-clockwise to
 		// match the Voronoi cells and the rest of the framework's fill winding.
 		let polygons = triangles.iter().map(|&[a, b, c]| vec![sites[a], sites[c], sites[b]]).collect();
-		replace_with_polygons(&mut vector, polygons, connect_cells);
+		replace_with_polygons(&mut source, polygons, connect_cells);
 	}
 
-	vector
+	source
 }
 
 /// Replaces a vector's geometry (points, segments, and regions) with the given closed polygons, preserving its style.
@@ -3953,6 +3947,7 @@ mod test {
 		// contour returns to approximately, not exactly, its start; that near-coincident point must close, not duplicate).
 		let delaunay = super::triangulate(&(), vector_from_points(&SQUARE_WITH_CENTER), false);
 		let (result, _) = super::offset_path(&(), (delaunay, Attr(DAffine2::IDENTITY)), 0.5, StrokeJoin::Miter, 4.);
+
 		let mut subpaths = 0;
 		for (group, closed) in result.stroke_manipulator_groups() {
 			subpaths += 1;
@@ -4104,7 +4099,6 @@ mod test {
 			assert_eq!(manipulator_groups_anchors[i], expected_bounding_box[i]);
 		}
 	}
-
 	#[test]
 	fn sample_polyline() {
 		let path = BezPath::from_vec(vec![PathEl::MoveTo(Point::ZERO), PathEl::CurveTo(Point::ZERO, Point::new(100., 0.), Point::new(100., 0.))]);