Fix click targets (in, e.g., the boolean node) by resolving footprints from render output (#1946)

* add NodeId (u64) and Footprint to Graphic Group

* Render Output footprints

* Small bug fixes

* Commented out render output click targets/footprints

* Run graph when deleting

* Switch to node path

* Add upstream clicktargets for boolean operation

* Fix boolean operations

* Fix grouped layers

* Add click targets to vello render

* Add cache to artwork

* Fix demo artwork

* Improve recursion

* Code review

---------

Co-authored-by: Dennis Kobert <dennis@kobert.dev>
Co-authored-by: Keavon Chambers <keavon@keavon.com>

editor/src/messages/portfolio/document/document_message.rs

@@ -11,6 +11,9 @@ use graphene_core::raster::BlendMode;
 use graphene_core::raster::Image;
 use graphene_core::vector::style::ViewMode;
 use graphene_core::Color;
+use graphene_std::renderer::ClickTarget;
+use graphene_std::transform::Footprint;
+use graphene_std::vector::VectorData;
 
 use glam::DAffine2;
 
@@ -155,6 +158,15 @@ pub enum DocumentMessage {
 	ToggleGridVisibility,
 	ToggleOverlaysVisibility,
 	ToggleSnapping,
+	UpdateUpstreamTransforms {
+		upstream_transforms: HashMap<NodeId, (Footprint, DAffine2)>,
+	},
+	UpdateClickTargets {
+		click_targets: HashMap<NodeId, Vec<ClickTarget>>,
+	},
+	UpdateVectorModify {
+		vector_modify: HashMap<NodeId, VectorData>,
+	},
 	Undo,
 	UngroupSelectedLayers,
 	UngroupLayer {

editor/src/messages/portfolio/document/document_message_handler.rs

@@ -1022,8 +1022,9 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				if self.network_interface.transaction_status() == TransactionStatus::Finished {
 					return;
 				}
+
+				self.document_undo_history.pop_back();
 				self.network_interface.finish_transaction();
-				self.undo(ipp, responses);
 				responses.add(OverlaysMessage::Draw);
 			}
 			DocumentMessage::AddTransaction => {
@@ -1054,6 +1055,25 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				self.snapping_state.snapping_enabled = !self.snapping_state.snapping_enabled;
 				responses.add(PortfolioMessage::UpdateDocumentWidgets);
 			}
+			DocumentMessage::UpdateUpstreamTransforms { upstream_transforms } => {
+				self.network_interface.update_transforms(upstream_transforms);
+			}
+			DocumentMessage::UpdateClickTargets { click_targets } => {
+				// TODO: Allow non layer nodes to have click targets
+				let layer_click_targets = click_targets
+					.into_iter()
+					.filter_map(|(node_id, click_targets)| {
+						self.network_interface.is_layer(&node_id, &[]).then(|| {
+							let layer = LayerNodeIdentifier::new(node_id, &self.network_interface, &[]);
+							(layer, click_targets)
+						})
+					})
+					.collect();
+				self.network_interface.update_click_targets(layer_click_targets);
+			}
+			DocumentMessage::UpdateVectorModify { vector_modify } => {
+				self.network_interface.update_vector_modify(vector_modify);
+			}
 			DocumentMessage::Undo => {
 				if self.network_interface.transaction_status() != TransactionStatus::Finished {
 					return;
@@ -1107,6 +1127,9 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 					node_ids: vec![layer.to_node()],
 					delete_children: true,
 				});
+				responses.add(NodeGraphMessage::RunDocumentGraph);
+				responses.add(NodeGraphMessage::SelectedNodesUpdated);
+				responses.add(NodeGraphMessage::SendGraph);
 			}
 			DocumentMessage::PTZUpdate => {
 				if !self.graph_view_overlay_open {
@@ -1239,7 +1262,7 @@ impl DocumentMessageHandler {
 			.filter(|&layer| self.network_interface.selected_nodes(&[]).unwrap().layer_visible(layer, &self.network_interface))
 			.filter(|&layer| !self.network_interface.selected_nodes(&[]).unwrap().layer_locked(layer, &self.network_interface))
 			.filter(|&layer| !self.network_interface.is_artboard(&layer.to_node(), &[]))
-			.filter_map(|layer| self.metadata().click_target(layer).map(|targets| (layer, targets)))
+			.filter_map(|layer| self.metadata().click_targets(layer).map(|targets| (layer, targets)))
 			.filter(move |(layer, target)| {
 				target
 					.iter()
@@ -1256,7 +1279,7 @@ impl DocumentMessageHandler {
 			.all_layers()
 			.filter(|&layer| self.network_interface.selected_nodes(&[]).unwrap().layer_visible(layer, &self.network_interface))
 			.filter(|&layer| !self.network_interface.selected_nodes(&[]).unwrap().layer_locked(layer, &self.network_interface))
-			.filter_map(|layer| self.metadata().click_target(layer).map(|targets| (layer, targets)))
+			.filter_map(|layer| self.metadata().click_targets(layer).map(|targets| (layer, targets)))
 			.filter(move |(layer, target)| target.iter().any(|target| target.intersect_point(point, self.metadata().transform_to_document(*layer))))
 			.map(|(layer, _)| layer)
 	}

editor/src/messages/portfolio/document/graph_operation/graph_operation_message_handler.rs

@@ -206,6 +206,9 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageData<'_>> for Gr
 					});
 				}
 				// TODO: Replace deleted artboards with merge nodes
+				responses.add(NodeGraphMessage::RunDocumentGraph);
+				responses.add(NodeGraphMessage::SelectedNodesUpdated);
+				responses.add(NodeGraphMessage::SendGraph);
 			}
 			GraphOperationMessage::NewSvg {
 				id,

editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs

@@ -253,8 +253,12 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 							},
 							DocumentNode {
 								manual_composition: Some(concrete!(Footprint)),
-								inputs: vec![NodeInput::node(NodeId(1), 0), NodeInput::node(NodeId(2), 0)],
-								implementation: DocumentNodeImplementation::proto("graphene_core::ConstructLayerNode<_, _>"),
+								inputs: vec![
+									NodeInput::node(NodeId(1), 0),
+									NodeInput::node(NodeId(2), 0),
+									NodeInput::Reflection(graph_craft::document::DocumentNodeMetadata::DocumentNodePath),
+								],
+								implementation: DocumentNodeImplementation::proto("graphene_core::ConstructLayerNode<_, _, _>"),
 								..Default::default()
 							},
 						]
@@ -359,8 +363,9 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 								inputs: vec![
 									NodeInput::network(graphene_core::Type::Fn(Box::new(concrete!(Footprint)), Box::new(concrete!(ArtboardGroup))), 0),
 									NodeInput::node(NodeId(1), 0),
+									NodeInput::Reflection(graph_craft::document::DocumentNodeMetadata::DocumentNodePath),
 								],
-								implementation: DocumentNodeImplementation::proto("graphene_core::AddArtboardNode<_, _>"),
+								implementation: DocumentNodeImplementation::proto("graphene_core::AddArtboardNode<_, _, _>"),
 								..Default::default()
 							},
 						]
