Cut over to the graphene execution model

node-graph/nodes/gcore/src/animation.rs

@@ -1,6 +1,7 @@
+use core_types::gpoll::GPoll;
 use core_types::list::List;
 use core_types::transform::Footprint;
-use core_types::{CacheHash, CloneVarArgs, Color, Context, Ctx, ExtractAll, ExtractAnimationTime, ExtractPointerPosition, ExtractRealTime, OwnedContextImpl};
+use core_types::{CacheHash, Color, Context, Ctx, DeriveCtx, ExtractAnimationTime, ExtractPointerPosition, ExtractRealTime};
 use glam::{DAffine2, DVec2};
 use graphic_types::vector_types::GradientStops;
 use graphic_types::{Artboard, Graphic, Vector};
@@ -61,8 +62,8 @@ fn animation_time(
 }
 
 #[node_macro::node(category("Debug"))]
-async fn quantize_real_time<T>(
-	ctx: impl Ctx + ExtractAll + CloneVarArgs,
+fn quantize_real_time<T>(
+	ctx: impl Ctx + ExtractRealTime + DeriveCtx,
 	#[implementations(
 		Context -> bool,
 		Context -> u32,
@@ -84,11 +85,11 @@ async fn quantize_real_time<T>(
 		Context -> List<f64>,
 		Context -> (),
 	)]
-	value: impl Node<'n, Context<'static>, Output = T>,
+	value: impl Node<Context<'_>, Output = T>,
 	#[default(1)]
 	#[unit("sec")]
 	quantum: f64,
-) -> T {
+) -> GPoll<T> {
 	let time = ctx.try_real_time().unwrap_or_default();
 	let time = time / 1000.;
 	let mut quantized_time = (time * quantum.recip()).round() / quantum.recip();
@@ -96,13 +97,13 @@ async fn quantize_real_time<T>(
 		quantized_time = time;
 	}
 	let quantized_time = quantized_time * 1000.;
-	let new_context = OwnedContextImpl::from(ctx).with_real_time(quantized_time);
-	value.eval(Some(new_context.into())).await
+	let scope = ctx.scope().with_real_time(Some(quantized_time));
+	value.eval(&ctx.with_scope(&scope))
 }
 
 #[node_macro::node(category("Debug"))]
-async fn quantize_animation_time<T>(
-	ctx: impl Ctx + ExtractAll + CloneVarArgs,
+fn quantize_animation_time<T>(
+	ctx: impl Ctx + ExtractAnimationTime + DeriveCtx,
 	#[implementations(
 		Context -> bool,
 		Context -> u32,
@@ -124,18 +125,18 @@ async fn quantize_animation_time<T>(
 		Context -> List<f64>,
 		Context -> (),
 	)]
-	value: impl Node<'n, Context<'static>, Output = T>,
+	value: impl Node<Context<'_>, Output = T>,
 	#[default(1)]
 	#[unit("sec")]
 	quantum: f64,
-) -> T {
+) -> GPoll<T> {
 	let time = ctx.try_animation_time().unwrap_or_default();
 	let mut quantized_time = (time * quantum.recip()).round() / quantum.recip();
 	if !quantized_time.is_finite() {
 		quantized_time = time;
 	}
-	let new_context = OwnedContextImpl::from(ctx).with_animation_time(quantized_time);
-	value.eval(Some(new_context.into())).await
+	let scope = ctx.scope().with_animation_time(Some(quantized_time));
+	value.eval(&ctx.with_scope(&scope))
 }
 
 /// Produces the current position of the user's pointer within the document canvas.

node-graph/nodes/gcore/src/context.rs

@@ -47,7 +47,7 @@ fn read_gradient(ctx: impl Ctx + ExtractVarArgs) -> List<GradientStops> {
 }
 
 #[node_macro::node(category("Context"), path(core_types::vector))]
