Rename GradientStops to Gradient and the legacy Gradient/Fill structs to LegacyGradient/LegacyFill

2026-09-15 14:18:04 +08:00 · 2026-07-20 15:27:21 -07:00
parent e10d56c261
commit d13f926da3
45 changed files with 296 additions and 300 deletions
--- a/editor/src/messages/color_picker/color_picker_message_handler.rs
+++ b/editor/src/messages/color_picker/color_picker_message_handler.rs
@@ -5,7 +5,7 @@ use crate::messages::prelude::*;
 use graphene_std::Color;
 use graphene_std::color::SRGBA8;
 use graphene_std::core_types::misc::parse_css_color;
-use graphene_std::vector::style::{FillChoice, FillChoiceUI, GradientStops, GradientStopsUI};
+use graphene_std::vector::style::{FillChoice, FillChoiceUI, Gradient, GradientUI};

 /// Bounds for a midpoint position (relative to the interval between two adjacent gradient stops).
 const MIN_MIDPOINT: f64 = 0.01;
@@ -28,7 +28,7 @@ pub struct ColorPickerMessageHandler {
 	old_is_none: bool,

 	// When set, the picker is editing a gradient: the visual pickers and inputs target the active stop's color.
-	gradient: Option<GradientStops>,
+	gradient: Option<Gradient>,
 	active_marker_index: Option<u32>,
 	active_marker_is_midpoint: bool,

@@ -430,7 +430,7 @@ impl ColorPickerMessageHandler {
 			// For gradient editing, the markers' handle colors mirror their gradient stop colors
 			let markers = gradient.iter().map(|stop| SpectrumMarker::new(stop.position, stop.midpoint, stop.color)).collect();
 			let mut row_widgets = vec![
-				SpectrumInput::new(GradientStopsUI::from(gradient))
+				SpectrumInput::new(GradientUI::from(gradient))
 					.markers(markers)
 					.active_marker_index(self.active_marker_index)
 					.active_marker_is_midpoint(self.active_marker_is_midpoint)
--- a/editor/src/messages/layout/utility_types/widgets/input_widgets.rs
+++ b/editor/src/messages/layout/utility_types/widgets/input_widgets.rs
@@ -6,7 +6,7 @@ use derivative::*;
 use graphene_std::Color;
 use graphene_std::color::SRGBA8;
 use graphene_std::transform::ReferencePoint;
-use graphene_std::vector::style::{FillChoiceUI, GradientStopsUI};
+use graphene_std::vector::style::{FillChoiceUI, GradientUI};
 use graphite_proc_macros::WidgetBuilder;

 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
@@ -531,7 +531,7 @@ pub struct SpectrumInput {
 	// Content
 	/// The colored gradient drawn behind the markers (display-only, caller-owned).
 	#[widget_builder(constructor)]
-	pub track: GradientStopsUI,
+	pub track: GradientUI,
 	/// CSS `linear-gradient(...)` string for the track strip's `background-image`. Auto-populated from `track` at layout-send time.
 	#[serde(rename = "trackCSS")]
 	#[widget_builder(skip)]
--- a/editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs
+++ b/editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs
@@ -8,7 +8,7 @@ use glam::{Affine2, DAffine2, Vec2};
 use graph_craft::document::NodeId;
 use graphene_std::blending::BlendMode;
 use graphene_std::color::SRGBA8;
-use graphene_std::gradient::GradientStops;
+use graphene_std::gradient::Gradient;
 use graphene_std::list::List;
 use graphene_std::raster_types::{CPU, GPU, Raster};
 use graphene_std::vector::Vector;
@@ -192,7 +192,7 @@ fn generate_layout(introspected_data: &Arc<dyn std::any::Any + Send + Sync + 'st
 		List<Raster<CPU>>,
 		List<Raster<GPU>>,
 		List<Color>,
-		List<GradientStops>,
+		List<Gradient>,
 		List<String>,
 		List<f64>,
 		List<u8>,
@@ -201,7 +201,7 @@ fn generate_layout(introspected_data: &Arc<dyn std::any::Any + Send + Sync + 'st
 		List<BlendMode>,
 		List<GradientType>,
 		List<GradientSpreadMethod>,
-		GradientStops,
+		Gradient,
 		f64,
 		u32,
 		u64,
@@ -543,7 +543,7 @@ impl TableItemLayout for Color {
 	}
 }

-impl TableItemLayout for GradientStops {
+impl TableItemLayout for Gradient {
 	fn type_name() -> &'static str {
 		"Gradient"
 	}
@@ -911,12 +911,12 @@ macro_rules! known_item_types {
 			List<Raster<CPU>>,
 			List<Raster<GPU>>,
 			List<Color>,
-			List<GradientStops>,
+			List<Gradient>,
 			List<String>,
 			List<NodeId>,
 			List<f64>,
 			List<u8>,
-			GradientStops,
+			Gradient,
 			Color,
 			NodeId,
 			DAffine2,
--- a/editor/src/messages/portfolio/document/document_message_handler.rs
+++ b/editor/src/messages/portfolio/document/document_message_handler.rs
@@ -125,7 +125,7 @@ pub struct DocumentMessageHandler {
 	/// network path, the node itself, and its original relative gradient. The deferred migration removes each entry as its bake lands.
 	/// Transient migration state, but persisted in the saved document so unfinished bakes retry on the next open instead of losing placement.
 	#[serde(default, skip_serializing_if = "Vec::is_empty")]
-	pub(crate) pending_gradient_bbox_bake: Vec<(Vec<NodeId>, NodeId, graphic_types::migrations::legacy::Gradient)>,
+	pub(crate) pending_gradient_bbox_bake: Vec<(Vec<NodeId>, NodeId, graphic_types::migrations::legacy::LegacyGradient)>,

 	// =============================================
 	// Fields omitted from the saved document format
@@ -4007,7 +4007,7 @@ mod document_message_handler_tests {
 	#[test]
 	fn pending_gradient_bakes_round_trip_through_serialization() {
 		let document = DocumentMessageHandler {
-			pending_gradient_bbox_bake: vec![(vec![NodeId(7)], NodeId(42), graphic_types::migrations::legacy::Gradient::default())],
+			pending_gradient_bbox_bake: vec![(vec![NodeId(7)], NodeId(42), graphic_types::migrations::legacy::LegacyGradient::default())],
 			..Default::default()
 		};

--- a/editor/src/messages/portfolio/document/graph_operation/graph_operation_message.rs
+++ b/editor/src/messages/portfolio/document/graph_operation/graph_operation_message.rs
@@ -11,7 +11,7 @@ use graphene_std::raster_types::Image;
 use graphene_std::subpath::Subpath;
 use graphene_std::text::{Font, TypesettingConfig};
 use graphene_std::vector::style::{GradientSpreadMethod, GradientType, Stroke};
-use graphene_std::vector::{GradientStops, PointId, VectorModificationType};
+use graphene_std::vector::{Gradient, PointId, VectorModificationType};

 #[impl_message(Message, DocumentMessage, GraphOperation)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -22,7 +22,7 @@ pub enum GraphOperationMessage {
 	},
 	FillGradientSet {
 		layer: LayerNodeIdentifier,
-		gradient: GradientStops,
+		gradient: Gradient,
 		gradient_type: GradientType,
 		spread_method: GradientSpreadMethod,
 		transform: DAffine2,
@@ -33,7 +33,7 @@ pub enum GraphOperationMessage {
 	},
 	GradientStopsSet {
 		layer: LayerNodeIdentifier,
-		stops: GradientStops,
+		stops: Gradient,
 	},
 	GradientTransformSet {
 		layer: LayerNodeIdentifier,
--- a/editor/src/messages/portfolio/document/graph_operation/graph_operation_message_handler.rs
+++ b/editor/src/messages/portfolio/document/graph_operation/graph_operation_message_handler.rs
@@ -13,7 +13,7 @@ use graph_craft::document::{NodeId, NodeInput};
 use graphene_std::list::List;
 use graphene_std::renderer::convert_usvg_path::convert_usvg_path;
 use graphene_std::text::{Font, TypesettingConfig};
-use graphene_std::vector::style::{GradientSpreadMethod, GradientStop, GradientStops, GradientType, PaintOrder, Stroke, StrokeAlign, StrokeCap, StrokeJoin};
+use graphene_std::vector::style::{Gradient, GradientSpreadMethod, GradientStop, GradientType, PaintOrder, Stroke, StrokeAlign, StrokeCap, StrokeJoin};
 use graphene_std::{Artboard, Color};

 #[derive(ExtractField)]
@@ -508,8 +508,8 @@ const GRAPHITE_NAMESPACE: &str = "https://graphite.art";
 /// Pre-parses the raw SVG XML to extract gradient stops that have `graphite:midpoint` attributes.
 /// Graphite exports gradients with midpoint curve data by writing interpolated approximation stops
 /// alongside the real stops. Real stops are tagged with `graphite:midpoint` attributes.
-/// Returns a map from gradient element `id` to `GradientStops` containing only the real stops.
-fn extract_graphite_gradient_stops(svg: &str) -> HashMap<String, GradientStops> {
+/// Returns a map from gradient element `id` to `Gradient` containing only the real stops.
+fn extract_graphite_gradient_stops(svg: &str) -> HashMap<String, Gradient> {
 	let mut result = HashMap::new();

 	// Quick check: if the SVG doesn't reference `graphite:midpoint` at all, skip parsing
@@ -555,7 +555,7 @@ fn extract_graphite_gradient_stops(svg: &str) -> HashMap<String, GradientStops>
 		}

 		if has_any_midpoint && !real_stops.is_empty() {
-			result.insert(gradient_id, GradientStops::new(real_stops));
+			result.insert(gradient_id, Gradient::new(real_stops));
 		}
 	}

@@ -579,14 +579,7 @@ fn parse_hex_stop_color(hex: &str, opacity: f32) -> Option<Color> {
 /// interact with any existing layers in the parent stack. All descendant layers use a lightweight
 /// O(n) import path that skips collision detection and instead calculates positions directly from
 /// the known tree structure.
-fn import_usvg_node(
-	modify_inputs: &mut ModifyInputsContext,
-	node: &usvg::Node,
-	id: NodeId,
-	parent: LayerNodeIdentifier,
-	insert_index: usize,
-	graphite_gradient_stops: &HashMap<String, GradientStops>,
-) {
+fn import_usvg_node(modify_inputs: &mut ModifyInputsContext, node: &usvg::Node, id: NodeId, parent: LayerNodeIdentifier, insert_index: usize, graphite_gradient_stops: &HashMap<String, Gradient>) {
 	let layer = modify_inputs.create_layer(id);

 	modify_inputs.network_interface.move_layer_to_stack(layer, parent, insert_index, &[]);
@@ -649,7 +642,7 @@ fn import_usvg_node_inner(
 	id: NodeId,
 	parent: LayerNodeIdentifier,
 	insert_index: usize,
-	graphite_gradient_stops: &HashMap<String, GradientStops>,
+	graphite_gradient_stops: &HashMap<String, Gradient>,
 	group_extents_map: &mut HashMap<LayerNodeIdentifier, Vec<u32>>,
 ) -> u32 {
 	let layer = modify_inputs.create_layer(id);
@@ -692,7 +685,7 @@ fn import_usvg_node_inner(
 }

 /// Helper to apply path data (vector geometry, fill, stroke, transform) to a layer.
-fn import_usvg_path(modify_inputs: &mut ModifyInputsContext, node: &usvg::Node, path: &usvg::Path, layer: LayerNodeIdentifier, graphite_gradient_stops: &HashMap<String, GradientStops>) {
+fn import_usvg_path(modify_inputs: &mut ModifyInputsContext, node: &usvg::Node, path: &usvg::Path, layer: LayerNodeIdentifier, graphite_gradient_stops: &HashMap<String, Gradient>) {
 	let subpaths = convert_usvg_path(path);

 	// Skip creating a Transform node entirely when the SVG-native transform is identity.
@@ -807,7 +800,7 @@ fn convert_spread_method(spread_method: usvg::SpreadMethod) -> GradientSpreadMet
 	}
 }

-fn apply_usvg_fill(fill: &usvg::Fill, modify_inputs: &mut ModifyInputsContext, graphite_gradient_stops: &HashMap<String, GradientStops>) {
+fn apply_usvg_fill(fill: &usvg::Fill, modify_inputs: &mut ModifyInputsContext, graphite_gradient_stops: &HashMap<String, Gradient>) {
 	match &fill.paint() {
 		usvg::Paint::Color(color) => modify_inputs.fill_color_set(Some(usvg_color(*color, fill.opacity().get()))),
 		usvg::Paint::LinearGradient(linear) => {
@@ -827,7 +820,7 @@ fn apply_usvg_fill(fill: &usvg::Fill, modify_inputs: &mut ModifyInputsContext, g
 						midpoint: 0.5,
 						color: usvg_color(stop.color(), stop.opacity().get()),
 					});
-					GradientStops::new(stops)
+					Gradient::new(stops)
 				}
 			};
 			let spread_method = convert_spread_method(linear.spread_method());
@@ -851,7 +844,7 @@ fn apply_usvg_fill(fill: &usvg::Fill, modify_inputs: &mut ModifyInputsContext, g
 						midpoint: 0.5,
 						color: usvg_color(stop.color(), stop.opacity().get()),
 					});
-					GradientStops::new(stops)
+					Gradient::new(stops)
 				}
 			};
 			let spread_method = convert_spread_method(radial.spread_method());
--- a/editor/src/messages/portfolio/document/graph_operation/utility_types.rs
+++ b/editor/src/messages/portfolio/document/graph_operation/utility_types.rs
@@ -16,7 +16,7 @@ use graphene_std::raster_types::Image;
 use graphene_std::subpath::Subpath;
 use graphene_std::text::{Font, TypesettingConfig};
 use graphene_std::vector::style::{GradientSpreadMethod, GradientType, Stroke};
-use graphene_std::vector::{GradientStops, PointId, Vector, VectorModification, VectorModificationType};
+use graphene_std::vector::{Gradient, PointId, Vector, VectorModification, VectorModificationType};
 use graphene_std::{Artboard, Color, Graphic, NodeInputDecleration};

 #[derive(PartialEq, Clone, Copy, Debug, serde::Serialize, serde::Deserialize)]
@@ -464,7 +464,7 @@ impl<'a> ModifyInputsContext<'a> {
 		self.set_input_with_refresh(input_connector, NodeInput::value(TaggedValue::Color(color), false), false);
 	}

-	pub fn fill_gradient_set(&mut self, gradient: GradientStops, gradient_type: GradientType, spread_method: GradientSpreadMethod, transform: DAffine2) {
+	pub fn fill_gradient_set(&mut self, gradient: Gradient, gradient_type: GradientType, spread_method: GradientSpreadMethod, transform: DAffine2) {
 		let Some(fill_node_id) = self.existing_proto_node_id(graphene_std::vector_nodes::fill::IDENTIFIER, true) else {
 			return;
 		};
@@ -563,7 +563,7 @@ impl<'a> ModifyInputsContext<'a> {
 	}

 	/// Write the gradient stops to the 'Gradient Value' node feeding the layer.
-	pub fn gradient_stops_set(&mut self, stops: GradientStops) {
+	pub fn gradient_stops_set(&mut self, stops: Gradient) {
 		let Some(output_layer) = self.get_output_layer() else { return };

 		let gradient_value_id = match get_upstream_gradient_value_node_id(output_layer, self.network_interface) {
--- a/editor/src/messages/portfolio/document/node_graph/node_properties.rs
+++ b/editor/src/messages/portfolio/document/node_graph/node_properties.rs
@@ -33,7 +33,7 @@ use graphene_std::transform::{Footprint, ReferencePoint, ScaleType, Transform};
 use graphene_std::vector::misc::BooleanOperation;
 use graphene_std::vector::misc::{ArcType, CentroidType, ExtrudeJoiningAlgorithm, GridType, InterpolationDistribution, MergeByDistanceAlgorithm, PointSpacingType, RowsOrColumns, SpiralType};
 use graphene_std::vector::style::{
-	FillChoice, FillChoiceUI, GradientSpreadMethod, GradientStops, GradientStopsUI, GradientType, PaintOrder, StrokeAlign, StrokeCap, StrokeJoin, build_transform_with_y_preservation,
+	FillChoice, FillChoiceUI, Gradient, GradientSpreadMethod, GradientType, GradientUI, PaintOrder, StrokeAlign, StrokeCap, StrokeJoin, build_transform_with_y_preservation,
 };
 use graphene_std::vector::{QRCodeErrorCorrectionLevel, VectorModification};

@@ -254,11 +254,11 @@ pub(crate) fn property_from_type(
 						// ==========
 						Some(x) if x == TypeId::of::<List<f64>>() => array_of_number_widget(default_info, TextInput::default()).into(),
 						Some(x) if x == TypeId::of::<List<Color>>() => color_widget(default_info, ColorInput::default().allow_none(true)),
-						Some(x) if x == TypeId::of::<List<GradientStops>>() => color_widget(default_info, ColorInput::default().allow_none(false)),
+						Some(x) if x == TypeId::of::<List<Gradient>>() => color_widget(default_info, ColorInput::default().allow_none(false)),
 						Some(x) if x == TypeId::of::<List<BrushStroke>>() => brush_strokes_widget(default_info).into(),
 						// Leveled wires type by their element; each element keeps its list form's widget.
 						Some(x) if x == TypeId::of::<Color>() => color_widget(default_info, ColorInput::default().allow_none(true)),
-						Some(x) if x == TypeId::of::<GradientStops>() => color_widget(default_info, ColorInput::default().allow_none(false)),
+						Some(x) if x == TypeId::of::<Gradient>() => color_widget(default_info, ColorInput::default().allow_none(false)),
 						Some(x) if x == TypeId::of::<BrushStroke>() => brush_strokes_widget(default_info).into(),
 						// ============
 						// STRUCT TYPES
@@ -1190,7 +1190,7 @@ pub fn color_widget(parameter_widgets_info: ParameterWidgetsInfo, color_button:
 			color_button
 				.value(FillChoiceUI::from(&FillChoice::Gradient(stops.clone())))
 				.on_update(update_value(
-					|input: &ColorInput| TaggedValue::Gradient(input.value.as_gradient().map(GradientStops::from).unwrap_or_default()),
+					|input: &ColorInput| TaggedValue::Gradient(input.value.as_gradient().map(Gradient::from).unwrap_or_default()),
 					node_id,
 					index,
 				))
@@ -1267,8 +1267,8 @@ pub fn query_assign_colors_randomize(node_id: NodeId, context: &NodePropertiesCo
 }

 /// 2-stop black-to-white gradient track for spectrum sliders that map a value to a grayscale axis.
-fn bw_track() -> GradientStops {
-	GradientStops {
+fn bw_track() -> Gradient {
+	Gradient {
 		position: vec![0., 1.],
 		midpoint: vec![0.5, 0.5],
 		color: vec![Color::BLACK, Color::WHITE],
@@ -1276,8 +1276,8 @@ fn bw_track() -> GradientStops {
 }

 /// 3-stop black-to-color-to-white gradient track for spectrum sliders that map a value to a hue's full luminance range.
-fn color_track(color: Color) -> GradientStops {
-	GradientStops {
+fn color_track(color: Color) -> Gradient {
+	Gradient {
 		position: vec![0., 0.5, 1.],
 		midpoint: vec![0.5; 3],
 		color: vec![Color::BLACK, color, Color::WHITE],
@@ -1312,7 +1312,7 @@ pub(crate) fn brightness_contrast_properties(node_id: NodeId, context: &mut Node

 	let contrast_min = if use_classic_value { -100. } else { -50. };
 	let zero_position = -contrast_min / (100. - contrast_min);
-	let contrast_track = GradientStops {
+	let contrast_track = Gradient {
 		position: vec![0., zero_position, 1.],
 		midpoint: vec![0.5; 3],
 		color: vec![Color::from_rgbf32_unchecked(0.5, 0.5, 0.5), Color::BLACK, Color::from_rgbf32_unchecked(0.5, 0.5, 0.5)],
@@ -1409,7 +1409,7 @@ fn build_shared_spectrum_section(node_id: NodeId, context: &mut NodePropertiesCo

 	// Build the shared spectrum widget (placed on the first non-exposed row)
 	let spectrum_widget = (!spectrum_markers.is_empty()).then(|| {
-		SpectrumInput::new(GradientStopsUI::from(&bw_track()))
+		SpectrumInput::new(GradientUI::from(&bw_track()))
 			.markers(spectrum_markers)
 			.show_midpoints(false)
 			.allow_insert(false)
@@ -1502,13 +1502,13 @@ pub(crate) fn hue_saturation_properties(node_id: NodeId, context: &mut NodePrope
 	let saturated_current_hue = Color::from_hsva(marker_hue, 1., 1., 1.);

 	// Hue: cyclic rainbow
-	let hue_track = GradientStops {
+	let hue_track = Gradient {
 		position: vec![0., 1. / 6., 2. / 6., 3. / 6., 4. / 6., 5. / 6., 1.],
 		midpoint: vec![0.5; 7],
 		color: vec![Color::RED, Color::YELLOW, Color::GREEN, Color::CYAN, Color::BLUE, Color::MAGENTA, Color::RED],
 	};
 	// Saturation: gray to the fully saturated current hue
-	let saturation_track = GradientStops {
+	let saturation_track = Gradient {
 		position: vec![0., 1.],
 		midpoint: vec![0.5, 0.5],
 		color: vec![Color::from_rgbf32_unchecked(0.5, 0.5, 0.5), saturated_current_hue],
@@ -1558,7 +1558,7 @@ fn spectrum_slider_row(
 	node_id: NodeId,
 	context: &mut NodePropertiesContext,
 	input_index: usize,
-	track: GradientStops,
+	track: Gradient,
 	handle_color: Color,
 	value_min: f64,
 	value_max: f64,
@@ -1583,7 +1583,7 @@ fn spectrum_slider_row(

 		let position_to_value = move |position: f64| value_min + position * value_range;
 		row.push(
-			SpectrumInput::new(GradientStopsUI::from(&track))
+			SpectrumInput::new(GradientUI::from(&track))
 				.markers(vec![SpectrumMarker::new(position, 0.5, handle_color)])
 				.show_midpoints(false)
 				.allow_insert(false)
@@ -1643,7 +1643,7 @@ pub(crate) fn threshold_properties(node_id: NodeId, context: &mut NodeProperties
 pub(crate) fn vibrance_properties(node_id: NodeId, context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
 	use graphene_std::raster::vibrance::*;

-	let track = GradientStops {
+	let track = Gradient {
 		position: vec![0., 1.],
 		midpoint: vec![0.5, 0.5],
 		color: vec![Color::from_rgbf32_unchecked(0.5, 0.5, 0.5), Color::RED],
@@ -2451,7 +2451,7 @@ pub(crate) fn fill_properties(node_id: NodeId, context: &mut NodePropertiesConte
 	enum ResolvedFill {
 		Solid(Option<Color>),
 		Gradient {
-			gradient: GradientStops,
+			gradient: Gradient,
 			gradient_type: GradientType,
 			spread_method: GradientSpreadMethod,
 			transform: DAffine2,
@@ -2487,7 +2487,7 @@ pub(crate) fn fill_properties(node_id: NodeId, context: &mut NodePropertiesConte
 				ResolvedFill::Other
 			}
 		}
-		Some(ty) if ty == &concrete!(List<GradientStops>) => {
+		Some(ty) if ty == &concrete!(List<Gradient>) => {
 			// Read this node's own inputs rather than the layer's nearest Fill, which may be a different node when Fills are chained
 			if let Ok(document_node) = get_document_node(node_id, context)
 				&& let Some(gradient) = graph_modification_utils::read_fill_node_gradient(document_node, || {
@@ -2515,11 +2515,11 @@ pub(crate) fn fill_properties(node_id: NodeId, context: &mut NodePropertiesConte
 			};
 			let backup_stops = match document_node.inputs[BackupGradientInput::INDEX].as_value() {
 				Some(TaggedValue::Gradient(stops)) => stops.clone(),
-				_ => GradientStops::default(),
+				_ => Gradient::default(),
 			};
 			(backup_color, backup_stops)
 		}
-		Err(_) => (None, GradientStops::default()),
+		Err(_) => (None, Gradient::default()),
 	};

 	match &fill {
@@ -2545,7 +2545,7 @@ pub(crate) fn fill_properties(node_id: NodeId, context: &mut NodePropertiesConte
 				FillChoiceUI::None
 			}
 		}
-		ResolvedFill::Gradient { gradient: stops, .. } => FillChoiceUI::Gradient(GradientStopsUI::from(stops)),
+		ResolvedFill::Gradient { gradient: stops, .. } => FillChoiceUI::Gradient(GradientUI::from(stops)),
 		ResolvedFill::Other => FillChoiceUI::None,
 	};

@@ -2566,7 +2566,7 @@ pub(crate) fn fill_properties(node_id: NodeId, context: &mut NodePropertiesConte
 		]),
 	};

-	let gradient_set_messages = move |gradient: GradientStops| Message::Batched {
+	let gradient_set_messages = move |gradient: Gradient| Message::Batched {
 		messages: Box::new([
 			NodeGraphMessage::SetInputValue {
 				node_id,
@@ -2594,7 +2594,7 @@ pub(crate) fn fill_properties(node_id: NodeId, context: &mut NodePropertiesConte
 					solid_set_messages(color)
 				}
 				FillChoiceUI::Gradient(gradient_stops_ui) => {
-					let gradient = GradientStops::from(gradient_stops_ui);
+					let gradient = Gradient::from(gradient_stops_ui);
 					gradient_set_messages(gradient)
 				}
 			})
--- a/editor/src/messages/portfolio/document_migration.rs
+++ b/editor/src/messages/portfolio/document_migration.rs
@@ -32,6 +32,9 @@ const TEXT_REPLACEMENTS: &[(&str, &str)] = &[
 	("\"OptionalF64\":", "\"F64\":"),
 	("\"path_bool_nodes::BooleanOperation\"", "\"vector_types::vector::misc::BooleanOperation\""),
 	("\"core_types::table::Table<", "\"core_types::list::List<"),
+	// The `GradientStops` type was renamed to `Gradient`; stale stored output names are cleared so the display falls back to the live type name
+	("\"output_names\":[\"GradientStops\"]", "\"output_names\":[\"\"]"),
+	("vector_types::gradient::GradientStops", "vector_types::gradient::Gradient"),
 ];

 pub struct NodeReplacement<'a> {
@@ -1622,21 +1625,21 @@ fn migrate_node(node_id: &NodeId, node: &DocumentNode, network_path: &[NodeId],
 		// Content: no change
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);

-		// Fill: a literal Fill value is decomposed, and a wired input (`List<GradientStops> / List<Color>`) is kept as-is
+		// Fill: a literal Fill value is decomposed, and a wired input (`List<Gradient> / List<Color>`) is kept as-is
 		match old_inputs[1].as_value() {
 			Some(TaggedValue::LegacyFill(old_fill)) => {
 				let exposed = old_inputs[1].is_exposed();
 				let fill_value = match old_fill {
-					graphic_types::migrations::legacy::Fill::None => TaggedValue::Color(None),
-					graphic_types::migrations::legacy::Fill::Solid(color) => TaggedValue::Color(Some(*color)),
-					graphic_types::migrations::legacy::Fill::Gradient(gradient) => TaggedValue::Gradient(gradient.stops.clone()),
+					graphic_types::migrations::legacy::LegacyFill::None => TaggedValue::Color(None),
+					graphic_types::migrations::legacy::LegacyFill::Solid(color) => TaggedValue::Color(Some(*color)),
+					graphic_types::migrations::legacy::LegacyFill::Gradient(gradient) => TaggedValue::Gradient(gradient.stops.clone()),
 				};
 				document
 					.network_interface
 					.set_input(&InputConnector::node(*node_id, 1), NodeInput::value(fill_value, exposed), network_path);

 				// Gradient metadata (4, 5, 6): applies only to a literal gradient, solids/none keep the template defaults
-				if let graphic_types::migrations::legacy::Fill::Gradient(gradient) = old_fill {
+				if let graphic_types::migrations::legacy::LegacyFill::Gradient(gradient) = old_fill {
 					document.network_interface.set_input(
 						&InputConnector::node(*node_id, 4),
 						NodeInput::value(TaggedValue::GradientType(gradient.gradient_type), false),
@@ -1661,7 +1664,7 @@ fn migrate_node(node_id: &NodeId, node: &DocumentNode, network_path: &[NodeId],
 				}
 			}
 			// Wired/exposed fill keeps the connection.
-			// The generic paint connector accepts the existing `List<Color>`/`List<GradientStops>` paint sources directly.
+			// The generic paint connector accepts the existing `List<Color>`/`List<Gradient>` paint sources directly.
 			_ => {
 				document.network_interface.set_input(&InputConnector::node(*node_id, 1), old_inputs[1].clone(), network_path);
 			}
@@ -1680,7 +1683,7 @@ fn migrate_node(node_id: &NodeId, node: &DocumentNode, network_path: &[NodeId],
 			if matches!(
 				old_inputs[1].as_value(),
 				Some(TaggedValue::LegacyFill(
-					graphic_types::migrations::legacy::Fill::None | graphic_types::migrations::legacy::Fill::Solid(_)
+					graphic_types::migrations::legacy::LegacyFill::None | graphic_types::migrations::legacy::LegacyFill::Solid(_)
 				))
 			) {
 				document
--- a/editor/src/messages/tool/common_functionality/graph_modification_utils.rs
+++ b/editor/src/messages/tool/common_functionality/graph_modification_utils.rs
@@ -15,7 +15,7 @@ use graphene_std::subpath::Subpath;
 use graphene_std::text::{Font, TypesettingConfig};
 use graphene_std::vector::misc::ManipulatorPointId;
 use graphene_std::vector::style::{FillChoice, PaintOrder, StrokeAlign, StrokeCap, StrokeJoin, initial_gradient_transform_for_bounding_box};
-use graphene_std::vector::{GradientSpreadMethod, GradientStops, GradientType, PointId, SegmentId, VectorModificationType};
+use graphene_std::vector::{Gradient, GradientSpreadMethod, GradientType, PointId, SegmentId, VectorModificationType};
 use std::collections::VecDeque;

 /// Returns the ID of the first Spline node in the horizontal flow which is not followed by a `Path` node, or `None` if none exists.
@@ -309,7 +309,7 @@ pub fn get_fill_input_node_id(layer: LayerNodeIdentifier, network_interface: &No
 }

 /// Get the gradient stops of a layer, if any.
-pub fn get_gradient_stops(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> Option<GradientStops> {
+pub fn get_gradient_stops(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> Option<Gradient> {
 	// Try to find the gradient stops value that is created by a Fill node first
 	if let Some(fill_node_id) = get_fill_node_id_with_direct_fill_input(layer, network_interface) {
 		return network_interface
@@ -328,7 +328,7 @@ pub fn get_gradient_stops(layer: LayerNodeIdentifier, network_interface: &NodeNe
 	Some(stops.clone())
 }

-/// Compute the transform from a gradient's local space to viewport space for the given layer. For a `List<GradientStops>`
+/// Compute the transform from a gradient's local space to viewport space for the given layer. For a `List<Gradient>`
 /// layer this is the layer's incoming footprint transform; for a Fill-owned gradient value it composes the layer's viewport
 /// transform with the [0,1]² → bounding-box mapping.
 pub fn gradient_space_transform(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> glam::DAffine2 {
@@ -625,7 +625,7 @@ pub fn set_stroke_weight_for_selected_layers(weight: f64, document: &DocumentMes

 /// A Fill node's decoded gradient inputs, with the transform kept in its raw form (not yet baked into `start`/`end`).
 pub struct FillNodeGradient {
-	pub stops: GradientStops,
+	pub stops: Gradient,
 	pub gradient_type: GradientType,
 	pub spread_method: GradientSpreadMethod,
 	pub transform: DAffine2,
--- a/editor/src/messages/tool/tool_messages/gradient_tool.rs
+++ b/editor/src/messages/tool/tool_messages/gradient_tool.rs
@@ -16,7 +16,7 @@ use glam::DMat2;
 use graph_craft::document::value::TaggedValue;
 use graphene_std::color::SRGBA8;
 use graphene_std::raster::color::Color;
-use graphene_std::vector::style::{FillChoice, FillChoiceUI, GradientSpreadMethod, GradientStop, GradientStops, GradientStopsUI, GradientType, build_transform_with_y_preservation};
+use graphene_std::vector::style::{FillChoice, FillChoiceUI, Gradient, GradientSpreadMethod, GradientStop, GradientType, GradientUI, build_transform_with_y_preservation};

 #[derive(Default, ExtractField)]
 pub struct GradientTool {
@@ -53,7 +53,7 @@ pub enum GradientToolMessage {
 	CommitTransactionForColorStop,
 	CloseStopColorPicker,
 	UpdateStopColor { color: Color },
-	UpdateStops { stops: GradientStopsUI },
+	UpdateStops { stops: GradientUI },
 	UpdateOptions { options: GradientOptionsUpdate },
 }

@@ -146,7 +146,7 @@ impl<'a> MessageHandler<ToolMessage, &mut ToolActionMessageContext<'a>> for Grad
 				}
 			}
 			ToolMessage::Gradient(GradientToolMessage::UpdateStops { stops }) => {
-				apply_stops_update(&mut self.data, context, responses, GradientStops::from(&stops));
+				apply_stops_update(&mut self.data, context, responses, Gradient::from(&stops));
 			}
 			ToolMessage::Gradient(GradientToolMessage::CloseStopColorPicker) => {
 				if self.data.color_picker_transaction_open {
@@ -264,7 +264,7 @@ impl LayoutHolder for GradientTool {
 			.or_else(|| self.data.default_gradient_stops.clone())
 			.map(FillChoice::Gradient)
 			.unwrap_or_else(|| {
-				FillChoice::Gradient(GradientStops::new([
+				FillChoice::Gradient(Gradient::new([
 					GradientStop {
 						position: 0.,
 						midpoint: 0.5,
@@ -389,7 +389,7 @@ enum GradientSource {
 }

 /// Get the gradient with appearance information from Fill node values, or the chain connected to Fill node / layer.
-fn resolve_gradient(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> Option<(GradientStops, GradientAppearance, GradientSource)> {
+fn resolve_gradient(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> Option<(Gradient, GradientAppearance, GradientSource)> {
 	if let Some(stops) = get_gradient_stops(layer, network_interface) {
 		// A Fill node holding a direct gradient value decodes through the shared reader
 		if let Some(fill_id) = get_fill_node_id_with_direct_fill_input(layer, network_interface) {
@@ -521,15 +521,15 @@ struct SelectedGradient {
 	dragging: GradientDragTarget,
 	/// Transform from the geometry's local gradient space to viewport space.
 	gradient_space_transform: DAffine2,
-	gradient: GradientStops,
+	gradient: Gradient,
 	appearance: GradientAppearance,
-	initial_gradient: GradientStops,
+	initial_gradient: Gradient,
 	/// Transform from unit [0, 1] line to the geometry's local gradient space, the snapshot from `GradientAppearance.transform`.
 	initial_gradient_transform: DAffine2,
 	is_gradient_chain: bool,
 }

-fn calculate_insertion(start: DVec2, end: DVec2, stops: &GradientStops, mouse: DVec2) -> Option<f64> {
+fn calculate_insertion(start: DVec2, end: DVec2, stops: &Gradient, mouse: DVec2) -> Option<f64> {
 	let distance = (end - start).angle_to(mouse - start).sin() * (mouse - start).length();
 	let projection = ((end - start).angle_to(mouse - start)).cos() * start.distance(mouse) / start.distance(end);

@@ -568,7 +568,7 @@ fn calculate_insertion(start: DVec2, end: DVec2, stops: &GradientStops, mouse: D
 }

 impl SelectedGradient {
-	pub fn new(gradient: GradientStops, appearance: GradientAppearance, source: GradientSource, layer: LayerNodeIdentifier, document: &DocumentMessageHandler) -> Self {
+	pub fn new(gradient: Gradient, appearance: GradientAppearance, source: GradientSource, layer: LayerNodeIdentifier, document: &DocumentMessageHandler) -> Self {
 		let gradient_space_transform = gradient_space_transform(layer, document);
 		Self {
 			layer: Some(layer),
@@ -820,7 +820,7 @@ impl SelectedGradient {
 }

 /// Send the four per-attribute graph operations that mirror the in-memory `Gradient` onto the chain feeding the layer.
-fn dispatch_gradient_chain_writes(layer: LayerNodeIdentifier, gradient: &GradientStops, appearance: GradientAppearance, responses: &mut VecDeque<Message>) {
+fn dispatch_gradient_chain_writes(layer: LayerNodeIdentifier, gradient: &Gradient, appearance: GradientAppearance, responses: &mut VecDeque<Message>) {
 	responses.add(GraphOperationMessage::GradientStopsSet { layer, stops: gradient.clone() });
 	responses.add(GraphOperationMessage::GradientTransformSet {
 		layer,
@@ -868,11 +868,11 @@ struct GradientToolData {
 	has_selected_gradient: bool,
 	/// Cached stops of the currently selected layer's gradient, mirrored into the control-bar widget.
 	/// Independent of any in-progress drag (which uses `selected_gradient`) so it stays current after selection changes too.
-	current_gradient_stops: Option<GradientStops>,
+	current_gradient_stops: Option<Gradient>,
 	/// User-customized default gradient stop colors: used when nothing that has a gradient is selected.
 	/// `None` means to follow the working colors.
 	/// Cleared on tool deactivation so each fresh activation starts from the working colors again.
-	default_gradient_stops: Option<GradientStops>,
+	default_gradient_stops: Option<Gradient>,
 	/// Cached viewport-space orientation (true = predominantly rightward) of the selected gradient line.
 	/// Used to refresh the control bar's "Reverse Direction" icon only when the line's apparent direction flips.
 	gradient_orientation_rightward: bool,
@@ -1496,7 +1496,7 @@ impl Fsm for GradientToolFsmState {
 							// Generate a new gradient running primary → secondary so the default working colors
 							// (primary = black, secondary = white) produce the expected black-to-white gradient
 							None => (
-								GradientStops::new([
+								Gradient::new([
 									GradientStop {
 										position: 0.,
 										midpoint: 0.5,
@@ -1738,7 +1738,7 @@ impl Fsm for GradientToolFsmState {
 	}
 }

-fn insert_stop_at_point(gradient: &mut GradientStops, point: DVec2, unit_to_viewport: DAffine2) -> Option<usize> {
+fn insert_stop_at_point(gradient: &mut Gradient, point: DVec2, unit_to_viewport: DAffine2) -> Option<usize> {
 	let (start, end) = gradient_handle_positions(unit_to_viewport);
 	let t = ((end - start).angle_to(point - start)).cos() * start.distance(point) / start.distance(end);
 	(0. ..=1.).contains(&t).then(|| gradient.insert_stop(t))
@@ -1831,8 +1831,8 @@ fn apply_gradient_update(
 	data: &mut GradientToolData,
 	context: &mut ToolActionMessageContext,
 	responses: &mut VecDeque<Message>,
-	condition: impl Fn((&GradientStops, &GradientAppearance)) -> bool,
-	update: impl Fn((&mut GradientStops, &mut GradientAppearance)),
+	condition: impl Fn((&Gradient, &GradientAppearance)) -> bool,
+	update: impl Fn((&mut Gradient, &mut GradientAppearance)),
 ) {
 	let selected_layers: Vec<_> = context
 		.document
@@ -1888,7 +1888,7 @@ fn apply_gradient_update(
 /// Set new gradient stops on every selected layer's gradient. Unlike `apply_gradient_update`, this doesn't open its own
 /// transaction so it can be called repeatedly during a color picker drag and have all the changes coalesced into a
 /// single undo entry by the surrounding 'on_commit' callback.
-fn apply_stops_update(data: &mut GradientToolData, context: &mut ToolActionMessageContext, responses: &mut VecDeque<Message>, new_gradient: GradientStops) {
+fn apply_stops_update(data: &mut GradientToolData, context: &mut ToolActionMessageContext, responses: &mut VecDeque<Message>, new_gradient: Gradient) {
 	let selected_layers: Vec<_> = context
 		.document
 		.network_interface
@@ -1933,7 +1933,7 @@ fn apply_stops_update(data: &mut GradientToolData, context: &mut ToolActionMessa
 }

 /// Find the first selected visible layer that has a gradient and return both the layer ID and its resolved gradient.
-fn current_layer_and_gradient(document: &DocumentMessageHandler) -> (Option<LayerNodeIdentifier>, Option<(GradientStops, GradientAppearance)>) {
+fn current_layer_and_gradient(document: &DocumentMessageHandler) -> (Option<LayerNodeIdentifier>, Option<(Gradient, GradientAppearance)>) {
 	for layer in document.network_interface.selected_nodes().selected_visible_layers(&document.network_interface) {
 		if let Some((gradient, appearance, _source)) = resolve_gradient(layer, &document.network_interface) {
 			return (Some(layer), Some((gradient, appearance)));
@@ -1942,7 +1942,7 @@ fn current_layer_and_gradient(document: &DocumentMessageHandler) -> (Option<Laye
 	(None, None)
 }

-fn get_gradient_on_selected_layer(document: &DocumentMessageHandler) -> Option<(GradientStops, GradientAppearance, GradientSource)> {
+fn get_gradient_on_selected_layer(document: &DocumentMessageHandler) -> Option<(Gradient, GradientAppearance, GradientSource)> {
 	document
 		.network_interface
 		.selected_nodes()
@@ -2015,18 +2015,18 @@ mod test_gradient {
 	use graphene_std::NodeInputDecleration;
 	use graphene_std::color::SRGBA8;
 	use graphene_std::vector::style::{GradientSpreadMethod, build_transform_with_y_preservation};
-	use graphene_std::vector::{GradientStop, GradientStops, fill};
+	use graphene_std::vector::{Gradient, GradientStop, fill};

 	use super::gradient_space_transform;

 	struct ResolvedGradient {
-		stops: GradientStops,
+		stops: Gradient,
 		spread_method: GradientSpreadMethod,
 		transform: DAffine2,
 	}

 	impl ResolvedGradient {
-		fn new(stops: GradientStops, appearance: super::GradientAppearance) -> Self {
+		fn new(stops: Gradient, appearance: super::GradientAppearance) -> Self {
 			Self {
 				stops,
 				spread_method: appearance.spread_method,
@@ -2146,7 +2146,7 @@ mod test_gradient {
 			.handle_message(NodeGraphMessage::SetInputValue {
 				node_id: gradient_node_id,
 				input_index: 1,
-				value: Box::new(TaggedValue::Gradient(GradientStops::new([
+				value: Box::new(TaggedValue::Gradient(Gradient::new([
 					GradientStop {
 						position: 0.,
 						midpoint: 0.5,
@@ -2183,7 +2183,7 @@ mod test_gradient {
 			.handle_message(NodeGraphMessage::SetInputValue {
 				node_id: gradient_node_id,
 				input_index: 1,
-				value: Box::new(TaggedValue::Gradient(GradientStops::new([
+				value: Box::new(TaggedValue::Gradient(Gradient::new([
 					GradientStop {
 						position: 0.,
 						midpoint: 0.5,
@@ -2654,7 +2654,7 @@ mod test_gradient {
 		// Create original transform for the control geometry and apply it
 		let initial_start = DVec2::new(10., 50.);
 		let initial_end = DVec2::new(200., 50.);
-		let stops = GradientStops::new([
+		let stops = Gradient::new([
 			GradientStop {
 				position: 0.,
 				midpoint: 0.5,
@@ -2725,7 +2725,7 @@ mod test_gradient {
 		let layer = create_gradient_list_layer(&mut editor).await;

 		// Set up a 3-stop gradient with distinct colors
-		let original_stops = GradientStops::new([
+		let original_stops = Gradient::new([
 			GradientStop {
 				position: 0.,
 				midpoint: 0.5,
@@ -2826,7 +2826,7 @@ mod test_gradient {
 			.handle_message(NodeGraphMessage::SetInputValue {
 				node_id: gradient_value_id,
 				input_index: 1,
-				value: Box::new(TaggedValue::Gradient(GradientStops::new([
+				value: Box::new(TaggedValue::Gradient(Gradient::new([
 					GradientStop {
 						position: 0.,
 						midpoint: 0.5,
--- a/editor/src/node_graph_executor.rs
+++ b/editor/src/node_graph_executor.rs
@@ -84,7 +84,7 @@ struct ExecutionContext {
 	/// Set when this execution is a gradient-migration measurement run, carrying the "Fill" node (addressed by its enclosing
 	/// network path) and its original relative gradient. The evaluated geometry is read back from the inspect result to size the
 	/// gradient; such runs never touch the visible artwork. Carrying the entry keeps a stale re-dispatched response paired with the fill it measured.
-	measure_fill: Option<(Vec<NodeId>, NodeId, graphic_types::migrations::legacy::Gradient)>,
+	measure_fill: Option<(Vec<NodeId>, NodeId, graphic_types::migrations::legacy::LegacyGradient)>,
 }

 // TODO: Eventually remove this document upgrade code
@@ -94,7 +94,7 @@ struct ExecutionContext {
 #[derive(Debug, Clone)]
 struct GradientMigration {
 	document_id: DocumentId,
-	remaining: VecDeque<(Vec<NodeId>, NodeId, graphic_types::migrations::legacy::Gradient)>,
+	remaining: VecDeque<(Vec<NodeId>, NodeId, graphic_types::migrations::legacy::LegacyGradient)>,
 	resolution: UVec2,
 	scale: f64,
 }
@@ -507,7 +507,7 @@ impl NodeGraphExecutor {
 		}

 		// Snapshot the queue but leave `pending_gradient_bbox_bake` populated, so subsequent render requests keep deferring here (and hit the guard above); each entry is removed from the document as its bake lands.
-		let remaining: VecDeque<(Vec<NodeId>, NodeId, graphic_types::migrations::legacy::Gradient)> = document.pending_gradient_bbox_bake.iter().cloned().collect();
+		let remaining: VecDeque<(Vec<NodeId>, NodeId, graphic_types::migrations::legacy::LegacyGradient)> = document.pending_gradient_bbox_bake.iter().cloned().collect();
 		let Some((first_network_path, first_fill, first_gradient)) = remaining.front().cloned() else {
 			return false;
 		};
@@ -534,7 +534,7 @@ impl NodeGraphExecutor {
 		document_id: DocumentId,
 		network_path: Vec<NodeId>,
 		fill_node_id: NodeId,
-		gradient: graphic_types::migrations::legacy::Gradient,
+		gradient: graphic_types::migrations::legacy::LegacyGradient,
 		resolution: UVec2,
 		scale: f64,
 		responses: &mut VecDeque<Message>,
@@ -603,7 +603,7 @@ impl NodeGraphExecutor {
 		&mut self,
 		document: &mut DocumentMessageHandler,
 		document_id: DocumentId,
-		bake_target: (Vec<NodeId>, NodeId, graphic_types::migrations::legacy::Gradient),
+		bake_target: (Vec<NodeId>, NodeId, graphic_types::migrations::legacy::LegacyGradient),
 		inspect_result: Option<InspectResult>,
 		responses: &mut VecDeque<Message>,
 	) {