Switch to new async execution model

desktop/src/render/state.rs

@@ -228,7 +228,7 @@ impl RenderState {
 			return;
 		};
 		let size = glam::UVec2::new(viewport_texture.width(), viewport_texture.height());
-		let result = futures::executor::block_on(self.executor.render_vello_scene(&scene, size, &Default::default(), None));
+		let result = self.executor.render_vello_scene(&scene, size, &Default::default(), None);
 		match result {
 			Ok(texture) => {
 				self.overlays_texture = Some(texture.into());

document/graph-storage/src/tests/round_trip.rs

@@ -246,10 +246,10 @@ fn test_nested_network_flattening() {
 #[test]
 fn test_metadata_preservation() {
 	// Create a network with nodes that have non-default metadata
-	let context_features = ContextDependencies {
-		extract: core_types::context::ContextFeatures::FOOTPRINT | core_types::context::ContextFeatures::REAL_TIME,
-		..Default::default()
-	};
+	let context_features = ContextDependencies::new(
+		core_types::context::ContextFeatures::FOOTPRINT | core_types::context::ContextFeatures::REAL_TIME,
+		core_types::context::ContextFeatures::empty(),
+	);
 
 	let network = NodeNetwork {
 		exports: vec![NodeInput::node(NodeId(1), 0)],

editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs

@@ -14,7 +14,7 @@ use graphene_std::memo::IORecord;
 use graphene_std::raster_types::{CPU, GPU, Raster};
 use graphene_std::vector::Vector;
 use graphene_std::vector::style::{FillChoice, FillChoiceUI, GradientSpreadMethod, GradientType};
-use graphene_std::{Artboard, Color, Context, Graphic};
+use graphene_std::{Artboard, Color, CtxSnapshot, Graphic};
 use std::any::Any;
 use std::sync::Arc;
 
@@ -167,7 +167,7 @@ macro_rules! generate_layout_downcast {
 	($introspected_data:expr, $data:expr, [ $($ty:ty),* $(,)? ]) => {
 		if false { None }
 		$(
-			else if let Some(io) = $introspected_data.downcast_ref::<IORecord<Context, $ty>>() {
+			else if let Some(io) = $introspected_data.downcast_ref::<IORecord<CtxSnapshot, $ty>>() {
 				Some(io.output.layout_with_breadcrumb($data))
 			}
 		)*
@@ -178,7 +178,7 @@ macro_rules! generate_layout_downcast {
 fn generate_layout(introspected_data: &Arc<dyn std::any::Any + Send + Sync + 'static>, data: &mut LayoutData) -> Option<Vec<LayoutGroup>> {
 	// `List<NodeId>` is interpreted as a path (e.g. the value produced by `path_of_subgraph`), shown as a
 	// `List` where each item's NodeId resolves against the prefix made up of the items above it.
-	if let Some(io) = introspected_data.downcast_ref::<IORecord<Context, List<NodeId>>>() {
+	if let Some(io) = introspected_data.downcast_ref::<IORecord<CtxSnapshot, List<NodeId>>>() {
 		return Some(table_node_id_path_layout_with_breadcrumb(&io.output, data));
 	}
 	generate_layout_downcast!(introspected_data, data, [

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

@@ -919,7 +919,12 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 						exports: vec![NodeInput::node(NodeId(1), 0)],
 						nodes: [
 							DocumentNode {
-								inputs: vec![NodeInput::value(TaggedValue::None, false), NodeInput::import(concrete!(String), 1)],
+								inputs: vec![
+									NodeInput::value(TaggedValue::None, false),
+									NodeInput::import(concrete!(String), 1),
+									NodeInput::scope("graphene_std::runtime::RuntimeNode"),
+									NodeInput::Reflection(graph_craft::document::DocumentNodeMetadata::SourceId),
+								],
 								implementation: DocumentNodeImplementation::ProtoNode(platform_application_io::load_resource::IDENTIFIER),
 								..Default::default()
 							},
@@ -994,7 +999,13 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 								..Default::default()
 							},
 							DocumentNode {
-								inputs: vec![NodeInput::import(generic!(T), 0), NodeInput::import(concrete!(Footprint), 1), NodeInput::node(NodeId(1), 0)],
+								inputs: vec![
+									NodeInput::import(generic!(T), 0),
+									NodeInput::import(concrete!(Footprint), 1),
+									NodeInput::node(NodeId(1), 0),
+									NodeInput::scope("graphene_std::runtime::RuntimeNode"),
+									NodeInput::Reflection(graph_craft::document::DocumentNodeMetadata::SourceId),
+								],
 								implementation: DocumentNodeImplementation::ProtoNode(platform_application_io::rasterize::IDENTIFIER),
 								..Default::default()
 							},

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

@@ -29,7 +29,7 @@ pub(super) fn post_process_nodes(custom: Vec<DocumentNodeDefinition>) -> HashMap
 	// fallback when deriving `call_argument` so it reflects the impls actually registered, which will usually be `Context`.
 	let extended_node_registry = &*interpreted_executor::node_registry::NODE_REGISTRY;
 	let node_registry = NODE_REGISTRY.lock().unwrap();
-	let empty_implementations: Vec<(NodeConstructor, NodeIOTypes)> = Vec::new();
+	let empty_implementations: Vec<RegistryEntry> = Vec::new();
 	let context_type = concrete!(Context);
 	for (id, metadata) in NODE_METADATA.lock().unwrap().iter() {
 		let identifier = DefinitionIdentifier::ProtoNode(id.clone());
@@ -48,12 +48,12 @@ pub(super) fn post_process_nodes(custom: Vec<DocumentNodeDefinition>) -> HashMap
 
 		let implementations = node_registry.get(id).unwrap_or(&empty_implementations);
 
-		let first_node_io = implementations.first().map(|(_, node_io)| node_io).unwrap_or(const { &NodeIOTypes::empty() });
+		let first_node_io = implementations.first().map(|entry| &entry.io).unwrap_or(const { &NodeIOTypes::empty() });
 
 		let call_arguments: Vec<&Type> = if !implementations.is_empty() {
-			implementations.iter().map(|(_, io)| &io.call_argument).collect()
+			implementations.iter().map(|entry| &entry.io.call_argument).collect()
 		} else if let Some(impls) = extended_node_registry.get(id) {
-			impls.keys().map(|io| &io.call_argument).collect()
+			impls.iter().map(|entry| &entry.io.call_argument).collect()
 		} else {
 			Vec::new()
 		};

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

@@ -2360,7 +2360,7 @@ pub(crate) fn generate_node_properties(node_id: NodeId, context: &mut NodeProper
 							return Vec::new();
 						};
 
-						let mut input_types = implementations.keys().filter_map(|item| item.inputs.get(input_index)).collect::<Vec<_>>();
+						let mut input_types = implementations.iter().filter_map(|entry| entry.io.inputs.get(input_index)).collect::<Vec<_>>();
 						input_types.sort_by_key(|ty| ty.type_name());
 						let input_type = input_types.first().cloned();
 

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

@@ -253,8 +253,9 @@ impl NodeNetworkInterface {
 				};
 				let number_of_inputs = self.number_of_inputs(node_id, network_path);
 				implementations
-					.keys()
-					.filter_map(|node_io| {
+					.iter()
+					.filter_map(|entry| {
+						let node_io = &entry.io;
 						// Check if this NodeIOTypes implementation is valid for the other inputs
 						let valid_implementation = (0..number_of_inputs).filter(|iterator_index| iterator_index != input_index).all(|iterator_index| {
 							let input_type = self.input_type_not_invalid(&InputConnector::node(*node_id, iterator_index), network_path);
@@ -293,8 +294,9 @@ impl NodeNetworkInterface {
 						let valid_output_types = self.valid_output_types(&OutputConnector::node(*node_id, 0), network_path);
 
 						implementations
-							.keys()
-							.filter_map(|node_io| {
+							.iter()
+							.filter_map(|entry| {
+								let node_io = &entry.io;
 								if !valid_output_types.iter().any(|output_type| output_type.nested_type() == node_io.return_value.nested_type()) {
 									return None;
 								}
@@ -323,7 +325,7 @@ impl NodeNetworkInterface {
 							log::error!("Protonode {render_node:?} not found in registry");
 							return Vec::new();
 						};
-						implementations.keys().map(|types| types.inputs[1].clone()).collect()
+						implementations.iter().map(|entry| entry.io.inputs[1].clone()).collect()
 					}
 				}
 			}

editor/src/node_graph_executor.rs

@@ -15,7 +15,7 @@ use graphene_std::raster::{CPU, Raster};
 use graphene_std::renderer::{RenderMetadata, graphic_list_bounding_box};
 use graphene_std::transform::Footprint;
 use graphene_std::vector::{Vector, graphic_types};
-use graphene_std::{ATTR_TRANSFORM, Context, Graphic, NodeInputDecleration};
+use graphene_std::{ATTR_TRANSFORM, CtxSnapshot, Graphic, NodeInputDecleration};
 use interpreted_executor::dynamic_executor::ResolvedDocumentNodeTypesDelta;
 use std::any::Any;
 use std::sync::Arc;
@@ -26,7 +26,7 @@ pub use runtime_io::NodeRuntimeIO;
 mod runtime;
 pub use runtime::*;
 
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ExecutionRequest {
 	execution_id: u64,
 	render_config: RenderConfig,
@@ -375,10 +375,12 @@ impl NodeGraphExecutor {
 						}
 					}
 
-					let Some((queued_execution_id, execution_context)) = self.futures.pop_front() else {
+					let execution_context = if self.futures.front().is_some_and(|&(queued_execution_id, _)| queued_execution_id == execution_id) {
+						let (_, execution_context) = self.futures.pop_front().expect("front was just matched");
+						execution_context
+					} else {
 						panic!("InvalidGenerationId")
 					};
-					assert_eq!(queued_execution_id, execution_id, "Missmatch in execution id");
 
 					// TODO: Eventually remove this document upgrade code
 					// Gradient-migration measurement runs only read back the fill's evaluated geometry; they never render to the artwork.
@@ -892,7 +894,7 @@ fn introspected_output<T: Clone + Send + Sync + 'static>(data: &Arc<dyn Any + Se
 	if let Some(io) = data.downcast_ref::<IORecord<Footprint, T>>() {
 		return Some(io.output.clone());
 	}
-	if let Some(io) = data.downcast_ref::<IORecord<Context, T>>() {
+	if let Some(io) = data.downcast_ref::<IORecord<CtxSnapshot, T>>() {
 		return Some(io.output.clone());
 	}
 	None
@@ -911,7 +913,7 @@ mod test {
 	use crate::test_utils::test_prelude::{self, NodeGraphLayer};
 	use graph_craft::ProtoNodeIdentifier;
 	use graph_craft::document::NodeNetwork;
-	use graphene_std::Context;
+	use graphene_std::CtxSnapshot;
 	use graphene_std::NodeInputDecleration;
 	use graphene_std::memo::IORecord;
 	use test_prelude::LayerNodeIdentifier;
@@ -979,7 +981,7 @@ mod test {
 				Some(x.output.clone())
 			} else if let Some(x) = dynamic.downcast_ref::<IORecord<Footprint, Input::Result>>() {
 				Some(x.output.clone())
-			} else if let Some(x) = dynamic.downcast_ref::<IORecord<Context, Input::Result>>() {
+			} else if let Some(x) = dynamic.downcast_ref::<IORecord<CtxSnapshot, Input::Result>>() {
 				Some(x.output.clone())
 			} else {
 				warn!("cannot downcast type for introspection");