-async fn read_position(
+fn read_position(
 	ctx: impl Ctx + ExtractPosition,
 	_primary: (),
 	/// The number of nested loops to traverse outwards (from the innermost loop) to get the position from. The most upstream loop is level 0, and downstream loops add levels.
@@ -64,7 +64,7 @@ async fn read_position(
 ///
 /// Nested loops can enable 2D or higher-dimensional iteration by using the *Loop Level* parameter to read the index from outer levels of loops.
 #[node_macro::node(category("Context"), path(core_types::vector))]
-async fn read_index(
+fn read_index(
 	ctx: impl Ctx + ExtractIndex,
 	_primary: (),
 	/// The number of nested loops to traverse outwards (from the innermost loop) to get the index from. The most upstream loop is level 0, and downstream loops add levels.

node-graph/nodes/gcore/src/context_modification.rs

@@ -1,9 +1,10 @@
 use core::f64;
-use core_types::context::{CloneVarArgs, Context, ContextFeatures, Ctx, ExtractAll};
+use core_types::Color;
+use core_types::context::{Context, ContextModification, Ctx, DeriveCtx};
+use core_types::gpoll::GPoll;
 use core_types::list::{AttributeDyn, AttributeValueDyn, List, ListDyn};
 use core_types::transform::Footprint;
 use core_types::uuid::NodeId;
-use core_types::{Color, OwnedContextImpl};
 use glam::{DAffine2, DVec2};
 use graphic_types::vector_types::GradientStops;
 use graphic_types::{Artboard, Graphic, Vector};
@@ -12,8 +13,8 @@ use raster_types::{CPU, GPU, Raster};
 /// Filters out what should be unused components of the context based on the specified requirements.
 /// This node is inserted by the compiler to "zero out" unused context components.
 #[node_macro::node(category(""))]
-async fn context_modification<T>(
-	ctx: impl Ctx + CloneVarArgs + ExtractAll,
+fn context_modification<T>(
+	ctx: impl Ctx + DeriveCtx,
 	/// The data to pass through, evaluated with the stripped down context.
 	#[implementations(
 		Context -> (),
@@ -41,80 +42,10 @@ async fn context_modification<T>(
 		Context -> AttributeValueDyn,
 		Context -> ListDyn,
 	)]
-	value: impl Node<Context<'static>, Output = T>,
+	value: impl Node<Context<'_>, Output = T>,
 	/// The parts of the context to keep when evaluating the input value. All other parts are nullified.
-	features_to_keep: ContextFeatures,
-) -> T {
-	let new_context = OwnedContextImpl::from_flags(ctx, features_to_keep);
-
-	value.eval(Some(new_context.into())).await
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	use core_types::graphene_hash::CacheHash;
-	use core_types::transform::Footprint;
-	use std::collections::hash_map::DefaultHasher;
-	use std::hash::Hasher;
-
-	/// Verifies that nullified context fields don't affect the cache hash — only the kept features matter.
-	#[test]
-	fn test_nullified_context_hash_stability() {
-		use core_types::Context;
-		use std::sync::Arc;
-
-		let original_ctx: Context = Some(Arc::new(
-			OwnedContextImpl::empty()
-				.with_footprint(Footprint::default())
-				.with_index(1)
-				.with_real_time(10.5)
-				.with_vararg(Box::new("test"))
-				.with_animation_time(20.25),
-		));
-
-		// A second context with different values for the nullified fields
-		let changed_ctx: Context = Some(Arc::new(
-			OwnedContextImpl::empty()
-				.with_footprint(Footprint::default())
-				.with_index(2)
-				.with_real_time(999.9)
-				.with_vararg(Box::new("test"))
-				.with_animation_time(888.8),
-		));
-
-		// Nullify everything — both should hash the same regardless of their field values
-		let features_to_keep = ContextFeatures::empty();
-		let nullified1 = OwnedContextImpl::from_flags(original_ctx.clone().unwrap(), features_to_keep);
-		let nullified2 = OwnedContextImpl::from_flags(changed_ctx.clone().unwrap(), features_to_keep);
-
-		let mut hasher1 = DefaultHasher::new();
-		nullified1.cache_hash(&mut hasher1);
-
-		let mut hasher2 = DefaultHasher::new();
-		nullified2.cache_hash(&mut hasher2);
-
-		assert_eq!(
-			hasher1.finish(),
-			hasher2.finish(),
-			"Hash of nullified context should remain stable regardless of input changes when features are nullified"
-		);
-
-		// Keep only footprint and varargs — both have the same footprint and vararg, so hash should still match
-		let partial_features = ContextFeatures::FOOTPRINT | ContextFeatures::VARARGS;
-		let partial1 = OwnedContextImpl::from_flags(original_ctx.clone().unwrap(), partial_features);
-		let partial2 = OwnedContextImpl::from_flags(changed_ctx.clone().unwrap(), partial_features);
-
-		let mut hasher3 = DefaultHasher::new();
-		partial1.cache_hash(&mut hasher3);
-
-		let mut hasher4 = DefaultHasher::new();
-		partial2.cache_hash(&mut hasher4);
-
-		assert_eq!(
-			hasher3.finish(),
-			hasher4.finish(),
-			"Hash should be stable when keeping only footprint and varargs and their values are the same"
-		);
-	}
+	modification: ContextModification,
+) -> GPoll<T> {
+	let scope = ctx.scope().nullified(modification.features, Some(&modification.sources));
+	value.eval(&ctx.nullified(modification.features, &scope))
 }

node-graph/nodes/gcore/src/memo.rs

@@ -1,54 +1,265 @@
-use core_types::WasmNotSend;
+use core_types::arena::{Arena, ArenaCell};
+use core_types::context::{Ctx, CtxSnapshot, DeriveCtx, ExtractAll};
+use core_types::frame_table::{FrameTable, Lookup};
+use core_types::gpoll::{Extent, Finality, GPoll, Interrupt};
 use core_types::graphene_hash::CacheHash;
 use core_types::memo::*;
-use std::hash::DefaultHasher;
-use std::hash::Hasher;
+use core_types::node::Node;
+use core_types::registry::cache_key;
 use std::sync::Arc;
 use std::sync::Mutex;
 
 /// Helps speed up repeated renders in a computationally-heavy part of the node graph.
 ///
 /// Stores the last evaluated data that flowed through this node and immediately returns that data on subsequent renders if the context has not changed.
-#[node_macro::node(category("General"), path(graphene_core::memo), skip_impl)]
-async fn memoize<I: CacheHash + Send + 'n, T: Clone + WasmNotSend>(input: I, #[data] cache: Arc<Mutex<Option<(u64, T)>>>, content: impl Node<I, Output = T>) -> T {
-	// Caches the output of a given node called with a specific input.
-	//
-	// A cache miss occurs when the Option is None. In this case, the node evaluates the inner node and memoizes (stores) the result.
-	//
-	// A cache hit occurs when the Option is Some and has a stored hash matching the hash of the call argument. In this case, the node returns the cached value without re-evaluating the inner node.
-	//
-	// Currently, only one input-output pair is cached. Subsequent calls with different inputs will overwrite the previous cache.
-
-	let mut hasher = DefaultHasher::new();
-	input.cache_hash(&mut hasher);
-	let hash = hasher.finish();
-
-	if let Some(data) = cache.lock().as_ref().unwrap().as_ref().and_then(|data| (data.0 == hash).then_some(data.1.clone())) {
-		return data;
+#[node_macro::node(category("General"), path(graphene_core::memo), skip_impl, extent(memoize_extent))]
+fn memoize<I: CacheHash, T: Clone>(input: I, #[data] cache: Arc<Mutex<Option<(u64, T, Finality)>>>, content: impl Node<I, Output = T>) -> GPoll<T> {
+	let key = cache_key(&input);
+	if let Some((hash, value, finality)) = cache.lock().unwrap().as_ref()
+		&& *hash == key
+	{
+		return match finality {
+			Finality::AllFinal => GPoll::Final(value.clone()),
+			Finality::Partial => GPoll::Partial(value.clone()),
+		};
 	}
-
-	let value = content.eval(input).await;
-	*cache.lock().unwrap() = Some((hash, value.clone()));
-	value
+	let result = content.eval(input);
+	match &result {
+		GPoll::Final(value) => *cache.lock().unwrap() = Some((key, value.clone(), Finality::AllFinal)),
+		GPoll::Partial(value) => *cache.lock().unwrap() = Some((key, value.clone(), Finality::Partial)),
+		GPoll::Pending | GPoll::Fallback(_) | GPoll::Error(_) => {}
+	}
+	result
 }
 
-type MonitorValue<I, T> = Arc<Mutex<Option<Arc<IORecord<I, T>>>>>;
+fn memoize_extent<C, T, NodeContent>(node: &MemoizeNode<T, NodeContent>, ctx: &C) -> GPoll<Extent>
+where
+	T: Clone,
+	NodeContent: Node<C, Output = T>,
+{
+	node.content.extent(ctx)
+}
+
+#[node_macro::node(category(""), path(graphene_core::memo), skip_impl, extent(frame_memo_extent))]
+fn frame_memo<'e, T: Clone + 'static>(ctx: impl Ctx + CacheHash + ExtractArena<'e>, #[data] cell: ArenaCell<FrameTable<T, 32>>, content: impl Node<Context<'_>, Output = T>) -> GPoll<&'e T> {
+	let arena = ctx.arena();
+	let table = match cell.load(arena) {
+		Some(table) => table,
+		None => match arena.alloc(FrameTable::new()) {
+			Some((table, weak)) => {
+				cell.store(weak);
+				table
+			}
+			None => return park(arena, content.eval(ctx)),
+		},
+	};
+	match table.lookup(cache_key(ctx)) {
+		Lookup::Hit(Finality::AllFinal, value) => GPoll::Final(value),
+		Lookup::Hit(Finality::Partial, value) => GPoll::Partial(value),
+		Lookup::Vacant(slot) => match content.eval(ctx) {
+			GPoll::Final(value) => GPoll::Final(slot.publish(value, Finality::AllFinal)),
+			GPoll::Partial(value) => GPoll::Partial(slot.publish(value, Finality::Partial)),
+			unpublishable => {
+				slot.release();
+				park(arena, unpublishable)
+			}
+		},
+		Lookup::Full => park(arena, content.eval(ctx)),
+	}
+}
+
+fn frame_memo_extent<C, T, NodeContent>(node: &FrameMemoNode<T, NodeContent>, ctx: &C) -> GPoll<Extent>
+where
+	T: Clone + 'static,
+	NodeContent: Node<C, Output = T>,
+{
+	node.content.extent(ctx)
+}
+
+pub fn park<T>(arena: &Arena, result: GPoll<T>) -> GPoll<&T> {
+	match result {
+		GPoll::Final(value) => match arena.alloc(value) {
+			Some((parked, _)) => GPoll::Final(parked),
+			None => GPoll::arena_exhausted(),
+		},
+		GPoll::Partial(value) => match arena.alloc(value) {
+			Some((parked, _)) => GPoll::Partial(parked),
+			None => GPoll::arena_exhausted(),
+		},
+		GPoll::Fallback(boxed) => {
+			let (value, error) = *boxed;
+			match arena.alloc(value) {
+				Some((parked, _)) => GPoll::Fallback(Box::new((parked, error))),
+				None => GPoll::arena_exhausted(),
+			}
+		}
+		GPoll::Pending => GPoll::Pending,
+		GPoll::Error(error) => GPoll::Error(error),
+	}
+}
+
+type MonitorValue<T> = Arc<Mutex<Option<Arc<IORecord<CtxSnapshot, T>>>>>;
 
 /// The Monitor node is used by the editor to access the data flowing through it.
 #[node_macro::node(category(""), path(graphene_core::memo), serialize(serialize_monitor), properties("monitor_properties"), skip_impl)]
-async fn monitor<I: Clone + 'static + Send + Sync, T: Clone + 'static + Send + Sync>(
-	input: I,
+fn monitor<T: Clone + 'static + Send + Sync>(
+	ctx: impl Ctx + DeriveCtx + ExtractAll,
 	#[allow(clippy::type_complexity)]
 	#[data]
-	io: MonitorValue<I, T>,
-	content: impl Node<I, Output = T>,
-) -> T {
-	let output = content.eval(input.clone()).await;
-	*io.lock().unwrap() = Some(Arc::new(IORecord { input, output: output.clone() }));
-	output
+	io: MonitorValue<T>,
+	content: impl Node<Context<'_>, Output = T>,
+) -> Result<T, Interrupt> {
+	let output = content.eval(&ctx.derived())?;
+	*io.lock().unwrap() = Some(Arc::new(IORecord {
+		input: CtxSnapshot::capture(ctx),
+		output: output.clone(),
+	}));
+	Ok(output)
 }
 
-fn serialize_monitor<I: Clone + 'static + Send + Sync, T: Clone + 'static + Send + Sync>(io: &MonitorValue<I, T>) -> Option<Arc<dyn std::any::Any + Send + Sync>> {
+fn serialize_monitor<T: Clone + 'static + Send + Sync>(io: &MonitorValue<T>) -> Option<Arc<dyn std::any::Any + Send + Sync>> {
 	let io = io.lock().unwrap();
 	io.as_ref().map(|output| output.clone() as Arc<dyn std::any::Any + Send + Sync>)
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use core_types::SourceId;
+	use core_types::Type;
+	use core_types::concrete;
+	use core_types::context::{ContextImpl, EvalScope};
+	use core_types::registry::{EdgeHandle, ErasedLendNode, ErasedNode};
+	use std::sync::atomic::{AtomicU32, Ordering};
+
+	struct CountingNode(AtomicU32);
+
+	impl<Input> Node<Input> for CountingNode {
+		type Output = u32;
+
+		fn eval(&self, _input: &Input) -> GPoll<u32> {
+			GPoll::Final(self.0.fetch_add(1, Ordering::Relaxed) + 1)
+		}
+	}
+
+	struct PartialCountingNode(AtomicU32);
+
+	impl<Input> Node<Input> for PartialCountingNode {
+		type Output = u32;
+
+		fn eval(&self, _input: &Input) -> GPoll<u32> {
+			GPoll::Partial(self.0.fetch_add(1, Ordering::Relaxed) + 1)
+		}
+	}
+
+	struct ValueNode<T>(T);
+
+	impl<T: Clone, Input> Node<Input> for ValueNode<T> {
+		type Output = T;
+
+		fn eval(&self, _input: &Input) -> GPoll<T> {
+			GPoll::Final(self.0.clone())
+		}
+	}
+
+	fn scope_fixture<'a>(generations: &'a [(SourceId, u64)], arena: &'a Arena) -> EvalScope<'a> {
+		EvalScope::new(Some(0.5), None, None, generations, arena)
+	}
+
+	#[test]
+	fn monitor_serialize_exposes_the_io_record_through_the_edge() {
+		let arena = Arena::new(1024);
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let handle = EdgeHandle::new(Arc::new(MonitorNode::new(ValueNode(11u32))) as Arc<ErasedNode<u32>>);
+		assert!(handle.serialize().is_none(), "no record before the first eval");
+
+		let edge = handle.duplicate().downcast::<u32>().unwrap();
+		assert_eq!(edge.eval(&ctx), GPoll::Final(11));
+
+		let record = handle.serialize().expect("the eval landed a record");
+		let record = record.downcast_ref::<IORecord<CtxSnapshot, u32>>().expect("the record is the monitor io");
+		assert_eq!(record.output, 11);
+	}
+
+	#[test]
+	fn memoize_caches_across_evals() {
+		let arena = Arena::new(1024);
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let memoized = MemoizeNode::new(CountingNode(AtomicU32::new(0)));
+
+		assert_eq!(memoized.eval(&ctx), GPoll::Final(1));
+		assert_eq!(memoized.eval(&ctx), GPoll::Final(1));
+	}
+
+	#[test]
+	fn memo_invalidates_on_generation_bump() {
+		let arena = Arena::new(1024);
+		let source: SourceId = 7;
+		let before = [(source, 1)];
+		let after = [(source, 2)];
+		let scope_before = scope_fixture(&before, &arena);
+		let scope_after = scope_fixture(&after, &arena);
+
+		let memoized = MemoizeNode::new(CountingNode(AtomicU32::new(0)));
+
+		assert_eq!(memoized.eval(&ContextImpl::root(&scope_before)), GPoll::Final(1));
+		assert_eq!(memoized.eval(&ContextImpl::root(&scope_before)), GPoll::Final(1));
+		assert_eq!(memoized.eval(&ContextImpl::root(&scope_after)), GPoll::Final(2));
+	}
+
+	#[test]
+	fn memo_replays_partiality_on_hit() {
+		let arena = Arena::new(1024);
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let memoized = MemoizeNode::new(PartialCountingNode(AtomicU32::new(0)));
+
+		assert_eq!(memoized.eval(&ctx), GPoll::Partial(1));
+		assert_eq!(memoized.eval(&ctx), GPoll::Partial(1));
+	}
+
+	#[test]
+	fn memoized_edges_stack_and_rewire() {
+		let arena = Arena::new(1024);
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let edge = EdgeHandle::new(Arc::new(CountingNode(AtomicU32::new(0))) as Arc<ErasedNode<u32>>);
+		let memoized = EdgeHandle::new(Arc::new(MemoizeNode::new(edge.downcast::<u32>().unwrap())) as Arc<ErasedNode<u32>>);
+		let stacked = MemoizeNode::new(memoized.downcast::<u32>().unwrap());
+
+		assert_eq!(stacked.eval(&ctx), GPoll::Final(1));
+		assert_eq!(stacked.eval(&ctx), GPoll::Final(1));
+	}
+
+	#[test]
+	fn frame_memo_turns_an_owned_edge_into_a_lending_edge() {
+		let arena = Arena::new(4096);
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let edge = EdgeHandle::new(Arc::new(ValueNode("lent out".to_string())) as Arc<ErasedNode<String>>);
+		let lending = EdgeHandle::new_ref(Arc::new(FrameMemoNode::new(edge.downcast::<String>().unwrap())) as Arc<ErasedLendNode<String>>);
+		assert_eq!(*lending.ty(), core_types::registry::lend_edge_type::<String>());
+
+		let node = lending.downcast_lend::<String>().unwrap();
+		let GPoll::Final(first) = node.eval(&ctx) else {
+			panic!("lend must fill the frame table and lend");
+		};
+		let GPoll::Final(second) = node.eval(&ctx) else {
+			panic!("second eval must lend the published value");
+		};
+		assert_eq!(first, "lent out");
+		assert!(std::ptr::eq(first, second));
+	}
+}

node-graph/nodes/gcore/src/ops.rs

@@ -1,9 +1,8 @@
-use core_types::{Ctx, ExtractFootprint, ops::Convert, transform::Footprint};
+use core_types::ExtractAll;
+use core_types::runtime::SourceFuture;
+use core_types::{Ctx, ops::Convert, ops::ConvertAsync, transform::Footprint};
 use std::marker::PhantomData;
 
-// Re-export TypeNode from core-types for convenience
-pub use core_types::ops::TypeNode;
-
 /// Passes-through the input value without changing it. This is useful for rerouting wires for organization purposes.
 #[node_macro::node(category("General"), skip_impl)]
 fn passthrough<'i, T: 'i + Send>(_: impl Ctx, content: T) -> T {
@@ -11,13 +10,18 @@ fn passthrough<'i, T: 'i + Send>(_: impl Ctx, content: T) -> T {
 }
 
 #[node_macro::node(category(""), skip_impl)]
-fn into<'i, T: 'i + Send + Into<O>, O: 'i + Send>(_: impl Ctx, value: T, _out_ty: PhantomData<O>) -> O {
+fn into<T: Send + Into<O>, O: Send>(_: impl Ctx, value: T, #[data] _out_ty: PhantomData<O>) -> O {
 	value.into()
 }
 
 #[node_macro::node(category(""), skip_impl)]
-async fn convert<'i, T: 'i + Send + Convert<O, C>, O: 'i + Send, C: 'i + Send>(ctx: impl Ctx + ExtractFootprint, value: T, converter: C, _out_ty: PhantomData<O>) -> O {
-	value.convert(*ctx.try_footprint().unwrap_or(&Footprint::DEFAULT), converter).await
+fn convert<T: Send + Convert<O, C>, O: Send, C: Send>(ctx: impl Ctx + ExtractAll, value: T, converter: C, #[data] _out_ty: PhantomData<O>) -> O {
+	value.convert(*ctx.try_footprint().unwrap_or(&Footprint::DEFAULT), converter)
+}
+
+#[node_macro::node(category(""), skip_impl)]
+fn convert_async<T: Send + ConvertAsync<O, C>, O: Send + 'static, C: Send>(ctx: impl Ctx + ExtractAll, value: T, converter: C, #[data] _out_ty: PhantomData<O>) -> SourceFuture<O> {
+	value.convert(*ctx.try_footprint().unwrap_or(&Footprint::DEFAULT), converter)
 }
 
 #[cfg(test)]
@@ -26,6 +30,6 @@ mod test {
 
 	#[test]
 	pub fn passthrough_node() {
-		assert_eq!(passthrough((), &4), &4);
+		assert_eq!(passthrough(&(), &4), &4);
 	}
 }