Add per-field erased-read glue, the record monitor with introspection capture, and rename record constructors to new

node-graph/interpreted-executor/src/dynamic_executor.rs

@@ -145,8 +145,14 @@ impl DynamicExecutor {
 	}
 
 	/// Calls the `Node::serialize` for that specific node, returning for example the cached value for a monitor node. The node path must match the document node path.
+	/// A record capture materializes here against the arena, inside the introspection window.
 	pub fn introspect(&self, node_path: &[NodeId]) -> Result<Arc<dyn std::any::Any + Send + Sync + 'static>, IntrospectError> {
-		self.tree.introspect(node_path)
+		let result = self.tree.introspect(node_path)?;
+		if let Some(capture) = result.downcast_ref::<core_types::record::RecordCapture>() {
+			let arena = self.arena.lock().unwrap_or_else(PoisonError::into_inner);
+			return capture.materialize(&arena).map(|fields| Arc::new(fields) as Arc<_>).ok_or(IntrospectError::NoData);
+		}
+		Ok(result)
 	}
 
 	pub fn input_type(&self) -> Option<Type> {
@@ -624,6 +630,30 @@ mod test {
 		assert_eq!((&executor).execute(()).unwrap(), GPoll::Final(TaggedValue::F64(7.)));
 	}
 
+	#[test]
+	fn a_record_monitor_row_forwards_and_introspects_through_the_executor() {
+		let mut monitor = proto_node("graphene_core::memo::MonitorNode", vec![NodeId(1)]);
+		monitor.original_location.path = Some(vec![NodeId(9)]);
+		let network = ProtoNetwork {
+			inputs: vec![],
+			output: NodeId(3),
+			nodes: vec![
+				(NodeId(0), ProtoNode::value(ConstructionArgs::Value(TaggedValue::F64(7.).into()), vec![])),
+				(NodeId(1), proto_node("core_types::record::RecordLiftNode", vec![NodeId(0)])),
+				(NodeId(2), monitor),
+				(NodeId(3), proto_node("core_types::record::RecordExtractNode", vec![NodeId(2)])),
+			],
+		};
+
+		let executor = DynamicExecutor::new(network).unwrap();
+		assert_eq!((&executor).execute(()).unwrap(), GPoll::Final(TaggedValue::F64(7.)));
+		let fields = executor.introspect(&[NodeId(9)]).unwrap();
+		let fields = fields
+			.downcast_ref::<Vec<(&'static str, Box<dyn core_types::list::AnyAttributeValue>)>>()
+			.expect("a record capture materializes to its fields");
+		assert!(fields.is_empty(), "an element-only record has no attribute fields");
+	}
+
 	#[test]
 	fn a_lift_adapter_is_spliced_between_a_plain_producer_and_a_record_consumer() {
 		let network = ProtoNetwork {

node-graph/interpreted-executor/src/node_registry.rs

@@ -376,6 +376,30 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, Vec<RegistryEntry>> {
 		lend_node!(f64),
 		record_lift_node!(f64),
 		record_extract_node!(f64),
+		(
+			ProtoNodeIdentifier::new("graphene_core::memo::MonitorNode"),
+			RegistryEntry {
+				io: NodeIOTypes::new(
+					concrete!(Context),
+					core_types::Type::Record(Box::new(core_types::Type::Generic(std::borrow::Cow::Borrowed("T")))),
+					vec![core_types::registry::generic_record_edge_type("T")],
+				),
+				constructor: |inputs| {
+					if inputs.len() != 1 {
+						return Err(ConstructionError::Arity { expected: 1, got: inputs.len() });
+					}
+					let mut inputs = inputs.into_iter();
+					let handle = inputs.next().unwrap();
+					let ty = handle.ty().clone();
+					let Some(layout) = handle.layout().cloned() else {
+						return Err(ConstructionError::MissingLayout);
+					};
+					let edge = handle.downcast_erased::<core_types::registry::ErasedRecordNode>(ty.clone())?;
+					let node = core_types::record::RecordMonitor::new(edge, &layout);
+					Ok(EdgeHandle::new_erased(std::sync::Arc::new(node) as std::sync::Arc<core_types::registry::ErasedRecordNode>, ty))
+				},
+			},
+		),
 		clone_node!(f64),
 		frame_memo_node!(f64),
 		lend_node!(f32),
@@ -782,7 +806,7 @@ mod node_registry_macros {
 							return Err(ConstructionError::Arity { expected: 1, got: inputs.len() });
 						}
 						let mut inputs = inputs.into_iter();
-						let node = core_types::record::RecordLift::<$type, _>::wire(inputs.next().unwrap().downcast::<$type>()?);
+						let node = core_types::record::RecordLift::<$type, _>::new(inputs.next().unwrap().downcast::<$type>()?);
 						Ok(EdgeHandle::new_record::<$type>(std::sync::Arc::new(node) as std::sync::Arc<core_types::registry::ErasedRecordNode>))
 					},
 				},
@@ -801,7 +825,7 @@ mod node_registry_macros {
 							return Err(ConstructionError::Arity { expected: 1, got: inputs.len() });
 						}
 						let mut inputs = inputs.into_iter();
-						let node = core_types::record::RecordExtract::<$type, _>::wire(inputs.next().unwrap().downcast_record::<$type>()?);
+						let node = core_types::record::RecordExtract::<$type, _>::new(inputs.next().unwrap().downcast_record::<$type>()?);
 						Ok(EdgeHandle::new(std::sync::Arc::new(node) as std::sync::Arc<ErasedNode<$type>>))
 					},
 				},