@@ -3800,14 +3805,62 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 			category: "Vector",
 			node_template: NodeTemplate {
 				document_node: DocumentNode {
+					implementation: DocumentNodeImplementation::Network(NodeNetwork {
+						exports: vec![NodeInput::node(NodeId(1), 0)],
+						nodes: vec![
+							DocumentNode {
+								inputs: vec![NodeInput::network(concrete!(VectorData), 0), NodeInput::network(concrete!(vector::style::Fill), 1)],
+								implementation: DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier::new("graphene_std::vector::BooleanOperationNode<_>")),
+								..Default::default()
+							},
+							DocumentNode {
+								inputs: vec![NodeInput::node(NodeId(0), 0)],
+								implementation: DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier::new("graphene_core::memo::ImpureMemoNode<_, _, _>")),
+								manual_composition: Some(concrete!(Footprint)),
+								..Default::default()
+							},
+						]
+						.into_iter()
+						.enumerate()
+						.map(|(id, node)| (NodeId(id as u64), node))
+						.collect(),
+						..Default::default()
+					}),
 					inputs: vec![
 						NodeInput::value(TaggedValue::GraphicGroup(GraphicGroup::EMPTY), true),
 						NodeInput::value(TaggedValue::BooleanOperation(vector::misc::BooleanOperation::Union), false),
 					],
