Tidy up NodeNetworkInterface, replacing &[] root network arguments with methods for the document network (#2393)

* Replace `.selected_nodes(&[])` with `.selected_nodes_in_nested_network()` and `.selected_nodes()`

* Replace `.network(&[])` with `.document_network()` and `.nested_network()`

* Replace `.network_metadata(&[])` with `.document_network_metadata()`

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

@@ -253,7 +253,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				};
 
 				let mut added_transaction = false;
-				for layer in self.network_interface.selected_nodes(&[]).unwrap().selected_unlocked_layers(&self.network_interface) {
+				for layer in self.network_interface.selected_nodes().selected_unlocked_layers(&self.network_interface) {
 					let Some(bbox) = self.metadata().bounding_box_viewport(layer) else {
 						continue;
 					};
@@ -290,7 +290,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				});
 			}
 			DocumentMessage::CreateEmptyFolder => {
-				let selected_nodes = self.network_interface.selected_nodes(&[]).unwrap();
+				let selected_nodes = self.network_interface.selected_nodes();
 				let id = NodeId::new();
 
 				let parent = self
@@ -298,7 +298,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 					.deepest_common_ancestor(&selected_nodes, &self.selection_network_path, true)
 					.unwrap_or(LayerNodeIdentifier::ROOT_PARENT);
 
-				let insert_index = DocumentMessageHandler::get_calculated_insert_index(self.metadata(), &self.network_interface.selected_nodes(&[]).unwrap(), parent);
+				let insert_index = DocumentMessageHandler::get_calculated_insert_index(self.metadata(), &self.network_interface.selected_nodes(), parent);
 				responses.add(DocumentMessage::AddTransaction);
 				responses.add(GraphOperationMessage::NewCustomLayer {
 					id,
@@ -440,7 +440,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 					let center = (max + min) / 2.;
 					let bbox_trans = DAffine2::from_translation(-center);
 					let mut added_transaction = false;
-					for layer in self.network_interface.selected_nodes(&[]).unwrap().selected_unlocked_layers(&self.network_interface) {
+					for layer in self.network_interface.selected_nodes().selected_unlocked_layers(&self.network_interface) {
 						if !added_transaction {
 							responses.add(DocumentMessage::AddTransaction);
 							added_transaction = true;
@@ -463,7 +463,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 					let bbox_trans = DAffine2::from_translation(-center);
 
 					let mut added_transaction = false;
-					for layer in self.network_interface.selected_nodes(&[]).unwrap().selected_unlocked_layers(&self.network_interface) {
+					for layer in self.network_interface.selected_nodes().selected_unlocked_layers(&self.network_interface) {
 						if !added_transaction {
 							responses.add(DocumentMessage::AddTransaction);
 							added_transaction = true;
@@ -528,14 +528,14 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 					.children(self.metadata())
 					.filter(|x| self.network_interface.is_artboard(&x.to_node(), &self.selection_network_path))
 					.collect::<Vec<_>>();
-				let Some(selected_nodes) = self.network_interface.selected_nodes(&[]) else { return };
+				let selected_nodes = self.network_interface.selected_nodes();
 
 				// Non-artboard (infinite canvas) workflow
 				if artboards.is_empty() {
 					let Some(parent) = self.network_interface.deepest_common_ancestor(&selected_nodes, &self.selection_network_path, false) else {
 						return;
 					};
-					let Some(selected_nodes) = &self.network_interface.selected_nodes(&self.selection_network_path) else {
+					let Some(selected_nodes) = &self.network_interface.selected_nodes_in_nested_network(&self.selection_network_path) else {
 						return;
 					};
 					let insert_index = DocumentMessageHandler::get_calculated_insert_index(self.metadata(), selected_nodes, parent);
@@ -608,8 +608,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				// Disallow trying to insert into self.
 				if self
 					.network_interface
-					.selected_nodes(&[])
-					.unwrap()
+					.selected_nodes()
 					.selected_layers(self.metadata())
 					.any(|layer| parent.ancestors(self.metadata()).any(|ancestor| ancestor == layer))
 				{
@@ -618,8 +617,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				// Artboards can only have `ROOT_PARENT` as the parent.
 				let any_artboards = self
 					.network_interface
-					.selected_nodes(&[])
-					.unwrap()
+					.selected_nodes()
 					.selected_layers(self.metadata())
 					.any(|layer| self.network_interface.is_artboard(&layer.to_node(), &self.selection_network_path));
 				if any_artboards && parent != LayerNodeIdentifier::ROOT_PARENT {
@@ -629,8 +627,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				// Non-artboards cannot be put at the top level if artboards also exist there
 				let selected_any_non_artboards = self
 					.network_interface
-					.selected_nodes(&[])
-					.unwrap()
+					.selected_nodes()
 					.selected_layers(self.metadata())
 					.any(|layer| !self.network_interface.is_artboard(&layer.to_node(), &self.selection_network_path));
 
@@ -719,9 +716,8 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				let resize_opposite_corner = ipp.keyboard.key(resize_opposite_corner);
 
 				let can_move = |layer| {
-					self.network_interface
-						.selected_nodes(&[])
-						.is_some_and(|selected| selected.layer_visible(layer, &self.network_interface) && !selected.layer_locked(layer, &self.network_interface))
+					let selected = self.network_interface.selected_nodes();
+					selected.layer_visible(layer, &self.network_interface) && !selected.layer_locked(layer, &self.network_interface)
 				};
 
 				// Nudge translation without resizing
@@ -982,7 +978,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				})
 			}
 			DocumentMessage::SelectParentLayer => {
-				let selected_nodes = self.network_interface.selected_nodes(&[]).unwrap();
+				let selected_nodes = self.network_interface.selected_nodes();
 				let selected_layers = selected_nodes.selected_layers(self.metadata());
 
 				let mut parent_layers = HashSet::new();
@@ -1009,8 +1005,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 			DocumentMessage::SelectAllLayers => {
 				let metadata = self.metadata();
 				let all_layers_except_artboards_invisible_and_locked = metadata.all_layers().filter(|&layer| !self.network_interface.is_artboard(&layer.to_node(), &[])).filter(|&layer| {
-					self.network_interface.selected_nodes(&[]).unwrap().layer_visible(layer, &self.network_interface)
-						&& !self.network_interface.selected_nodes(&[]).unwrap().layer_locked(layer, &self.network_interface)
+					self.network_interface.selected_nodes().layer_visible(layer, &self.network_interface) && !self.network_interface.selected_nodes().layer_locked(layer, &self.network_interface)
 				});
 				let nodes = all_layers_except_artboards_invisible_and_locked.map(|layer| layer.to_node()).collect();
 				responses.add(NodeGraphMessage::SelectedNodesSet { nodes });
@@ -1064,7 +1059,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				} else {
 					if ctrl {
 						// Toggle selection when holding ctrl
-						if self.network_interface.selected_nodes(&[]).unwrap().selected_layers_contains(layer, self.metadata()) {
+						if self.network_interface.selected_nodes().selected_layers_contains(layer, self.metadata()) {
 							responses.add_front(NodeGraphMessage::SelectedNodesRemove { nodes: vec![id] });
 						} else {
 							responses.add_front(NodeGraphMessage::SelectedNodesAdd { nodes: vec![id] });
@@ -1106,7 +1101,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				responses.add(NodeGraphMessage::UpdateInSelectedNetwork);
 			}
 			DocumentMessage::SetBlendModeForSelectedLayers { blend_mode } => {
-				for layer in self.network_interface.selected_nodes(&[]).unwrap().selected_layers_except_artboards(&self.network_interface) {
+				for layer in self.network_interface.selected_nodes().selected_layers_except_artboards(&self.network_interface) {
 					responses.add(GraphOperationMessage::BlendModeSet { layer, blend_mode });
 				}
 			}
@@ -1123,7 +1118,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 			}
 			DocumentMessage::SetOpacityForSelectedLayers { opacity } => {
 				let opacity = opacity.clamp(0., 1.);
-				for layer in self.network_interface.selected_nodes(&[]).unwrap().selected_layers_except_artboards(&self.network_interface) {
+				for layer in self.network_interface.selected_nodes().selected_layers_except_artboards(&self.network_interface) {
 					responses.add(GraphOperationMessage::OpacitySet { layer, opacity });
 				}
 			}
@@ -1233,7 +1228,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 					.into_iter()
 					.filter(|(node_id, _)|
 						// Ensure that the layer is in the document network to prevent logging an error
-						self.network_interface.network(&[]).unwrap().nodes.contains_key(node_id))
+						self.network_interface.document_network().nodes.contains_key(node_id))
 					.filter_map(|(node_id, click_targets)| {
 						self.network_interface.is_layer(&node_id, &[]).then(|| {
 							let layer = LayerNodeIdentifier::new(node_id, &self.network_interface, &[]);
@@ -1448,7 +1443,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 		);
 
 		// Additional actions if there are any selected layers
-		if self.network_interface.selected_nodes(&[]).unwrap().selected_layers(self.metadata()).next().is_some() {
+		if self.network_interface.selected_nodes().selected_layers(self.metadata()).next().is_some() {
 			let mut select = actions!(DocumentMessageDiscriminant;
 				DeleteSelectedLayers,
 				DuplicateSelectedLayers,
@@ -1594,8 +1589,7 @@ impl DocumentMessageHandler {
 	/// Get the combined bounding box of the click targets of the selected visible layers in viewport space
 	pub fn selected_visible_layers_bounding_box_viewport(&self) -> Option<[DVec2; 2]> {
 		self.network_interface
-			.selected_nodes(&[])
-			.unwrap()
+			.selected_nodes()
 			.selected_visible_layers(&self.network_interface)
 			.filter_map(|layer| self.metadata().bounding_box_viewport(layer))
 			.reduce(graphene_core::renderer::Quad::combine_bounds)
@@ -1603,15 +1597,14 @@ impl DocumentMessageHandler {
 
 	pub fn selected_visible_and_unlock_layers_bounding_box_viewport(&self) -> Option<[DVec2; 2]> {
 		self.network_interface
-			.selected_nodes(&[])
-			.unwrap()
+			.selected_nodes()
 			.selected_visible_and_unlocked_layers(&self.network_interface)
 			.filter_map(|layer| self.metadata().bounding_box_viewport(layer))
 			.reduce(graphene_core::renderer::Quad::combine_bounds)
 	}
 
 	pub fn document_network(&self) -> &NodeNetwork {
-		self.network_interface.network(&[]).unwrap()
+		self.network_interface.document_network()
 	}
 
 	pub fn metadata(&self) -> &DocumentMetadata {
@@ -1778,7 +1771,7 @@ impl DocumentMessageHandler {
 	}
 
 	pub fn current_hash(&self) -> Option<u64> {
-		self.document_undo_history.iter().last().map(|network| network.network(&[]).unwrap().current_hash())
+		self.document_undo_history.iter().last().map(|network| network.document_network().current_hash())
 	}
 
 	pub fn is_auto_saved(&self) -> bool {
@@ -1827,7 +1820,7 @@ impl DocumentMessageHandler {
 
 	/// Finds the parent folder which, based on the current selections, should be the container of any newly added layers.
 	pub fn new_layer_parent(&self, include_self: bool) -> LayerNodeIdentifier {
-		let Some(selected_nodes) = self.network_interface.selected_nodes(&self.selection_network_path) else {
+		let Some(selected_nodes) = self.network_interface.selected_nodes_in_nested_network(&self.selection_network_path) else {
 			warn!("No selected nodes found in new_layer_parent. Defaulting to ROOT_PARENT.");
 			return LayerNodeIdentifier::ROOT_PARENT;
 		};
@@ -1875,13 +1868,15 @@ impl DocumentMessageHandler {
 			}),
 			GroupFolderType::BooleanOperation(operation) => {
 				// Get the ID of the one selected layer, if exactly one is selected
-				let only_selected_layer = network_interface.selected_nodes(&[]).and_then(|selected_nodes| {
+				let only_selected_layer = {
+					let selected_nodes = network_interface.selected_nodes();
 					let mut layers = selected_nodes.selected_layers(network_interface.document_metadata());
+
 					match (layers.next(), layers.next()) {
 						(Some(id), None) => Some(id),
 						_ => None,
 					}
-				});
+				};
 
 				// If there is a single selected layer, check if there is a boolean operation upstream from it
 				let upstream_boolean_op = only_selected_layer.and_then(|selected_id| {
@@ -2141,7 +2136,7 @@ impl DocumentMessageHandler {
 
 	pub fn update_layers_panel_control_bar_widgets(&self, responses: &mut VecDeque<Message>) {
 		// Get an iterator over the selected layers (excluding artboards which don't have an opacity or blend mode).
-		let selected_nodes = self.network_interface.selected_nodes(&[]).unwrap();
+		let selected_nodes = self.network_interface.selected_nodes();
 		let selected_layers_except_artboards = selected_nodes.selected_layers_except_artboards(&self.network_interface);
 
 		// Look up the current opacity and blend mode of the selected layers (if any), and split the iterator into the first tuple and the rest.
@@ -2193,17 +2188,15 @@ impl DocumentMessageHandler {
 			})
 			.collect();
 
-		let has_selection = self.network_interface.selected_nodes(&[]).unwrap().selected_layers(self.metadata()).next().is_some();
+		let has_selection = self.network_interface.selected_nodes().selected_layers(self.metadata()).next().is_some();
 		let selection_all_visible = self
 			.network_interface
-			.selected_nodes(&[])
-			.unwrap()
+			.selected_nodes()
 			.selected_layers(self.metadata())
 			.all(|layer| self.network_interface.is_visible(&layer.to_node(), &[]));
 		let selection_all_locked = self
 			.network_interface
-			.selected_nodes(&[])
-			.unwrap()
+			.selected_nodes()
 			.selected_layers(self.metadata())
 			.all(|layer| self.network_interface.is_locked(&layer.to_node(), &[]));
 
@@ -2284,7 +2277,7 @@ impl DocumentMessageHandler {
 	}
 
 	pub fn selected_layers_reverse(&mut self, responses: &mut VecDeque<Message>) {
-		let selected_layers = self.network_interface.selected_nodes(&[]).unwrap();
+		let selected_layers = self.network_interface.selected_nodes();
 		let metadata = self.metadata();
 		let selected_layer_set = selected_layers.selected_layers(metadata).collect::<HashSet<_>>();
 
@@ -2376,7 +2369,7 @@ impl DocumentMessageHandler {
 	}
 
 	pub fn selected_layers_reorder(&mut self, relative_index_offset: isize, responses: &mut VecDeque<Message>) {
-		let selected_nodes = self.network_interface.selected_nodes(&[]).unwrap();
+		let selected_nodes = self.network_interface.selected_nodes();
 		let mut selected_layers = selected_nodes.selected_layers(self.metadata());
 
 		let first_or_last_selected_layer = match relative_index_offset.signum() {
@@ -2506,7 +2499,7 @@ impl<'a> ClickXRayIter<'a> {
 
 	/// Handles the checking of the layer to find if it has been clicked
 	fn check_layer(&mut self, layer: LayerNodeIdentifier) -> XRayResult {
-		let selected_layers = self.network_interface.selected_nodes(&[]).unwrap();
+		let selected_layers = self.network_interface.selected_nodes();
 		// Discard invisible and locked layers
 		if !selected_layers.layer_visible(layer, self.network_interface) || selected_layers.layer_locked(layer, self.network_interface) {
 			return XRayResult { clicked: false, use_children: false };

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

@@ -116,7 +116,7 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageData<'_>> for Gr
 				network_interface.move_layer_to_stack(artboard_layer, LayerNodeIdentifier::ROOT_PARENT, 0, &[]);
 
 				// If there is a non artboard feeding into the primary input of the artboard, move it to the secondary input
-				let Some(artboard) = network_interface.network(&[]).and_then(|network| network.nodes.get(&id)) else {
+				let Some(artboard) = network_interface.document_network().nodes.get(&id) else {
 					log::error!("Artboard not created");
 					return;
 				};
@@ -218,7 +218,7 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageData<'_>> for Gr
 				// Go through all artboards and create merge nodes
 				for artboard in network_interface.all_artboards() {
 					let node_id = NodeId::new();
-					let Some(document_node) = network_interface.network(&[]).and_then(|network| network.nodes.get(&artboard.to_node())) else {
+					let Some(document_node) = network_interface.document_network().nodes.get(&artboard.to_node()) else {
 						log::error!("Artboard not created");
 						responses.add(DocumentMessage::AbortTransaction);
 						return;

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

@@ -229,11 +229,7 @@ impl<'a> ModifyInputsContext<'a> {
 
 	fn get_output_layer(&self) -> Option<LayerNodeIdentifier> {
 		self.layer_node.or_else(|| {
-			let Some(network) = self.network_interface.network(&[]) else {
-				log::error!("Document network does not exist in ModifyInputsContext::get_output_node");
-				return None;
-			};
-			let export_node = network.exports.first().and_then(|export| export.as_node())?;
+			let export_node = self.network_interface.document_network().exports.first().and_then(|export| export.as_node())?;
 			if self.network_interface.is_layer(&export_node, &[]) {
 				Some(LayerNodeIdentifier::new(export_node, self.network_interface, &[]))
 			} else {
@@ -266,7 +262,7 @@ impl<'a> ModifyInputsContext<'a> {
 			}
 
 			let is_traversal_start = |node_id: NodeId| {
-				self.layer_node.map(|layer| layer.to_node()) == Some(node_id) || self.network_interface.network(&[]).unwrap().exports.iter().any(|export| export.as_node() == Some(node_id))
+				self.layer_node.map(|layer| layer.to_node()) == Some(node_id) || self.network_interface.document_network().exports.iter().any(|export| export.as_node() == Some(node_id))
 			};
 
 			if !is_traversal_start(upstream_node) && (self.network_interface.is_layer(&upstream_node, &[])) {
@@ -373,7 +369,7 @@ impl<'a> ModifyInputsContext<'a> {
 		let (layer_transform, transform_node_id) = self
 			.existing_node_id("Transform", false)
 			.and_then(|transform_node_id| {
-				let document_node = self.network_interface.network(&[])?.nodes.get(&transform_node_id)?;
+				let document_node = self.network_interface.document_network().nodes.get(&transform_node_id)?;
 				Some((transform_utils::get_current_transform(&document_node.inputs), transform_node_id))
 			})
 			.unzip();

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

@@ -125,11 +125,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				collapsed.0.retain(|&layer| network_interface.document_metadata().layer_exists(layer));
 			}
 			NodeGraphMessage::SelectedNodesUpdated => {
-				let selected_layers = network_interface
-					.selected_nodes(&[])
-					.unwrap()
-					.selected_layers(network_interface.document_metadata())
-					.collect::<Vec<_>>();
+				let selected_layers = network_interface.selected_nodes().selected_layers(network_interface.document_metadata()).collect::<Vec<_>>();
 				if selected_layers.len() <= 1 {
 					responses.add(DocumentMessage::SetRangeSelectionLayer {
 						new_layer: selected_layers.first().cloned(),
@@ -264,7 +260,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 			// 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.
 			NodeGraphMessage::DeleteSelectedNodes { delete_children } => {
-				let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
+				let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
 					log::error!("Could not get selected nodes in DeleteSelectedNodes");
 					return;
 				};
@@ -361,7 +357,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 			}
 			NodeGraphMessage::MergeSelectedNodes => {
 				let new_ids = network_interface
-					.selected_nodes(breadcrumb_network_path)
+					.selected_nodes_in_nested_network(breadcrumb_network_path)
 					.unwrap()
 					.selected_nodes()
 					.map(|id| (*id, *id))
@@ -377,9 +373,10 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				let mut import_connections = Vec::new();
 				let mut export_connections = Vec::new();
 				// Scan current nodes top to bottom and find all inputs/outputs connected to nodes that are not in the copied nodes. These will represent the new imports and exports.
-				let Some(nodes_sorted_top_to_bottom) =
-					network_interface.nodes_sorted_top_to_bottom(network_interface.selected_nodes(breadcrumb_network_path).unwrap().selected_nodes(), breadcrumb_network_path)
-				else {
+				let Some(nodes_sorted_top_to_bottom) = network_interface.nodes_sorted_top_to_bottom(
+					network_interface.selected_nodes_in_nested_network(breadcrumb_network_path).unwrap().selected_nodes(),
+					breadcrumb_network_path,
+				) else {
 					return;
 				};
 				//Ensure that nodes can be grouped by checking if there is an unselected node between selected nodes
@@ -676,7 +673,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				}
 
 				self.selection_before_pointer_down = network_interface
-					.selected_nodes(selection_network_path)
+					.selected_nodes_in_nested_network(selection_network_path)
 					.map(|selected_nodes| selected_nodes.selected_nodes().cloned().collect())
 					.unwrap_or_default();
 
@@ -730,7 +727,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				}
 
 				if let Some(clicked_id) = clicked_id {
-					let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
+					let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
 						log::error!("Could not get selected nodes in PointerDown");
 						return;
 					};
@@ -952,7 +949,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 					log::error!("Selection network path does not match breadcrumb network path in PointerUp");
 					return;
 				}
-				let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
+				let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
 					log::error!("Could not get selected nodes in PointerUp");
 					return;
 				};
@@ -1025,7 +1022,10 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 					self.shift_without_push = false;
 					// Reset all offsets to end the rubber banding while dragging
 					network_interface.unload_stack_dependents_y_offset(selection_network_path);
-					let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else { return };
+					let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
+						log::error!("Could not get selected nodes in PointerUp");
+						return;
+					};
 					// Only select clicked node if multiple are selected and they were not dragged
 					if let Some(select_if_not_dragged) = self.select_if_not_dragged {
 						if drag_start.start_x == point.x
@@ -1041,7 +1041,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 					}
 
 					// Try expand the upstream chain for all layers if there is an eligible node
-					let Some(network) = network_interface.network(selection_network_path) else { return };
+					let Some(network) = network_interface.nested_network(selection_network_path) else { return };
 					for layer in network
 						.nodes
 						.keys()
@@ -1053,14 +1053,17 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 					}
 					responses.add(NodeGraphMessage::SendGraph);
 
-					let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else { return };
+					let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
+						log::error!("Could not get selected nodes in PointerUp");
+						return;
+					};
 					// Check if a single node was dragged onto a wire and that the node was dragged onto the wire
 					if selected_nodes.selected_nodes_ref().len() == 1 && !self.begin_dragging {
 						let selected_node_id = selected_nodes.selected_nodes_ref()[0];
 						let has_primary_output_connection = network_interface
 							.outward_wires(selection_network_path)
 							.is_some_and(|outward_wires| outward_wires.get(&OutputConnector::node(selected_node_id, 0)).is_some_and(|outward_wires| !outward_wires.is_empty()));
-						let Some(network) = network_interface.network(selection_network_path) else {
+						let Some(network) = network_interface.nested_network(selection_network_path) else {
 							return;
 						};
 						if let Some(selected_node) = network.nodes.get(&selected_node_id) {
@@ -1164,7 +1167,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 									None
 								};
 								if let Some(overlapping_wire) = overlapping_wire {
-									let Some(network) = network_interface.network(selection_network_path) else {
+									let Some(network) = network_interface.nested_network(selection_network_path) else {
 										return;
 									};
 									// Ensure connection is to first visible input of selected node. If it does not have an input then do not connect
@@ -1390,7 +1393,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				}
 			}
 			NodeGraphMessage::ToggleSelectedAsLayersOrNodes => {
-				let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
+				let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
 					log::error!("Could not get selected nodes in NodeGraphMessage::ToggleSelectedAsLayersOrNodes");
 					return;
 				};
@@ -1458,7 +1461,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				network_interface.toggle_preview(node_id, selection_network_path);
 			}
 			NodeGraphMessage::ToggleSelectedLocked => {
-				let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
+				let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
 					log::error!("Could not get selected nodes in NodeGraphMessage::ToggleSelectedLocked");
 					return;
 				};
@@ -1476,7 +1479,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				responses.add(NodeGraphMessage::SetLockedOrVisibilitySideEffects { node_ids })
 			}
 			NodeGraphMessage::ToggleLocked { node_id } => {
-				let Some(node_metadata) = network_interface.network_metadata(&[]).unwrap().persistent_metadata.node_metadata.get(&node_id) else {
+				let Some(node_metadata) = network_interface.document_network_metadata().persistent_metadata.node_metadata.get(&node_id) else {
 					log::error!("Cannot get node {:?} in NodeGraphMessage::ToggleLocked", node_id);
 					return;
 				};
@@ -1491,7 +1494,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				network_interface.set_locked(&node_id, selection_network_path, locked);
 			}
 			NodeGraphMessage::ToggleSelectedIsPinned => {
-				let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
+				let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
 					log::error!("Could not get selected nodes in NodeGraphMessage::ToggleSelectedIsPinned");
 					return;
 				};
@@ -1507,7 +1510,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				responses.add(NodeGraphMessage::SetLockedOrVisibilitySideEffects { node_ids });
 			}
 			NodeGraphMessage::ToggleSelectedVisibility => {
-				let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
+				let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
 					log::error!("Could not get selected nodes in NodeGraphMessage::ToggleSelectedLocked");
 					return;
 				};
@@ -1576,7 +1579,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 						.transform_point2(ipp.mouse.position);
 
 					let shift = ipp.keyboard.get(crate::messages::tool::tool_messages::tool_prelude::Key::Shift as usize);
-					let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
+					let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
 						log::error!("Could not get selected nodes in PointerMove");
 						return;
 					};
@@ -1670,7 +1673,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				in_selected_network: selection_network_path == breadcrumb_network_path,
 			}),
 			NodeGraphMessage::SendSelectedNodes => {
-				let Some(selected_nodes) = network_interface.selected_nodes(breadcrumb_network_path) else {
+				let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(breadcrumb_network_path) else {
 					log::error!("Could not get selected nodes in NodeGraphMessage::SendSelectedNodes");
 					return;
 				};
@@ -1680,7 +1683,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 				});
 			}
 		}
-		let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
+		let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
 			log::error!("Could not get selected nodes in NodeGraphMessageHandler");
 			return;
 		};
@@ -1736,19 +1739,19 @@ impl NodeGraphMessageHandler {
 			return;
 		};
 
-		let Some(network) = network_interface.network(breadcrumb_network_path) else {
+		let Some(network) = network_interface.nested_network(breadcrumb_network_path) else {
 			warn!("No network in update_selection_action_buttons");
 			return;
 		};
 
-		let Some(selected_nodes) = network_interface.selected_nodes(breadcrumb_network_path) else {
+		let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(breadcrumb_network_path) else {
 			warn!("No selected nodes in update_selection_action_buttons");
 			return;
 		};
 
 		let has_selection = selected_nodes.has_selected_nodes();
-		let selection_includes_layers = network_interface.selected_nodes(&[]).unwrap().selected_layers(network_interface.document_metadata()).count() > 0;
-		let selection_all_locked = network_interface.selected_nodes(&[]).unwrap().selected_unlocked_layers(network_interface).count() == 0;
+		let selection_includes_layers = network_interface.selected_nodes().selected_layers(network_interface.document_metadata()).count() > 0;
+		let selection_all_locked = network_interface.selected_nodes().selected_unlocked_layers(network_interface).count() == 0;
 		let selection_all_visible = selected_nodes.selected_nodes().all(|node_id| network_interface.is_visible(node_id, breadcrumb_network_path));
 
 		let mut widgets = vec![
@@ -1913,7 +1916,7 @@ impl NodeGraphMessageHandler {
 	/// Collate the properties panel sections for a node graph
 	pub fn collate_properties(context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
 		// If the selected nodes are in the document network, use the document network. Otherwise, use the nested network
-		let Some(selected_nodes) = context.network_interface.selected_nodes(context.selection_network_path) else {
+		let Some(selected_nodes) = context.network_interface.selected_nodes_in_nested_network(context.selection_network_path) else {
 			warn!("No selected nodes in collate_properties");
 			return Vec::new();
 		};
@@ -1958,7 +1961,7 @@ impl NodeGraphMessageHandler {
 					],
 				}];
 
-				let Some(network) = context.network_interface.network(context.selection_network_path) else {
+				let Some(network) = context.network_interface.nested_network(context.selection_network_path) else {
 					warn!("No network in collate_properties");
 					return Vec::new();
 				};
@@ -2056,7 +2059,7 @@ impl NodeGraphMessageHandler {
 	}
 
 	fn collect_wires(network_interface: &NodeNetworkInterface, breadcrumb_network_path: &[NodeId]) -> Vec<FrontendNodeWire> {
-		let Some(network) = network_interface.network(breadcrumb_network_path) else {
+		let Some(network) = network_interface.nested_network(breadcrumb_network_path) else {
 			log::error!("Could not get network when collecting wires");
 			return Vec::new();
 		};
@@ -2129,7 +2132,7 @@ impl NodeGraphMessageHandler {
 		};
 		let mut can_be_layer_lookup = HashSet::new();
 		let mut position_lookup = HashMap::new();
-		let Some(network) = network_interface.network(breadcrumb_network_path) else {
+		let Some(network) = network_interface.nested_network(breadcrumb_network_path) else {
 			log::error!("Could not get nested network when collecting nodes");
 			return Vec::new();
 		};
@@ -2145,7 +2148,7 @@ impl NodeGraphMessageHandler {
 			}
 		}
 		let mut frontend_inputs_lookup = frontend_inputs_lookup(breadcrumb_network_path, network_interface);
-		let Some(network) = network_interface.network(breadcrumb_network_path) else {
+		let Some(network) = network_interface.nested_network(breadcrumb_network_path) else {
 			log::error!("Could not get nested network when collecting nodes");
 			return Vec::new();
 		};
@@ -2221,7 +2224,7 @@ impl NodeGraphMessageHandler {
 					connected_to,
 				});
 			}
-			let Some(network) = network_interface.network(breadcrumb_network_path) else {
+			let Some(network) = network_interface.nested_network(breadcrumb_network_path) else {
 				log::error!("Could not get nested network when collecting nodes");
 				return Vec::new();
 			};
@@ -2275,7 +2278,7 @@ impl NodeGraphMessageHandler {
 
 	fn collect_subgraph_names(network_interface: &mut NodeNetworkInterface, breadcrumb_network_path: &[NodeId]) -> Option<Vec<String>> {
 		let mut current_network_path = vec![];
-		let mut current_network = network_interface.network(&current_network_path).unwrap();
+		let mut current_network = network_interface.nested_network(&current_network_path).unwrap();
 		let mut subgraph_names = vec!["Document".to_string()];
 		for node_id in breadcrumb_network_path {
 			if let Some(node) = current_network.nodes.get(node_id) {
@@ -2293,11 +2296,8 @@ impl NodeGraphMessageHandler {
 	}
 
 	fn update_layer_panel(network_interface: &NodeNetworkInterface, selection_network_path: &[NodeId], collapsed: &CollapsedLayers, responses: &mut VecDeque<Message>) {
-		let Some(selected_nodes) = network_interface.selected_nodes(&[]) else {
-			log::error!("Could not get selected layers in update_layer_panel");
-			return;
-		};
-		let selected_layers = selected_nodes
+		let selected_layers = network_interface
+			.selected_nodes()
 			.selected_layers(network_interface.document_metadata())
 			.map(|layer| layer.to_node())
 			.collect::<HashSet<_>>();
@@ -2315,7 +2315,7 @@ impl NodeGraphMessageHandler {
 			}
 		}
 
-		for (&node_id, node_metadata) in &network_interface.network_metadata(&[]).unwrap().persistent_metadata.node_metadata {
+		for (&node_id, node_metadata) in &network_interface.document_network_metadata().persistent_metadata.node_metadata {
 			if node_metadata.persistent_metadata.is_layer() {
 				let layer = LayerNodeIdentifier::new(node_id, network_interface, &[]);
 
@@ -2449,7 +2449,7 @@ type FrontendInputsLookup = HashMap<NodeId, Vec<Option<InputLookup>>>;
 
 /// Create a lookup hashmap that can be used to create the frontend inputs. This is needed because `input_type` requires a mutable `network_interface`.
 fn frontend_inputs_lookup(breadcrumb_network_path: &[NodeId], network_interface: &mut NodeNetworkInterface) -> FrontendInputsLookup {
-	let Some(network) = network_interface.network(breadcrumb_network_path) else {
+	let Some(network) = network_interface.nested_network(breadcrumb_network_path) else {
 		return Default::default();
 	};
 	let mut frontend_inputs_lookup = HashMap::new();

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

@@ -101,7 +101,7 @@ pub(crate) fn property_from_type(
 		log::warn!("A widget failed to be built for node {node_id}, index {index} because the input name could not be determined");
 		return Err(vec![]);
 	};
-	let Some(network) = context.network_interface.network(context.selection_network_path) else {
+	let Some(network) = context.network_interface.nested_network(context.selection_network_path) else {
 		log::warn!("A widget failed to be built for node {node_id}, index {index} because the network could not be determined");
 		return Err(vec![]);
 	};
@@ -1171,7 +1171,10 @@ pub fn centroid_widget(document_node: &DocumentNode, node_id: NodeId, index: usi
 }
 
 pub fn get_document_node<'a>(node_id: NodeId, context: &'a NodePropertiesContext<'a>) -> Result<&'a DocumentNode, String> {
-	let network = context.network_interface.network(context.selection_network_path).ok_or("network not found in get_document_node")?;
+	let network = context
+		.network_interface
+		.nested_network(context.selection_network_path)
+		.ok_or("network not found in get_document_node")?;
 	network.nodes.get(&node_id).ok_or(format!("node {node_id} not found in get_document_node"))
 }
 
@@ -1818,7 +1821,7 @@ pub(crate) fn rectangle_properties(node_id: NodeId, context: &mut NodeProperties
 // 	let image_size = context
 // 		.executor
 // 		.introspect_node_in_network(
-// 			context.network_interface.network(&[]).unwrap(),
+// 			context.network_interface.document_network().unwrap(),
 // 			&imaginate_node,
 // 			|network| {
 // 				network

editor/src/messages/portfolio/document/overlays/utility_functions.rs

@@ -42,7 +42,7 @@ pub fn selected_segments(document: &DocumentMessageHandler, shape_editor: &mut S
 
 	// TODO: Currently if there are two duplicate layers, both of their segments get overlays
 	// Adding segments which are are connected to selected anchors
-	for layer in document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()) {
+	for layer in document.network_interface.selected_nodes().selected_layers(document.metadata()) {
 		let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else { continue };
 
 		for (segment_id, _bezier, start, end) in vector_data.segment_bezier_iter() {
@@ -114,7 +114,7 @@ pub fn overlay_bezier_handle_specific_point(
 }
 
 pub fn path_overlays(document: &DocumentMessageHandler, draw_handles: DrawHandles, shape_editor: &mut ShapeState, overlay_context: &mut OverlayContext) {
-	for layer in document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()) {
+	for layer in document.network_interface.selected_nodes().selected_layers(document.metadata()) {
 		let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else { continue };
 		let transform = document.metadata().transform_to_viewport(layer);
 		overlay_context.outline_vector(&vector_data, transform);
@@ -167,7 +167,7 @@ pub fn path_overlays(document: &DocumentMessageHandler, draw_handles: DrawHandle
 }
 
 pub fn path_endpoint_overlays(document: &DocumentMessageHandler, shape_editor: &mut ShapeState, overlay_context: &mut OverlayContext, preferences: &PreferencesMessageHandler) {
-	for layer in document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()) {
+	for layer in document.network_interface.selected_nodes().selected_layers(document.metadata()) {
 		let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else {
 			continue;
 		};

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

@@ -198,7 +198,7 @@ impl LayerNodeIdentifier {
 		debug_assert!(
 			network_interface.is_layer(&node_id, network_path),
 			"Layer identifier constructed from non-layer node {node_id}: {:#?}",
-			network_interface.network(network_path).unwrap().nodes.get(&node_id)
+			network_interface.nested_network(network_path).unwrap().nodes.get(&node_id)
 		);
 		Self::new_unchecked(node_id)
 	}

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

@@ -60,19 +60,27 @@ impl PartialEq for NodeNetworkInterface {
 
 // Public immutable getters for the network interface
 impl NodeNetworkInterface {
+	// TODO: Make private and use .field_name getter methods
+	/// Gets the network of the root document
+	pub fn document_network(&self) -> &NodeNetwork {
+		self.network
+			.nested_network(&[])
+			.expect("Could not get root document network in NodeNetworkInterface::document_network()")
+	}
+
 	// TODO: Make private and use .field_name getter methods
 	/// Gets the nested network based on network_path
-	pub fn network(&self, network_path: &[NodeId]) -> Option<&NodeNetwork> {
+	pub fn nested_network(&self, network_path: &[NodeId]) -> Option<&NodeNetwork> {
 		let Some(network) = self.network.nested_network(network_path) else {
-			log::error!("Could not get nested network with path {network_path:?}");
+			log::error!("Could not get nested network with path {network_path:?} in NodeNetworkInterface::network");
 			return None;
 		};
 		Some(network)
 	}
 
-	// TODO: Make private and use .field_name getter methods. For example network_interface.inputs(node_id, network_path) rather than getting the node then getting inputs
+	/// Get the specified document node in the nested network based on node_id and network_path
 	pub fn document_node(&self, node_id: &NodeId, network_path: &[NodeId]) -> Option<&DocumentNode> {
-		let network = self.network(network_path)?;
+		let network = self.nested_network(network_path)?;
 		let Some(node_metadata) = network.nodes.get(node_id) else {
 			log::error!("Could not get document node with id {node_id} in network {network_path:?}");
 			return None;
@@ -80,6 +88,10 @@ impl NodeNetworkInterface {
 		Some(node_metadata)
 	}
 
+	pub fn document_network_metadata(&self) -> &NodeNetworkMetadata {
+		&self.network_metadata
+	}
+
 	// TODO: Make private and use .field_name getter methods
 	/// The network metadata should always exist for the current network
 	pub fn network_metadata(&self, network_path: &[NodeId]) -> Option<&NodeNetworkMetadata> {
@@ -108,8 +120,12 @@ impl NodeNetworkInterface {
 		self.transaction_status
 	}
 
+	pub fn selected_nodes(&self) -> SelectedNodes {
+		self.selected_nodes_in_nested_network(&[]).unwrap_or_default()
+	}
+
 	/// Get the selected nodes for the network at the network_path
-	pub fn selected_nodes(&self, network_path: &[NodeId]) -> Option<SelectedNodes> {
+	pub fn selected_nodes_in_nested_network(&self, network_path: &[NodeId]) -> Option<SelectedNodes> {
 		let Some(network_metadata) = self.network_metadata(network_path) else {
 			log::error!("Could not get nested network_metadata in selected_nodes");
 			return None;
@@ -217,7 +233,7 @@ impl NodeNetworkInterface {
 
 	/// Check if the specified node id is connected to the output
 	pub fn connected_to_output(&self, target_node_id: &NodeId, network_path: &[NodeId]) -> bool {
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			log::error!("Could not get network in connected_to_output");
 			return false;
 		};
@@ -440,7 +456,7 @@ impl NodeNetworkInterface {
 	}
 
 	pub fn input_from_connector(&self, input_connector: &InputConnector, network_path: &[NodeId]) -> Option<&NodeInput> {
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			log::error!("Could not get network in input_from_connector");
 			return None;
 		};
@@ -825,7 +841,7 @@ impl NodeNetworkInterface {
 				.input_ports
 				.iter()
 				.filter_map(|(export_index, click_target)| {
-					let Some(network) = self.network(network_path) else {
+					let Some(network) = self.nested_network(network_path) else {
 						log::error!("Could not get network in frontend_exports");
 						return None;
 					};
@@ -1073,7 +1089,7 @@ impl NodeNetworkInterface {
 
 	/// Returns the root node (the node that the solid line is connect to), or None if no nodes are connected to the output
 	pub fn root_node(&self, network_path: &[NodeId]) -> Option<RootNode> {
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			log::error!("Could not get network in root_node");
 			return None;
 		};
@@ -1243,8 +1259,7 @@ impl NodeNetworkInterface {
 	}
 
 	pub fn all_artboards(&self) -> HashSet<LayerNodeIdentifier> {
-		self.network_metadata(&[])
-			.unwrap()
+		self.document_network_metadata()
 			.persistent_metadata
 			.node_metadata
 			.iter()
@@ -1269,7 +1284,7 @@ impl NodeNetworkInterface {
 			log::error!("Currently can only get deepest common ancestor in the document network");
 			return Vec::new();
 		}
-		let Some(selected_nodes) = self.selected_nodes(network_path) else {
+		let Some(selected_nodes) = self.selected_nodes_in_nested_network(network_path) else {
 			log::error!("Could not get selected nodes in deepest_common_ancestor");
 			return Vec::new();
 		};
@@ -1311,7 +1326,7 @@ impl NodeNetworkInterface {
 
 	/// Calculates the selected layer bounds in document space
 	pub fn selected_bounds_document_space(&self, include_artboards: bool, network_path: &[NodeId]) -> Option<[DVec2; 2]> {
-		let Some(selected_nodes) = self.selected_nodes(network_path) else {
+		let Some(selected_nodes) = self.selected_nodes_in_nested_network(network_path) else {
 			log::error!("Could not get selected nodes in shallowest_unique_layers");
 			return None;
 		};
@@ -1325,7 +1340,7 @@ impl NodeNetworkInterface {
 	/// Layers excluding ones that are children of other layers in the list.
 	// TODO: Cache this
 	pub fn shallowest_unique_layers(&self, network_path: &[NodeId]) -> impl Iterator<Item = LayerNodeIdentifier> {
-		let mut sorted_layers = if let Some(selected_nodes) = self.selected_nodes(network_path) {
+		let mut sorted_layers = if let Some(selected_nodes) = self.selected_nodes_in_nested_network(network_path) {
 			selected_nodes
 				.selected_layers(self.document_metadata())
 				.map(|layer| {
@@ -1390,7 +1405,7 @@ impl NodeNetworkInterface {
 
 	/// Gives an iterator to all nodes connected to the given nodes by all inputs (primary or primary + secondary depending on `only_follow_primary` choice), traversing backwards upstream starting from the given node's inputs.
 	pub fn upstream_flow_back_from_nodes<'a>(&'a self, mut node_ids: Vec<NodeId>, network_path: &'a [NodeId], mut flow_type: FlowType) -> impl Iterator<Item = NodeId> + 'a {
-		let (Some(network), Some(network_metadata)) = (self.network(network_path), self.network_metadata(network_path)) else {
+		let (Some(network), Some(network_metadata)) = (self.nested_network(network_path), self.network_metadata(network_path)) else {
 			log::error!("Could not get network or network_metadata in upstream_flow_back_from_nodes");
 			return FlowIter {
 				stack: Vec::new(),
@@ -1748,7 +1763,7 @@ impl NodeNetworkInterface {
 
 	// This function always has to be in sync with the selected nodes.
 	fn load_stack_dependents(&mut self, network_path: &[NodeId]) {
-		let Some(selected_nodes) = self.selected_nodes(network_path) else {
+		let Some(selected_nodes) = self.selected_nodes_in_nested_network(network_path) else {
 			log::error!("Could not get selected nodes in load_stack_dependents");
 			return;
 		};
@@ -1951,7 +1966,7 @@ impl NodeNetworkInterface {
 			log::error!("Could not get nested network_metadata in load_export_ports");
 			return;
 		};
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			log::error!("Could not get current network in load_export_ports");
 			return;
 		};
@@ -2050,7 +2065,7 @@ impl NodeNetworkInterface {
 			log::error!("Could not get nested network_metadata in load_export_ports");
 			return;
 		};
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			log::error!("Could not get current network in load_export_ports");
 			return;
 		};
@@ -2311,7 +2326,7 @@ impl NodeNetworkInterface {
 
 	fn load_outward_wires(&mut self, network_path: &[NodeId]) {
 		let mut outward_wires = HashMap::new();
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			log::error!("Could not get nested network in load_outward_wires");
 			return;
 		};
@@ -2601,7 +2616,7 @@ impl NodeNetworkInterface {
 	}
 
 	pub fn try_load_all_node_click_targets(&mut self, network_path: &[NodeId]) {
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			log::error!("Could not get network in load_all_node_click_targets");
 			return;
 		};
@@ -2718,7 +2733,7 @@ impl NodeNetworkInterface {
 	}
 
 	pub fn unload_all_nodes_click_targets(&mut self, network_path: &[NodeId]) {
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			log::error!("Could not get nested network in unload_all_nodes_click_targets");
 			return;
 		};
@@ -2737,7 +2752,7 @@ impl NodeNetworkInterface {
 // Helper functions for mutable getters
 impl NodeNetworkInterface {
 	pub fn upstream_chain_nodes(&mut self, network_path: &[NodeId]) -> Vec<NodeId> {
-		let Some(selected_nodes) = self.selected_nodes(network_path) else {
+		let Some(selected_nodes) = self.selected_nodes_in_nested_network(network_path) else {
 			log::error!("Could not get selected nodes in upstream_chain_nodes");
 			return Vec::new();
 		};
@@ -2895,7 +2910,7 @@ impl NodeNetworkInterface {
 			log::error!("Could not get nested network_metadata in node_from_click");
 			return None;
 		};
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			log::error!("Could not get nested network in node_from_click");
 			return None;
 		};
@@ -2932,7 +2947,7 @@ impl NodeNetworkInterface {
 			log::error!("Could not get nested network_metadata in visibility_from_click");
 			return None;
 		};
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			log::error!("Could not get nested network in visibility_from_click");
 			return None;
 		};
@@ -2962,7 +2977,7 @@ impl NodeNetworkInterface {
 			log::error!("Could not get nested network_metadata in input_connector_from_click");
 			return None;
 		};
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			log::error!("Could not get nested network in input_connector_from_click");
 			return None;
 		};
@@ -2995,7 +3010,7 @@ impl NodeNetworkInterface {
 			log::error!("Could not get nested network_metadata in output_connector_from_click");
 			return None;
 		};
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			log::error!("Could not get nested network in output_connector_from_click");
 			return None;
 		};
@@ -3068,7 +3083,7 @@ impl NodeNetworkInterface {
 
 	/// Get the combined bounding box of the click targets of the selected nodes in the node graph in layer space
 	pub fn selected_nodes_bounding_box(&mut self, network_path: &[NodeId]) -> Option<[DVec2; 2]> {
-		let Some(selected_nodes) = self.selected_nodes(network_path) else {
+		let Some(selected_nodes) = self.selected_nodes_in_nested_network(network_path) else {
 			log::error!("Could not get selected nodes in selected_nodes_bounding_box_viewport");
 			return None;
 		};
@@ -3151,9 +3166,7 @@ impl NodeNetworkInterface {
 		self.document_metadata.structure = HashMap::from_iter([(LayerNodeIdentifier::ROOT_PARENT, NodeRelations::default())]);
 
 		// Only load structure if there is a root node
-		let Some(root_node) = self.root_node(&[]) else {
-			return;
-		};
+		let Some(root_node) = self.root_node(&[]) else { return };
 
 		let Some(first_root_layer) = self.upstream_flow_back_from_nodes(vec![root_node.node_id], &[], FlowType::PrimaryFlow).find_map(|node_id| {
 			if self.is_layer(&node_id, &[]) {
@@ -3229,7 +3242,7 @@ impl NodeNetworkInterface {
 			}
 		}
 
-		let nodes: HashSet<NodeId> = self.network(&[]).unwrap().nodes.keys().cloned().collect::<HashSet<_>>();
+		let nodes: HashSet<NodeId> = self.document_network().nodes.keys().cloned().collect::<HashSet<_>>();
 
 		self.document_metadata.upstream_transforms.retain(|node, _| nodes.contains(node));
 		self.document_metadata.vector_modify.retain(|node, _| nodes.contains(node));
@@ -4573,7 +4586,7 @@ impl NodeNetworkInterface {
 	}
 
 	pub fn toggle_preview(&mut self, toggle_id: NodeId, network_path: &[NodeId]) {
-		let Some(network) = self.network(network_path) else {
+		let Some(network) = self.nested_network(network_path) else {
 			return;
 		};
 		// If new_export is None then disconnect
@@ -4919,7 +4932,10 @@ impl NodeNetworkInterface {
 	}
 
 	pub fn shift_selected_nodes(&mut self, direction: Direction, shift_without_push: bool, network_path: &[NodeId]) {
-		let Some(mut node_ids) = self.selected_nodes(network_path).map(|selected_nodes| selected_nodes.selected_nodes().cloned().collect::<HashSet<_>>()) else {
+		let Some(mut node_ids) = self
+			.selected_nodes_in_nested_network(network_path)
+			.map(|selected_nodes| selected_nodes.selected_nodes().cloned().collect::<HashSet<_>>())
+		else {
 			log::error!("Could not get selected nodes in shift_selected_nodes");
 			return;
 		};
@@ -5093,7 +5109,7 @@ impl NodeNetworkInterface {
 				if *offset == 0 {
 					return None;
 				}
-				if self.selected_nodes(network_path).is_some_and(|selected_nodes| {
+				if self.selected_nodes_in_nested_network(network_path).is_some_and(|selected_nodes| {
 					selected_nodes
 						.selected_nodes()
 						.any(|selected_node| selected_node == node_id || self.owned_nodes(node_id, network_path).is_some_and(|owned_nodes| owned_nodes.contains(selected_node)))

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

@@ -543,8 +543,7 @@ impl<'a> Selected<'a> {
 
 		let mut transform = self
 			.network_interface
-			.selected_nodes(&[])
-			.unwrap()
+			.selected_nodes()
 			.selected_visible_and_unlocked_layers(self.network_interface)
 			.find(|layer| !self.network_interface.is_artboard(&layer.to_node(), &[]))
 			.map(|layer| metadata.transform_to_viewport(layer))