Implement context modification node insertion

Author: TrueDoctor

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

@@ -15,7 +15,7 @@ use graphene_core::uuid::NodeId;
 use graphene_core::vector::Vector;
 use graphene_core::vector::style::Fill;
 use graphene_core::vector::style::GradientStops;
-use graphene_core::{Artboard, Color, Graphic, MemoHash, Node, Type};
+use graphene_core::{Artboard, Color, ContextFeatures, Graphic, MemoHash, Node, Type};
 use graphene_svg_renderer::RenderMetadata;
 use std::fmt::Display;
 use std::hash::Hash;
@@ -212,6 +212,7 @@ tagged_value! {
 	BrushStrokes(Vec<BrushStroke>),
 	BrushCache(BrushCache),
 	DocumentNode(DocumentNode),
+	ContextFeatures(ContextFeatures),
 	Curve(graphene_raster_nodes::curve::Curve),
 	Footprint(graphene_core::transform::Footprint),
 	VectorModification(Box<graphene_core::vector::VectorModification>),

node-graph/graph-craft/src/graphene_compiler.rs

@@ -17,7 +17,7 @@ impl Compiler {
 		let proto_networks = network.into_proto_networks();
 
 		proto_networks.map(move |mut proto_network| {
-			proto_network.resolve_inputs()?;
+			proto_network.insert_context_nullification_nodes()?;
 			proto_network.generate_stable_node_ids();
 			Ok(proto_network)
 		})

node-graph/graph-craft/src/proto.rs

@@ -1,3 +1,4 @@
+use crate::document::value::TaggedValue;
 use crate::document::{InlineRust, value};
 use crate::document::{NodeId, OriginalLocation};
 pub use graphene_core::registry::*;
@@ -296,15 +297,68 @@ impl ProtoNetwork {
 	/// Inserts context nullification nodes to optimize caching
 	/// This analysis is performed after topological sorting to ensure proper dependency tracking
 	pub fn insert_context_nullification_nodes(&mut self) -> Result<(), String> {
-		// TODO: Implement full context flow analysis with:
-		// 1. DFS traversal to track context feature requirements
-		// 2. Branch convergence analysis
-		// 3. Post-injection nullification
-		// 4. Insert ContextModificationNode instances where beneficial
+		// Perform topological sort once
+		self.reorder_ids()?;
+
 		let mut out_nodes = Vec::with_capacity(10);
 		self.find_context_dependencies(self.output, &mut out_nodes);
 		out_nodes.sort_by_key(|&(id, _)| id);
 
+		// TODO: use outwards edges tracked in original node location instead
+		// Collect outward edges once
+		let outwards_edges = self.collect_outwards_edges();
+
+		for (node_id, context_deps) in out_nodes {
+			let memo_node_id = NodeId(self.nodes.len() as u64);
+			let (_, node) = &self.nodes[node_id.0 as usize];
+			let path = node.original_location.path.clone();
+
+			self.nodes.push((
+				memo_node_id,
+				ProtoNode {
+					construction_args: ConstructionArgs::Nodes(vec![node_id]),
+					call_argument: concrete!(Context),
+					identifier: graphene_core::memo::memo::IDENTIFIER,
+					original_location: OriginalLocation {
+						path: path.clone(),
+						..Default::default()
+					},
+					..Default::default()
+				},
+			));
+
+			let nullification_value_node_id = NodeId(self.nodes.len() as u64);
+
+			self.nodes.push((
+				nullification_value_node_id,
+				ProtoNode {
+					construction_args: ConstructionArgs::Value(MemoHash::new(TaggedValue::ContextFeatures(context_deps))),
+					call_argument: concrete!(Context),
+					identifier: ProtoNodeIdentifier::new("graphene_core::value::ClonedNode"),
+					original_location: OriginalLocation {
+						path: path.clone(),
+						..Default::default()
+					},
+					..Default::default()
+				},
+			));
+			let nullification_node_id = NodeId(self.nodes.len() as u64);
+			self.nodes.push((
+				nullification_node_id,
+				ProtoNode {
+					construction_args: ConstructionArgs::Nodes(vec![memo_node_id, nullification_node_id]),
+					call_argument: concrete!(Context),
+					identifier: graphene_core::context_modification::context_modification::IDENTIFIER,
+					original_location: OriginalLocation {
+						path: path.clone(),
+						..Default::default()
+					},
+					..Default::default()
+				},
+			));
+			self.replace_node_id(&outwards_edges, node_id, nullification_node_id);
+		}
+
 		Ok(())
 	}
 
@@ -321,7 +375,7 @@ impl ProtoNetwork {
 		};
 
 		// Compute the dependencies for each branch and combine all of them
-		for &(node, _) in inputs {
+		for &node in inputs {
 			let branch = self.find_context_dependencies(node, out_nodes);
 			branch_dependencies.push(branch);
 			combined_deps |= branch;
@@ -338,7 +392,7 @@ impl ProtoNetwork {
 		let we_introduce_new_deps = !combined_deps.contains(new_deps);
 
 		// For diverging branches, we can add a cache node for all branches which don't reqire all dependencies
-		for (&(node, _), deps) in inputs.iter().zip(branch_dependencies.into_iter()) {
+		for (&node, deps) in inputs.iter().zip(branch_dependencies.into_iter()) {
 			if we_introduce_new_deps || deps != combined_deps {
 				out_nodes.push((node, deps));
 			}