-					implementation: DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier::new("graphene_std::vector::BooleanOperationNode<_>")),
 					..Default::default()
 				},
 				persistent_node_metadata: DocumentNodePersistentMetadata {
+					network_metadata: Some(NodeNetworkMetadata {
+						persistent_metadata: NodeNetworkPersistentMetadata {
+							node_metadata: [
+								DocumentNodeMetadata {
+									persistent_metadata: DocumentNodePersistentMetadata {
+										display_name: "Boolean Operation".to_string(),
+										node_type_metadata: NodeTypePersistentMetadata::node(IVec2::new(-7, 0)),
+										..Default::default()
+									},
+									..Default::default()
+								},
+								DocumentNodeMetadata {
+									persistent_metadata: DocumentNodePersistentMetadata {
+										display_name: "Cache".to_string(),
+										node_type_metadata: NodeTypePersistentMetadata::node(IVec2::new(0, 0)),
+										..Default::default()
+									},
+									..Default::default()
+								},
+							]
+							.into_iter()
+							.enumerate()
+							.map(|(id, node)| (NodeId(id as u64), node))
+							.collect(),
+							..Default::default()
+						},
+						..Default::default()
+					}),
 					input_names: vec!["Group of Paths".to_string(), "Operation".to_string()],
 					output_names: vec!["Vector".to_string()],
 					..Default::default()

editor/src/messages/portfolio/document/node_graph/node_graph_message_handler.rs

@@ -114,7 +114,8 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				responses.add(NodeGraphMessage::SendSelectedNodes);
 				responses.add(ArtboardToolMessage::UpdateSelectedArtboard);
 				responses.add(DocumentMessage::DocumentStructureChanged);
-				responses.add(NodeGraphMessage::RunDocumentGraph);
+				responses.add(OverlaysMessage::Draw);
+				responses.add(NodeGraphMessage::SendGraph);
 			}
 			NodeGraphMessage::CreateWire { output_connector, input_connector } => {
 				// TODO: Add support for flattening NodeInput::Network exports in flatten_with_fns https://github.com/GraphiteEditor/Graphite/issues/1762
@@ -203,8 +204,6 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 			}
 			NodeGraphMessage::DeleteNodes { node_ids, delete_children } => {
 				network_interface.delete_nodes(node_ids, delete_children, selection_network_path);
-				responses.add(NodeGraphMessage::SelectedNodesUpdated);
-				responses.add(NodeGraphMessage::SendGraph);
 			}
 			// Deletes selected_nodes. If `reconnect` is true, then all children nodes (secondary input) of the selected nodes are deleted and the siblings (primary input/output) are reconnected.
 			// If `reconnect` is false, then only the selected nodes are deleted and not reconnected.
