Add the Record wire type, record registry rows, lift and extract adapters, and executor stack reservation

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

@@ -181,6 +181,7 @@ where
 			return Err("Output node not found in executor".into());
 		};
 		let mut arena = self.arena.lock().unwrap_or_else(PoisonError::into_inner);
+		core_types::record::stack::reserve(self.tree.stack_need());
 		let result = eval_root(&mut arena, &self.runtime, &input, |ctx| match TaggedValue::from_edge(handle.duplicate(), ctx) {
 			Ok(poll) => poll.map(Ok),
 			Err(error) => GPoll::Final(Err(error)),
@@ -469,6 +470,14 @@ impl BorrowTree {
 	pub fn source_map(&self) -> &HashMap<Path, (NodeId, NodeTypes)> {
 		&self.source_map
 	}
+
+	/// The record-stack bound of an evaluation: the sum over all node frames.
+	pub fn stack_need(&self) -> usize {
+		self.nodes
+			.values()
+			.map(|(handle, _)| handle.layout().map_or(0, |layout| layout.size.next_multiple_of(8)))
+			.sum()
+	}
 }
 
 #[cfg(test)]
@@ -596,6 +605,40 @@ mod test {
 		assert!(matches!(result, Some(GPoll::Final(_))), "the palette must evaluate through the spliced lend, got {result:?}");
 	}
 
+	#[test]
+	fn a_record_wire_types_wires_and_evaluates_through_the_registry() {
+		let network = ProtoNetwork {
+			inputs: vec![],
+			output: NodeId(2),
+			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), proto_node("core_types::record::RecordExtractNode", vec![NodeId(1)])),
+			],
+		};
+
+		let executor = DynamicExecutor::new(network).unwrap();
+		let lift = executor.tree().get(NodeId(1)).unwrap();
+		assert_eq!(lift.ty(), &core_types::registry::record_edge_type::<f64>());
+		assert!(lift.layout().is_some());
+		assert_eq!((&executor).execute(()).unwrap(), GPoll::Final(TaggedValue::F64(7.)));
+	}
+
+	#[test]
+	fn a_lift_adapter_is_spliced_between_a_plain_producer_and_a_record_consumer() {
+		let network = ProtoNetwork {
+			inputs: vec![],
+			output: NodeId(1),
+			nodes: vec![
+				(NodeId(0), ProtoNode::value(ConstructionArgs::Value(TaggedValue::F64(7.).into()), vec![])),
+				(NodeId(1), proto_node("core_types::record::RecordExtractNode", vec![NodeId(0)])),
+			],
+		};
+
+		let executor = DynamicExecutor::new(network).unwrap();
+		assert_eq!((&executor).execute(()).unwrap(), GPoll::Final(TaggedValue::F64(7.)));
+	}
+
 	#[test]
 	fn a_clone_out_adapter_is_spliced_between_a_lending_producer_and_an_owned_consumer() {
 		let network = ProtoNetwork {

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

@@ -20,7 +20,7 @@ use graphene_std::transform::Footprint;
 use graphene_std::uuid::NodeId;
 use graphene_std::vector::Vector;
 use graphene_std::{Artboard, Context, Graphic, ProtoNodeIdentifier, SourceId, concrete, fn_type};
-use node_registry_macros::{async_node, clone_node, convert_node, frame_memo_node, into_node, lend_node};
+use node_registry_macros::{async_node, clone_node, convert_node, frame_memo_node, into_node, lend_node, record_extract_node, record_lift_node};
 use std::collections::HashMap;
 #[cfg(feature = "gpu")]
 use wgpu_executor::WgpuExecutorHandle;
@@ -374,6 +374,8 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, Vec<RegistryEntry>> {
 		#[cfg(target_family = "wasm")]
 		frame_memo_node!(CanvasHandle),
 		lend_node!(f64),
+		record_lift_node!(f64),
+		record_extract_node!(f64),
 		clone_node!(f64),
 		frame_memo_node!(f64),
 		lend_node!(f32),
@@ -769,6 +771,44 @@ mod node_registry_macros {
 		};
 	}
 
+	macro_rules! record_lift_node {
+		($type:ty) => {
+			(
+				ProtoNodeIdentifier::new("core_types::record::RecordLiftNode"),
+				RegistryEntry {
+					io: NodeIOTypes::new(concrete!(Context), core_types::registry::record_type::<$type>(), vec![fn_type!(Context, $type)]),
+					constructor: |inputs| {
+						if inputs.len() != 1 {
+							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>()?);
+						Ok(EdgeHandle::new_record::<$type>(std::sync::Arc::new(node) as std::sync::Arc<core_types::registry::ErasedRecordNode>))
+					},
+				},
+			)
+		};
+	}
+
+	macro_rules! record_extract_node {
+		($type:ty) => {
+			(
+				ProtoNodeIdentifier::new("core_types::record::RecordExtractNode"),
+				RegistryEntry {
+					io: NodeIOTypes::new(concrete!(Context), concrete!($type), vec![core_types::registry::record_edge_type::<$type>()]),
+					constructor: |inputs| {
+						if inputs.len() != 1 {
+							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>()?);
+						Ok(EdgeHandle::new(std::sync::Arc::new(node) as std::sync::Arc<ErasedNode<$type>>))
+					},
+				},
+			)
+		};
+	}
+
 	macro_rules! clone_node {
 		($type:ty) => {
 			(
@@ -813,4 +853,6 @@ mod node_registry_macros {
 	pub(crate) use frame_memo_node;
 	pub(crate) use into_node;
 	pub(crate) use lend_node;
+	pub(crate) use record_extract_node;
+	pub(crate) use record_lift_node;
 }