@@ -217,7 +216,10 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				responses.add(NodeGraphMessage::DeleteNodes {
 					node_ids: selected_nodes.selected_nodes().cloned().collect::<Vec<_>>(),
 					delete_children,
-				})
+				});
+				responses.add(NodeGraphMessage::RunDocumentGraph);
+				responses.add(NodeGraphMessage::SelectedNodesUpdated);
+				responses.add(NodeGraphMessage::SendGraph);
 			}
 			NodeGraphMessage::DisconnectInput { input_connector } => {
 				network_interface.disconnect_input(&input_connector, selection_network_path);

editor/src/messages/portfolio/document/utility_types/document_metadata.rs

@@ -22,7 +22,6 @@ pub struct DocumentMetadata {
 	pub structure: HashMap<LayerNodeIdentifier, NodeRelations>,
 	pub click_targets: HashMap<LayerNodeIdentifier, Vec<ClickTarget>>,
 	pub vector_modify: HashMap<NodeId, VectorData>,
-	// TODO: Remove and derive from document_ptz in document message handler
 	/// Transform from document space to viewport space.
 	pub document_to_viewport: DAffine2,
 }
@@ -52,7 +51,7 @@ impl DocumentMetadata {
 		self.structure.contains_key(&layer)
 	}
 
-	pub fn click_target(&self, layer: LayerNodeIdentifier) -> Option<&Vec<ClickTarget>> {
+	pub fn click_targets(&self, layer: LayerNodeIdentifier) -> Option<&Vec<ClickTarget>> {
 		self.click_targets.get(&layer)
 	}
 
@@ -71,29 +70,15 @@ impl DocumentMetadata {
 // ============================
 
 impl DocumentMetadata {
-	/// Update the cached transforms of the layers
-	pub fn update_transforms(&mut self, new_upstream_transforms: HashMap<NodeId, (Footprint, DAffine2)>) {
-		self.upstream_transforms = new_upstream_transforms;
-	}
-
 	/// Access the cached transformation to document space from layer space
 	pub fn transform_to_document(&self, layer: LayerNodeIdentifier) -> DAffine2 {
 		self.document_to_viewport.inverse() * self.transform_to_viewport(layer)
 	}
 
 	pub fn transform_to_viewport(&self, layer: LayerNodeIdentifier) -> DAffine2 {
-		layer
-			.ancestors(self)
-			.filter_map(|ancestor_layer| {
-				if ancestor_layer != LayerNodeIdentifier::ROOT_PARENT {
-					self.upstream_transforms.get(&ancestor_layer.to_node())
-				} else {
-					None
-				}
-			})
-			.copied()
-			.map(|(footprint, transform)| footprint.transform * transform)
-			.next()
+		self.upstream_transforms
+			.get(&layer.to_node())
+			.map(|(footprint, transform)| footprint.transform * *transform)
 			.unwrap_or(self.document_to_viewport)
 	}
 
@@ -119,16 +104,9 @@ impl DocumentMetadata {
 // ===============================
 
 impl DocumentMetadata {
-	/// Update the cached click targets and vector modify values of the layers
-	pub fn update_from_monitor(&mut self, new_click_targets: HashMap<LayerNodeIdentifier, Vec<ClickTarget>>, new_vector_modify: HashMap<NodeId, VectorData>) {
-		self.click_targets = new_click_targets;
-		self.vector_modify = new_vector_modify;
-	}
-
 	/// Get the bounding box of the click target of the specified layer in the specified transform space
 	pub fn bounding_box_with_transform(&self, layer: LayerNodeIdentifier, transform: DAffine2) -> Option<[DVec2; 2]> {
-		self.click_targets
-			.get(&layer)?
+		self.click_targets(layer)?
 			.iter()
 			.filter_map(|click_target| click_target.subpath().bounding_box_with_transform(transform))
 			.reduce(Quad::combine_bounds)

editor/src/messages/portfolio/document/utility_types/network_interface.rs

@@ -11,6 +11,7 @@ use bezier_rs::Subpath;
 use graph_craft::document::{value::TaggedValue, DocumentNode, DocumentNodeImplementation, NodeId, NodeInput, NodeNetwork, OldDocumentNodeImplementation, OldNodeNetwork};
 use graph_craft::{concrete, Type};
 use graphene_std::renderer::{ClickTarget, Quad};
+use graphene_std::transform::Footprint;
 use graphene_std::vector::{PointId, VectorData, VectorModificationType};
 use interpreted_executor::{dynamic_executor::ResolvedDocumentNodeTypes, node_registry::NODE_REGISTRY};
 
@@ -2327,7 +2328,7 @@ impl NodeNetworkInterface {
 			log::error!("Could not get nested node_metadata in position_from_downstream_node");
 			return None;
 		};
-		match &node_metadata.persistent_metadata.node_type_metadata.clone() {
+		match &node_metadata.persistent_metadata.node_type_metadata {
 			NodeTypePersistentMetadata::Layer(layer_metadata) => {
 				match layer_metadata.position {
 					LayerPosition::Absolute(position) => Some(position),
@@ -2550,8 +2551,7 @@ impl NodeNetworkInterface {
 	}
 
 	pub fn set_document_to_viewport_transform(&mut self, transform: DAffine2) {
-		let document_metadata = self.document_metadata_mut();
-		document_metadata.document_to_viewport = transform;
+		self.document_metadata.document_to_viewport = transform;
 	}
 
 	pub fn is_eligible_to_be_layer(&mut self, node_id: &NodeId, network_path: &[NodeId]) -> bool {
@@ -2882,7 +2882,7 @@ impl NodeNetworkInterface {
 			}
 
 			for (parent, child) in children {
-				parent.push_child(self.document_metadata_mut(), child);
+				parent.push_child(&mut self.document_metadata, child);
 			}
 
 			while let Some((primary_root_node_id, parent_layer_node)) = awaiting_primary_flow.pop() {
@@ -2902,7 +2902,7 @@ impl NodeNetworkInterface {
 					}
 				}
 				for child in children {
-					parent_layer_node.push_child(self.document_metadata_mut(), child);
+					parent_layer_node.push_child(&mut self.document_metadata, child);
 				}
 			}
 		}
@@ -2914,8 +2914,19 @@ impl NodeNetworkInterface {
 		self.document_metadata.click_targets.retain(|layer, _| self.document_metadata.structure.contains_key(layer));
 	}
 
-	pub fn document_metadata_mut(&mut self) -> &mut DocumentMetadata {
-		&mut self.document_metadata
+	/// Update the cached transforms of the layers
+	pub fn update_transforms(&mut self, new_upstream_transforms: HashMap<NodeId, (Footprint, DAffine2)>) {
+		self.document_metadata.upstream_transforms = new_upstream_transforms;
+	}
+
+	/// Update the cached click targets of the layers
+	pub fn update_click_targets(&mut self, new_click_targets: HashMap<LayerNodeIdentifier, Vec<ClickTarget>>) {
+		self.document_metadata.click_targets = new_click_targets;
+	}
+
+	/// Update the vector modify of the layers
+	pub fn update_vector_modify(&mut self, new_vector_modify: HashMap<NodeId, VectorData>) {
+		self.document_metadata.vector_modify = new_vector_modify;
 	}
 }
 
@@ -3083,7 +3094,7 @@ impl NodeNetworkInterface {
 	}
 
 	/// Keep metadata in sync with the new implementation if this is used by anything other than the upgrade scripts
-	pub fn set_implementation(&mut self, node_id: &NodeId, network_path: &[NodeId], implementation: DocumentNodeImplementation) {
+	pub fn replace_implementation(&mut self, node_id: &NodeId, network_path: &[NodeId], implementation: DocumentNodeImplementation) {
 		let Some(network) = self.network_mut(network_path) else {
 			log::error!("Could not get nested network in set_implementation");
 			return;
@@ -3095,6 +3106,20 @@ impl NodeNetworkInterface {
 		node.implementation = implementation;
 	}
 
+	// TODO: Eventually remove this (probably starting late 2024)
+	/// Keep metadata in sync with the new implementation if this is used by anything other than the upgrade scripts
+	pub fn replace_implementation_metadata(&mut self, node_id: &NodeId, network_path: &[NodeId], metadata: DocumentNodePersistentMetadata) {
+		let Some(network_metadata) = self.network_metadata_mut(network_path) else {
+			log::error!("Could not get network metdata in set implementation");
+			return;
+		};
+		let Some(node_metadata) = network_metadata.persistent_metadata.node_metadata.get_mut(node_id) else {
+			log::error!("Could not get persistent node metadata for node {node_id} in set implementation");
+			return;
+		};
+		node_metadata.persistent_metadata.network_metadata = metadata.network_metadata;
+	}
+
 	/// Keep metadata in sync with the new implementation if this is used by anything other than the upgrade scripts
 	pub fn replace_inputs(&mut self, node_id: &NodeId, inputs: Vec<NodeInput>, network_path: &[NodeId]) -> Vec<NodeInput> {
 		let Some(network) = self.network_mut(network_path) else {

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -425,7 +425,10 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
 						{
 							let node_definition = crate::messages::portfolio::document::node_graph::document_node_definitions::resolve_document_node_type(reference).unwrap();
 							let default_definition_node = node_definition.default_node_template();
-							document.network_interface.set_implementation(node_id, &[], default_definition_node.document_node.implementation);
+							document.network_interface.replace_implementation(node_id, &[], default_definition_node.document_node.implementation);
+							document
+								.network_interface
+								.replace_implementation_metadata(node_id, &[], default_definition_node.persistent_node_metadata);
 						}
 					}
 				}
@@ -461,7 +464,7 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
 					if reference == "Fill" && node.inputs.len() == 8 {
 						let node_definition = crate::messages::portfolio::document::node_graph::document_node_definitions::resolve_document_node_type(reference).unwrap();
 						let document_node = node_definition.default_node_template().document_node;
-						document.network_interface.set_implementation(node_id, &[], document_node.implementation.clone());
+						document.network_interface.replace_implementation(node_id, &[], document_node.implementation.clone());
 
 						let old_inputs = document.network_interface.replace_inputs(node_id, document_node.inputs.clone(), &[]);
 
@@ -515,6 +518,13 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
 						}
 					}
 
+					// Upgrade construct layer implementation from https://github.com/GraphiteEditor/Graphite/pull/1946
+					if reference == "Merge" || reference == "Artboard" {
+						let node_definition = crate::messages::portfolio::document::node_graph::document_node_definitions::resolve_document_node_type(reference).unwrap();
+						let new_merge_node = node_definition.default_node_template();
+						document.network_interface.replace_implementation(node_id, &[], new_merge_node.document_node.implementation)
+					}
+
 					// Upgrade artboard name being passed as hidden value input to "To Artboard"
 					if reference == "Artboard" {
 						let label = document.network_interface.display_name(node_id, &[]);

editor/src/messages/tool/tool_messages/select_tool.rs

@@ -391,6 +391,9 @@ impl SelectToolData {
 			})
 			.collect();
 		responses.add(NodeGraphMessage::SelectedNodesSet { nodes });
+		responses.add(NodeGraphMessage::RunDocumentGraph);
+		responses.add(NodeGraphMessage::SelectedNodesUpdated);
+		responses.add(NodeGraphMessage::SendGraph);
 		self.layers_dragging = original;
 	}
 }
@@ -413,12 +416,13 @@ impl Fsm for SelectToolFsmState {
 				tool_data.selected_layers_changed = selected_layers_count != tool_data.selected_layers_count;
 				tool_data.selected_layers_count = selected_layers_count;
 
-				// Outline selected layers
+				// Outline selected layers, but not artboards
 				for layer in document
 					.network_interface
 					.selected_nodes(&[])
 					.unwrap()
 					.selected_visible_and_unlocked_layers(&document.network_interface)
+					.filter(|layer| !document.network_interface.is_artboard(&layer.to_node(), &[]))
 				{
 					overlay_context.outline(document.metadata().layer_outline(layer), document.metadata().transform_to_viewport(layer));
 				}
@@ -429,7 +433,7 @@ impl Fsm for SelectToolFsmState {
 					.selected_nodes(&[])
 					.unwrap()
 					.selected_visible_and_unlocked_layers(&document.network_interface)
-					.next()
+					.find(|layer| !document.network_interface.is_artboard(&layer.to_node(), &[]))
 					.map(|layer| document.metadata().transform_to_viewport(layer));
 				let transform = transform.unwrap_or(DAffine2::IDENTITY);
 				if transform.matrix2.determinant() == 0. {
@@ -440,6 +444,7 @@ impl Fsm for SelectToolFsmState {
 					.selected_nodes(&[])
 					.unwrap()
 					.selected_visible_and_unlocked_layers(&document.network_interface)
+					.filter(|layer| !document.network_interface.is_artboard(&layer.to_node(), &[]))
 					.filter_map(|layer| {
 						document
 							.metadata()
@@ -649,7 +654,6 @@ impl Fsm for SelectToolFsmState {
 					}
 
 					if let Some(intersection) = intersection {
-
 						tool_data.layer_selected_on_start = Some(intersection);
 						selected = intersection_list;
 
@@ -694,7 +698,7 @@ impl Fsm for SelectToolFsmState {
 				let axis_align = input.keyboard.key(modifier_keys.axis_align);
 
 				// Ignore the non duplicated layers if the current layers have not spawned yet.
-				let layers_exist = tool_data.layers_dragging.iter().all(|&layer| document.metadata().click_target(layer).is_some());
+				let layers_exist = tool_data.layers_dragging.iter().all(|&layer| document.metadata().click_targets(layer).is_some());
 				let ignore = tool_data.non_duplicated_layers.as_ref().filter(|_| !layers_exist).unwrap_or(&tool_data.layers_dragging);
 
 				let snap_data = SnapData::ignore(document, input, ignore);
@@ -1195,9 +1199,12 @@ fn drag_shallowest_manipulation(responses: &mut VecDeque<Message>, selected: Vec
 }
 
 fn drag_deepest_manipulation(responses: &mut VecDeque<Message>, selected: Vec<LayerNodeIdentifier>, tool_data: &mut SelectToolData, document: &DocumentMessageHandler) {
-	tool_data.layers_dragging.append(&mut vec![document
-		.find_deepest(&selected)
-		.unwrap_or(LayerNodeIdentifier::ROOT_PARENT.children(document.metadata()).next().expect("Child should exist when dragging deepest"))]);
+	tool_data.layers_dragging.append(&mut vec![document.find_deepest(&selected).unwrap_or(
+		LayerNodeIdentifier::ROOT_PARENT
+			.children(document.metadata())
+			.next()
+			.expect("ROOT_PARENT should have a layer child when clicking"),
+	)]);
 	responses.add(NodeGraphMessage::SelectedNodesSet {
 		nodes: tool_data
 			.layers_dragging

editor/src/messages/tool/transform_layer/transform_layer_message_handler.rs

@@ -87,6 +87,8 @@ impl<'a> MessageHandler<TransformLayerMessage, TransformData<'a>> for TransformL
 			*mouse_position = input.mouse.position;
 			*start_mouse = input.mouse.position;
 			selected.original_transforms.clear();
+
+			selected.responses.add(DocumentMessage::StartTransaction);
 		};
 
 		match message {
@@ -97,6 +99,7 @@ impl<'a> MessageHandler<TransformLayerMessage, TransformData<'a>> for TransformL
 
 				self.transform_operation = TransformOperation::None;
 
+				responses.add(DocumentMessage::EndTransaction);
 				responses.add(ToolMessage::UpdateHints);
 				responses.add(NodeGraphMessage::RunDocumentGraph);
 			}
@@ -156,6 +159,7 @@ impl<'a> MessageHandler<TransformLayerMessage, TransformData<'a>> for TransformL
 
 				self.transform_operation = TransformOperation::None;
 
+				responses.add(DocumentMessage::AbortTransaction);
 				responses.add(ToolMessage::UpdateHints);
 			}
 			TransformLayerMessage::ConstrainX => self.transform_operation.constrain_axis(Axis::X, &mut selected, self.snap),