From 71f12db1e645c8baf54ed64e6ad1a626aa40a802 Mon Sep 17 00:00:00 2001
From: Dennis <dennis@kobert.dev>
Date: Mon, 22 Aug 2022 17:18:26 +0200
Subject: [PATCH] Impl DynNode

---
 Cargo.lock                              |  40 +++---
 libraries/dyn-any/src/lib.rs            |  49 +++++---
 node-graph/borrow_stack/src/lib.rs      |   7 ++
 node-graph/gcore/Cargo.toml             |   2 +-
 node-graph/gcore/src/lib.rs             |  48 +++++--
 node-graph/gcore/src/ops.rs             |  26 +++-
 node-graph/gcore/src/raster.rs          |   8 +-
 node-graph/gcore/src/structural.rs      |  54 ++++++--
 node-graph/gstd/Cargo.toml              |   2 +-
 node-graph/gstd/src/any.rs              | 161 ++++++++++++++++++++++++
 node-graph/gstd/src/document.rs         |  94 ++++++++++++++
 node-graph/gstd/src/lib.rs              |  16 +--
 node-graph/gstd/src/main.rs             |   1 +
 node-graph/gstd/src/memo.rs             |   1 -
 node-graph/gstd/src/raster.rs           |   8 +-
 node-graph/gstd/test-image-1-result.png | Bin 0 -> 29388 bytes
 16 files changed, 433 insertions(+), 84 deletions(-)
 create mode 100644 node-graph/gstd/src/any.rs
 create mode 100644 node-graph/gstd/src/document.rs
 create mode 100644 node-graph/gstd/test-image-1-result.png

diff --git a/Cargo.lock b/Cargo.lock
index a5eb3749..31197f1e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -234,9 +234,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f107b87b6afc2a64fd13cac55fe06d6c8859f12d4b14cbcdd2c67d0976781be"
+checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
 
 [[package]]
 name = "env_logger"
@@ -253,16 +253,15 @@ dependencies = [
 
 [[package]]
 name = "exr"
-version = "1.4.2"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14cc0e06fb5f67e5d6beadf3a382fec9baca1aa751c6d5368fdeee7e5932c215"
+checksum = "78c26a90d9dd411a3d119d6f55752fb4c134ca243250c32fb9cab7b2561638d2"
 dependencies = [
  "bit_field",
- "deflate",
  "flume",
  "half",
- "inflate",
  "lebe",
+ "miniz_oxide",
  "smallvec",
  "threadpool",
 ]
@@ -298,15 +297,15 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "futures-core"
-version = "0.3.21"
+version = "0.3.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c09fd04b7e4073ac7156a9539b57a484a8ea920f79c7c675d05d289ab6110d3"
+checksum = "d2acedae88d38235936c3922476b10fced7b2b68136f5e3c03c2d5be348a1115"
 
 [[package]]
 name = "futures-sink"
-version = "0.3.21"
+version = "0.3.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21163e139fa306126e6eedaf49ecdb4588f939600f0b1e770f4205ee4b7fa868"
+checksum = "ca0bae1fe9752cf7fd9b0064c674ae63f97b37bc714d745cbde0afb7ec4e6765"
 
 [[package]]
 name = "getrandom"
@@ -479,15 +478,6 @@ dependencies = [
  "tiff",
 ]
 
-[[package]]
-name = "inflate"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cdb29978cc5797bd8dcc8e5bf7de604891df2a8dc576973d71a281e916db2ff"
-dependencies = [
- "adler32",
-]
-
 [[package]]
 name = "itoa"
 version = "1.0.1"
@@ -529,9 +519,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "lebe"
-version = "0.5.1"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7efd1d698db0759e6ef11a7cd44407407399a910c774dd804c64c032da7826ff"
+checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
 
 [[package]]
 name = "libc"
@@ -646,18 +636,18 @@ checksum = "18a6dbe30758c9f83eb00cbea4ac95966305f5a7772f3f42ebfc7fc7eddbd8e1"
 
 [[package]]
 name = "pin-project"
-version = "1.0.11"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78203e83c48cffbe01e4a2d35d566ca4de445d79a85372fc64e378bfc812a260"
+checksum = "ad29a609b6bcd67fee905812e544992d216af9d755757c05ed2d0e15a74c6ecc"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.0.11"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "710faf75e1b33345361201d36d04e98ac1ed8909151a017ed384700836104c74"
+checksum = "069bdb1e05adc7a8990dce9cc75370895fbe4e3d58b9b73bf1aee56359344a55"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/libraries/dyn-any/src/lib.rs b/libraries/dyn-any/src/lib.rs
index e0e10c50..985e1906 100644
--- a/libraries/dyn-any/src/lib.rs
+++ b/libraries/dyn-any/src/lib.rs
@@ -25,6 +25,15 @@ pub fn downcast_ref<'a, V: StaticType>(i: &'a dyn DynAny<'a>) -> Option<&'a V> {
 		None
 	}
 }
+pub fn downcast<'a, V: StaticType>(i: Box<dyn DynAny<'a> + 'a>) -> Option<Box<V>> {
+	if i.type_id() == std::any::TypeId::of::<<V as StaticType>::Static>() {
+		// SAFETY: caller guarantees that T is the correct type
+		let ptr = Box::into_raw(i) as *mut dyn DynAny<'a> as *mut V;
+		Some(unsafe { Box::from_raw(ptr) })
+	} else {
+		None
+	}
+}
 
 pub trait StaticType {
 	type Static: 'static + ?Sized;
@@ -39,8 +48,11 @@ pub trait StaticTypeSized {
 		std::any::TypeId::of::<Self::Static>()
 	}
 }
-impl<'a, T: StaticTypeSized> StaticType for T {
-	type Static = <T as StaticTypeSized>::Static;
+impl<T: StaticType + Sized> StaticTypeSized for T
+where
+	T::Static: Sized,
+{
+	type Static = <T as StaticType>::Static;
 }
 pub trait StaticTypeClone {
 	type Static: 'static + Clone;
@@ -48,41 +60,44 @@ pub trait StaticTypeClone {
 		std::any::TypeId::of::<Self::Static>()
 	}
 }
-impl<'a, T: StaticTypeClone> StaticTypeSized for T {
-	type Static = <T as StaticTypeClone>::Static;
+impl<T: StaticType + Clone> StaticTypeClone for T
+where
+	T::Static: Clone,
+{
+	type Static = <T as StaticType>::Static;
 }
 
 macro_rules! impl_type {
     ($($id:ident$(<$($(($l:lifetime, $s:lifetime)),*|)?$($T:ident),*>)?),*) => {
         $(
-        impl<'a, $($($T: 'a + $crate::StaticTypeSized + Sized,)*)?> $crate::StaticTypeSized for $id $(<$($($l,)*)?$($T, )*>)?{
+        impl< $($($T:  $crate::StaticTypeSized ,)*)?> $crate::StaticType for $id $(<$($($l,)*)?$($T, )*>)?{
             type Static = $id$(<$($($s,)*)?$(<$T as $crate::StaticTypeSized>::Static,)*>)?;
         }
         )*
     };
 }
-impl<'a, T: Clone + StaticTypeClone> StaticTypeClone for std::borrow::Cow<'a, T> {
-	type Static = std::borrow::Cow<'static, <T as StaticTypeSized>::Static>;
+impl<'a, T: StaticTypeClone + Clone> StaticType for std::borrow::Cow<'a, T> {
+	type Static = std::borrow::Cow<'static, T::Static>;
 }
-impl<'a, T: StaticTypeSized> StaticTypeSized for *const [T] {
+impl<T: StaticTypeSized> StaticType for *const [T] {
 	type Static = *const [<T as StaticTypeSized>::Static];
 }
-impl<'a, T: StaticTypeSized> StaticTypeSized for *mut [T] {
+impl<T: StaticTypeSized> StaticType for *mut [T] {
 	type Static = *mut [<T as StaticTypeSized>::Static];
 }
-impl<'a, T: StaticTypeSized> StaticTypeSized for &'a [T] {
+impl<'a, T: StaticTypeSized> StaticType for &'a [T] {
 	type Static = &'static [<T as StaticTypeSized>::Static];
 }
-impl<'a> StaticTypeSized for &'a str {
+impl<'a> StaticType for &'a str {
 	type Static = &'static str;
 }
-impl<'a> StaticTypeSized for () {
+impl StaticType for () {
 	type Static = ();
 }
-impl<'a, T: 'a + StaticTypeClone> StaticTypeClone for &'a T {
-	type Static = &'static <T as StaticTypeClone>::Static;
+impl<'a, T: 'a + StaticType> StaticType for &'a T {
+	type Static = &'static <T as StaticType>::Static;
 }
-impl<'a, T: StaticTypeSized, const N: usize> StaticTypeSized for [T; N] {
+impl<T: StaticTypeSized, const N: usize> StaticType for [T; N] {
 	type Static = [<T as StaticTypeSized>::Static; N];
 }
 
@@ -102,7 +117,7 @@ use std::{
 
 impl_type!(Option<T>,Result<T, E>,Cell<T>,UnsafeCell<T>,RefCell<T>,MaybeUninit<T>,
 		   Vec<T>, String, BTreeMap<K,V>,BTreeSet<V>, LinkedList<T>, VecDeque<T>,
-		   BinaryHeap<T>, ManuallyDrop<T>, PhantomData<T>, PhantomPinned,Empty<T>,
+		   BinaryHeap<T>, Box<T>, ManuallyDrop<T>, PhantomData<T>, PhantomPinned,Empty<T>,
 		   Wrapping<T>, Duration, Once, Mutex<T>, RwLock<T>,  bool, f32, f64, char,
 		   u8, AtomicU8, u16,AtomicU16, u32,AtomicU32, u64,AtomicU64, usize,AtomicUsize,
 		   i8,AtomicI8, i16,AtomicI16, i32,AtomicI32, i64,AtomicI64, isize,AtomicIsize,
@@ -115,7 +130,7 @@ macro_rules! impl_tuple {
         impl_tuple! { @rec $($t)* }
     };
     (@impl $($t:ident)*) => {
-        impl<'dyn_any, $($t: StaticTypeSized,)*> StaticTypeSized for ($($t,)*) {
+        impl< $($t: StaticTypeSized,)*> StaticType for ($($t,)*) {
             type Static = ($(<$t as $crate::StaticTypeSized>::Static,)*);
         }
     };
diff --git a/node-graph/borrow_stack/src/lib.rs b/node-graph/borrow_stack/src/lib.rs
index 5026607a..90fcaf4f 100644
--- a/node-graph/borrow_stack/src/lib.rs
+++ b/node-graph/borrow_stack/src/lib.rs
@@ -7,8 +7,11 @@ use std::{
 
 pub trait BorrowStack<'n> {
 	type Item;
+	/// # Safety
 	unsafe fn push(&'n self, value: Self::Item);
+	/// # Safety
 	unsafe fn pop(&'n self);
+	/// # Safety
 	unsafe fn get(&'n self) -> &'n [Self::Item];
 }
 
@@ -37,6 +40,10 @@ impl<'n, T: Unpin> FixedSizeStack<'n, T> {
 	pub fn len(&self) -> usize {
 		self.len.load(Ordering::SeqCst)
 	}
+
+	pub fn is_empty(&self) -> bool {
+		self.len.load(Ordering::SeqCst) == 0
+	}
 }
 
 impl<'n, T> BorrowStack<'n> for FixedSizeStack<'n, T> {
diff --git a/node-graph/gcore/Cargo.toml b/node-graph/gcore/Cargo.toml
index 56e43bbc..79415975 100644
--- a/node-graph/gcore/Cargo.toml
+++ b/node-graph/gcore/Cargo.toml
@@ -10,7 +10,7 @@ license = "MIT OR Apache-2.0"
 
 [features]
 std = ["dyn-any"]
-default = ["gpu", "async"]
+default = ["async"]
 gpu = ["spirv-std"]
 async = ["async-trait"]
 nightly = []
diff --git a/node-graph/gcore/src/lib.rs b/node-graph/gcore/src/lib.rs
index 50c0f531..6f34c850 100644
--- a/node-graph/gcore/src/lib.rs
+++ b/node-graph/gcore/src/lib.rs
@@ -3,6 +3,7 @@
 
 #[cfg(feature = "async")]
 extern crate alloc;
+
 #[cfg(feature = "async")]
 use alloc::boxed::Box;
 #[cfg(feature = "async")]
@@ -18,12 +19,35 @@ pub trait Node<T> {
 	type Output;
 
 	fn eval(self, input: T) -> Self::Output;
+	fn input(&self) -> &str {
+		core::any::type_name::<T>()
+	}
+	fn output(&self) -> &str {
+		core::any::type_name::<Self::Output>()
+	}
 }
 
 trait Input<I> {
 	unsafe fn input(&self, input: I);
 }
 
+pub trait RefNode<T> {
+	type Output;
+
+	fn eval_ref(&self, input: T) -> Self::Output;
+}
+
+impl<'n, N: 'n, I> RefNode<I> for &'n N
+where
+	&'n N: Node<I>,
+	Self: 'n,
+{
+	type Output = <&'n N as Node<I>>::Output;
+	fn eval_ref(&self, input: I) -> Self::Output {
+		self.eval(input)
+	}
+}
+
 #[cfg(feature = "async")]
 #[async_trait]
 pub trait AsyncNode<T> {
@@ -46,13 +70,23 @@ pub trait Cache {
 	fn clear(&mut self);
 }
 
-#[cfg(not(feature = "gpu"))]
-extern crate alloc;
-#[cfg(not(feature = "gpu"))]
-impl<'n, I, O: 'n> Node<'n, I> for alloc::boxed::Box<dyn Node<'n, I, Output = O>> {
-	type Output = O;
-
-	fn eval(&'n self, input: &'n I) -> Self::Output {
+#[cfg(feature = "async")]
+impl<N, I> Node<I> for Box<N>
+where
+	N: Node<I>,
+{
+	type Output = <N as Node<I>>::Output;
+	fn eval(self, input: I) -> Self::Output {
+		(*self).eval(input)
+	}
+}
+#[cfg(feature = "async")]
+impl<'n, N, I> Node<I> for &'n Box<N>
+where
+	&'n N: Node<I>,
+{
+	type Output = <&'n N as Node<I>>::Output;
+	fn eval(self, input: I) -> Self::Output {
 		self.as_ref().eval(input)
 	}
 }
diff --git a/node-graph/gcore/src/ops.rs b/node-graph/gcore/src/ops.rs
index 9d2bd7e0..3aca9eba 100644
--- a/node-graph/gcore/src/ops.rs
+++ b/node-graph/gcore/src/ops.rs
@@ -11,6 +11,24 @@ impl<'n, L: Add<R, Output = O> + 'n, R, O: 'n> Node<(L, R)> for AddNode {
 		input.0 + input.1
 	}
 }
+impl<'n, L: Add<R, Output = O> + 'n, R, O: 'n> Node<(L, R)> for &'n AddNode {
+	type Output = <L as Add<R>>::Output;
+	fn eval(self, input: (L, R)) -> Self::Output {
+		input.0 + input.1
+	}
+}
+impl<'n, L: Add<R, Output = O> + 'n + Copy, R: Copy, O: 'n> Node<&'n (L, R)> for AddNode {
+	type Output = <L as Add<R>>::Output;
+	fn eval(self, input: &'n (L, R)) -> Self::Output {
+		input.0 + input.1
+	}
+}
+impl<'n, L: Add<R, Output = O> + 'n + Copy, R: Copy, O: 'n> Node<&'n (L, R)> for &'n AddNode {
+	type Output = <L as Add<R>>::Output;
+	fn eval(self, input: &'n (L, R)) -> Self::Output {
+		input.0 + input.1
+	}
+}
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct CloneNode;
@@ -82,7 +100,7 @@ pub struct DupNode;
 impl<'n, T: Clone + 'n> Node<T> for DupNode {
 	type Output = (T, T);
 	fn eval(self, input: T) -> Self::Output {
-		(input.clone(), input) //TODO: use Copy/Clone implementation
+		(input.clone(), input)
 	}
 }
 
@@ -95,6 +113,12 @@ impl<'n, T: 'n> Node<T> for IdNode {
 		input
 	}
 }
+impl<'n, T: 'n> Node<T> for &'n IdNode {
+	type Output = T;
+	fn eval(self, input: T) -> Self::Output {
+		input
+	}
+}
 
 pub struct MapResultNode<MN, I, E>(pub MN, pub PhantomData<(I, E)>);
 
diff --git a/node-graph/gcore/src/raster.rs b/node-graph/gcore/src/raster.rs
index 5139255e..7772ddb0 100644
--- a/node-graph/gcore/src/raster.rs
+++ b/node-graph/gcore/src/raster.rs
@@ -34,7 +34,7 @@ where
 	}
 }
 
-pub struct MutWrapper<N>(pub N);
+/*pub struct MutWrapper<N>(pub N);
 
 impl<'n, T: Clone, N> Node<&'n mut T> for &'n MutWrapper<N>
 where
@@ -44,7 +44,7 @@ where
 	fn eval(self, value: &'n mut T) {
 		*value = (&self.0).eval(value.clone());
 	}
-}
+}*/
 
 #[cfg(test)]
 mod test {
@@ -54,8 +54,8 @@ mod test {
 	fn map_node() {
 		let array = &mut [Color::from_rgbaf32(1.0, 0.0, 0.0, 1.0).unwrap()];
 		(&GrayscaleNode).eval(Color::from_rgbf32_unchecked(1., 0., 0.));
-		let map = ForEachNode(MutWrapper(GrayscaleNode));
+		/*let map = ForEachNode(MutWrapper(GrayscaleNode));
 		(&map).eval(array.iter_mut());
-		assert_eq!(array[0], Color::from_rgbaf32(0.33333334, 0.33333334, 0.33333334, 1.0).unwrap());
+		assert_eq!(array[0], Color::from_rgbaf32(0.33333334, 0.33333334, 0.33333334, 1.0).unwrap());*/
 	}
 }
diff --git a/node-graph/gcore/src/structural.rs b/node-graph/gcore/src/structural.rs
index 4db0131c..4dcd7f65 100644
--- a/node-graph/gcore/src/structural.rs
+++ b/node-graph/gcore/src/structural.rs
@@ -1,7 +1,8 @@
 use core::marker::PhantomData;
 
-use crate::Node;
+use crate::{Node, RefNode};
 
+#[derive(Debug)]
 pub struct ComposeNode<First, Second, Input> {
 	first: First,
 	second: Second,
@@ -25,25 +26,40 @@ where
 }
 impl<'n, Input, Inter, First, Second> Node<Input> for &'n ComposeNode<First, Second, Input>
 where
-	First: Node<Input, Output = Inter> + Copy,
-	Second: Node<Inter> + Copy,
+	First: RefNode<Input, Output = Inter> + Copy,
+	Second: RefNode<Inter> + Copy,
 {
-	type Output = Second::Output;
+	type Output = <Second as RefNode<Inter>>::Output;
 
 	fn eval(self, input: Input) -> Self::Output {
 		// evaluate the first node with the given input
 		// and then pipe the result from the first computation
 		// into the second node
-		let arg: Inter = self.first.eval(input);
-		(&self.second).eval(arg)
+		let arg: Inter = (self.first).eval_ref(input);
+		(self.second).eval_ref(arg)
 	}
 }
-
-impl<'n, Input, First: 'n, Second: 'n> ComposeNode<First, Second, Input>
+impl<Input, Inter, First, Second> RefNode<Input> for ComposeNode<First, Second, Input>
 where
-	First: Node<Input>,
-	Second: Node<First::Output>,
+	First: RefNode<Input, Output = Inter> + Copy,
+	Second: RefNode<Inter> + Copy,
 {
+	type Output = <Second as RefNode<Inter>>::Output;
+
+	fn eval_ref(&self, input: Input) -> Self::Output {
+		// evaluate the first node with the given input
+		// and then pipe the result from the first computation
+		// into the second node
+		let arg: Inter = (self.first).eval_ref(input);
+		(self.second).eval_ref(arg)
+	}
+}
+#[cfg(feature = "std")]
+impl<Input: 'static, First: 'static, Second: 'static> dyn_any::StaticType for ComposeNode<First, Second, Input> {
+	type Static = ComposeNode<First, Second, Input>;
+}
+
+impl<'n, Input, First: 'n, Second: 'n> ComposeNode<First, Second, Input> {
 	pub const fn new(first: First, second: Second) -> Self {
 		ComposeNode::<First, Second, Input> { first, second, _phantom: PhantomData }
 	}
@@ -79,6 +95,24 @@ pub trait AfterRef<Inter>: Sized {
 }
 impl<'n, Second: 'n, I> AfterRef<I> for Second where &'n Second: Node<I> {}
 
+#[cfg(feature = "async")]
+pub trait AfterBox<Inter> {
+	fn after<'n, First: 'n, Input>(self, first: First) -> ComposeNode<First, Self, Input>
+	where
+		First: Node<Input, Output = Inter> + Copy,
+		alloc::boxed::Box<Self>: Node<Inter>,
+		Self: Sized,
+	{
+		ComposeNode::<First, Self, Input> {
+			first,
+			second: self,
+			_phantom: PhantomData,
+		}
+	}
+}
+#[cfg(feature = "async")]
+impl<'n, Second: 'n, I> AfterBox<I> for alloc::boxed::Box<Second> where &'n alloc::boxed::Box<Second>: Node<I> {}
+
 pub struct ConsNode<Root>(pub Root);
 
 impl<Root, Input> Node<Input> for ConsNode<Root>
diff --git a/node-graph/gstd/Cargo.toml b/node-graph/gstd/Cargo.toml
index f37ada4e..82db125e 100644
--- a/node-graph/gstd/Cargo.toml
+++ b/node-graph/gstd/Cargo.toml
@@ -15,7 +15,7 @@ default = ["derive", "memoization"]
 
 
 [dependencies]
-graphene-core = {path = "../gcore"}
+graphene-core = {path = "../gcore", features = ["async", "std"]}
 borrow_stack = {path = "../borrow_stack"}
 dyn-any = {path = "../../libraries/dyn-any", features = ["derive"]}
 graph-proc-macros = {path = "../proc-macro", optional = true}
diff --git a/node-graph/gstd/src/any.rs b/node-graph/gstd/src/any.rs
new file mode 100644
index 00000000..17f80741
--- /dev/null
+++ b/node-graph/gstd/src/any.rs
@@ -0,0 +1,161 @@
+use dyn_any::{DynAny, StaticType};
+pub use graphene_core::{generic, ops /*, structural*/, Node, RefNode};
+use std::marker::PhantomData;
+
+fn fmt_error<I>() -> String {
+	format!("DynAnyNode: input is not of correct type, expected {}", std::any::type_name::<I>())
+}
+
+pub struct DynAnyNode<'n, N: RefNode<I>, I>(pub N, pub PhantomData<&'n I>);
+/*impl<'n, I: StaticType, N: RefNode<'n, &'n I, Output = O> + 'n, O: 'n + StaticType> Node<&'n dyn DynAny<'n>> for DynAnyNode<'n, N, I> {
+	type Output = Box<dyn dyn_any::DynAny<'n> + 'n>;
+	fn eval(self, input: &'n dyn DynAny<'n>) -> Self::Output {
+		let output = self.0.eval_ref(dyn_any::downcast_ref(input).expect(fmt_error::<I>().as_str()));
+		Box::new(output)
+	}
+}*/
+/*
+impl<'n, I: StaticType, N: RefNode<&'n I, Output = O> + Copy + 'n, O: 'n + StaticType> Node<&'n dyn DynAny<'n>> for &'n DynAnyNode<'n, N, I> {
+	type Output = Box<dyn dyn_any::DynAny<'n> + 'n>;
+	fn eval(self, input: &'n dyn DynAny<'n>) -> Self::Output {
+		let output = self.0.eval_ref(dyn_any::downcast_ref(input).unwrap_or_else(|| panic!("{}", fmt_error::<I>())));
+		Box::new(output)
+	}
+}
+impl<'n, I: StaticType, N: RefNode<'n, I, Output = O> + 'n, O: 'n + StaticType> Node<Box<dyn DynAny<'n>>> for DynAnyNode<'n, N, I> {
+	type Output = Box<dyn dyn_any::DynAny<'n> + 'n>;
+	fn eval(self, input: Box<dyn DynAny<'n>>) -> Self::Output {
+		let input: Box<I> = dyn_any::downcast(input).unwrap_or_else(|| panic!("{}", fmt_error::<I>()));
+		Box::new(self.0.eval_ref(*input))
+	}
+}*/
+impl<'n, I: StaticType, N: RefNode<I, Output = O> + Copy + 'n, O: 'n + StaticType> Node<Any<'n>> for &'n DynAnyNode<'n, N, I> {
+	type Output = Any<'n>;
+	fn eval(self, input: Any<'n>) -> Self::Output {
+		let input: Box<I> = dyn_any::downcast(input).unwrap_or_else(|| panic!("{}", fmt_error::<I>()));
+		Box::new(self.0.eval_ref(*input))
+	}
+}
+
+impl<'n, I: StaticType, N: RefNode<I, Output = O> + 'n + Copy, O: 'n + StaticType> DynAnyNode<'n, N, I>
+where
+	N::Output: StaticType,
+{
+	pub fn new(n: N) -> Self {
+		DynAnyNode(n, PhantomData)
+	}
+	pub fn into_erased(&'n self) -> impl RefNode<Any<'n>, Output = Any<'n>> {
+		self
+	}
+	/*pub fn as_ref(&'n self) -> &'n AnyNode<'n> {
+		self
+	}
+	pub fn into_ref_box(self) -> Box<dyn RefNode<Box<(dyn DynAny<'n> + 'n)>, Output = Box<(dyn DynAny<'n> + 'n)>> + 'n> {
+		Box::new(self)
+	}*/
+	pub fn into_ref(self: &'n &'n Self) -> &'n (dyn RefNode<Any<'n>, Output = Any<'n>> + 'n) {
+		self
+	}
+}
+
+/*impl<'n: 'static, I: StaticType, N, O: 'n + StaticType> DynAnyNode<'n, N, I>
+where
+	N: RefNode<I, Output = O> + 'n + Copy,
+{
+	/*pub fn into_owned_erased(self) -> impl RefNode<Any<'n>, Output = Any<'n>> + 'n {
+		self
+	}*/
+	pub fn as_owned(&'n self) -> &'n (dyn RefNode<Any<'n>, Output = Any<'n>> + 'n) {
+		self
+	}
+	/*pub fn into_owned_box(&self) -> Box<dyn DynNodeOwned<'n>> {
+		Box::new(self)
+	}*/
+}*/
+pub type Any<'n> = Box<dyn DynAny<'n> + 'n>;
+pub type AnyNode<'n> = dyn RefNode<Any<'n>, Output = Any<'n>>;
+
+pub trait DynNodeRef<'n>: RefNode<&'n dyn DynAny<'n>, Output = Box<dyn DynAny<'n> + 'n>> + 'n {}
+impl<'n, N: RefNode<&'n dyn DynAny<'n>, Output = Box<dyn DynAny<'n> + 'n>> + 'n> DynNodeRef<'n> for N {}
+
+pub trait DynNodeOwned<'n>: RefNode<Any<'n>, Output = Any<'n>> + 'n {}
+impl<'n, N: RefNode<Any<'n>, Output = Any<'n>> + 'n> DynNodeOwned<'n> for N {}
+
+/*impl<'n> Node<Box<dyn DynAny<'n>>> for &'n Box<dyn DynNodeOwned<'n>> {
+	type Output = Box<dyn DynAny<'n> + 'n>;
+	fn eval(self, input: Box<dyn DynAny<'n>>) -> Self::Output {
+		(&*self as &dyn Node<Box<dyn DynAny<'n> + 'n>, Output = Box<dyn DynAny<'n> + 'n>>).eval(input)
+	}
+}*/
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use graphene_core::ops::{AddNode, IdNode};
+	use graphene_core::value::ValueNode;
+	/*#[test]
+	pub fn dyn_input_compositon() {
+		use graphene_core::structural::After;
+		use graphene_core::structural::ComposeNode;
+		let id: DynAnyNode<_, u32> = DynAnyNode::new(IdNode);
+		let add: DynAnyNode<_, (u32, u32)> = DynAnyNode::new(AddNode);
+		let value: DynAnyNode<_, ()> = DynAnyNode::new(ValueNode((3u32, 4u32)));
+		let id = &id.as_owned();
+		let add = add.as_owned();
+		let value = value.as_owned();
+
+		/*let computation = ComposeNode::new(value, add);
+		let computation = id.after(add.after(value));
+		let result: u32 = *dyn_any::downcast(computation.eval(&())).unwrap();*/
+	}*/
+	#[test]
+	#[should_panic]
+	pub fn dyn_input_invalid_eval_panic() {
+		static ADD: &DynAnyNode<&AddNode, (u32, u32)> = &DynAnyNode(&AddNode, PhantomData);
+
+		let add = ADD.into_ref();
+		add.eval_ref(Box::new(&("32", 32u32)));
+	}
+	/*#[test]
+	pub fn dyn_input_storage() {
+		let mut vec: Vec<Box<dyn DynNodeRef>> = vec![];
+		let id: DynAnyNode<_, u32> = DynAnyNode::new(IdNode);
+		let add: DynAnyNode<_, (u32, u32)> = DynAnyNode::new(AddNode);
+		let value: DynAnyNode<_, ()> = DynAnyNode::new(ValueNode((3u32, 4u32)));
+
+		vec.push(add.into_ref_box());
+		vec.push(id.into_ref_box());
+		vec.push(value.into_ref_box());
+	}*/
+	#[test]
+	pub fn dyn_input_storage_composition() {
+		let mut vec: Vec<&(dyn RefNode<Any, Output = Any>)> = vec![];
+		//let id: DynAnyNode<_, u32> = DynAnyNode::new(IdNode);
+		let value: &DynAnyNode<&ValueNode<(u32, u32)>, ()> = &DynAnyNode(&ValueNode((3u32, 4u32)), PhantomData);
+		let add: &DynAnyNode<&AddNode, &(u32, u32)> = &DynAnyNode(&AddNode, PhantomData);
+
+		let value_ref = (&value).into_ref();
+		let add_ref = (&add).into_ref();
+		vec.push(value_ref);
+		vec.push(add_ref);
+		//vec.push(add.as_owned());
+		//vec.push(id.as_owned());
+		//let vec = vec.leak();
+
+		let n_value = vec[0];
+		let n_add = vec[1];
+		//let id = vec[2];
+
+		assert_eq!(*(dyn_any::downcast::<&(u32, u32)>(n_value.eval_ref(Box::new(()))).unwrap()), &(3u32, 4u32));
+		fn compose<'n>(
+			first: &'n (dyn RefNode<Box<(dyn DynAny<'n> + 'n)>, Output = Box<(dyn DynAny<'n> + 'n)>> + 'n),
+			second: &'n (dyn RefNode<Box<(dyn DynAny<'n> + 'n)>, Output = Box<(dyn DynAny<'n> + 'n)>> + 'n),
+			input: Any<'n>,
+		) -> Any<'n> {
+			second.eval_ref(first.eval_ref(input))
+		}
+		let result = compose(n_value, n_add, Box::new(()));
+		assert_eq!(*dyn_any::downcast::<u32>(result).unwrap(), 7u32);
+		//let result: u32 = *dyn_any::downcast(computation.eval(Box::new(()))).unwrap();
+	}
+}
diff --git a/node-graph/gstd/src/document.rs b/node-graph/gstd/src/document.rs
new file mode 100644
index 00000000..309d2158
--- /dev/null
+++ b/node-graph/gstd/src/document.rs
@@ -0,0 +1,94 @@
+/*
+use core::marker::PhantomData;
+
+use graphene_core::{structural::After, structural::ComposeNode, value::ValueNode, Node, RefNode};
+
+use crate::any::Any;
+use crate::any::DynAnyNode;
+
+pub trait DocumentNode<I>: RefNode<I> {
+	fn input_hints(&self) -> &'static [&'static str];
+	fn input_types(&self) -> &'static [&'static str];
+	fn inputs(&self) -> Vec<String> {
+		self.input_hints().iter().zip(self.input_types()).map(|(a, b)| format!("{}{}", a, b)).collect()
+	}
+}
+
+struct InjectNode<N: Node<I> + Copy, I>(N, PhantomData<I>);
+
+impl<'n, N: Node<I> + Copy, I> Node<&'n [&'n AnyNode<'n>]> for &'n InjectNode<N, I> {
+	type Output = Box<dyn RefNode<Any<'n>, Output = Any<'n>> + 'n>;
+	fn eval(self, input: &'n [&'n AnyNode<'n>]) -> Self::Output {
+		assert_eq!(input.len(), 1);
+		Box::new(ComposeNode::new(&DynAnyNode(input[0]), &DynAnyNode(self.0)))
+	}
+}
+
+impl<N: Node<I> + Copy, I> InjectNode<N, I> {
+	const TYPES: &'static [&'static str] = &[core::any::type_name::<I>()];
+	const HINTS: &'static [&'static str] = &["input: "];
+}
+impl<'n, N: Node<I> + Copy, I> DocumentNode<&'n [&'n AnyNode<'n>]> for &'n InjectNode<N, I> {
+	fn input_hints(&self) -> &'static [&'static str] {
+		InjectNode::<N, I>::HINTS
+	}
+	fn input_types(&self) -> &'static [&'static str] {
+		InjectNode::<N, I>::TYPES
+	}
+}
+
+pub type NodeId = u32;
+
+type AnyNode<'n> = dyn RefNode<Any<'n>, Output = Any<'n>>;
+
+pub struct DocumentGraphNode<'n> {
+	pub id: NodeId,
+	pub inputs: Vec<NodeInput>,
+	pub node: NodeWrapper<'n>,
+}
+
+impl<'n> DocumentGraphNode<'n> {
+	pub fn new(id: NodeId, inputs: Vec<NodeInput>, node: NodeWrapper<'n>) -> Self {
+		Self { id, inputs, node }
+	}
+}
+
+pub struct NodeWrapper<'n> {
+	pub node: &'n (dyn Node<Any<'n>, Output = Any<'n>> + 'n),
+
+	pub path: &'static str,
+}
+
+impl<'n> NodeWrapper<'n> {
+	pub fn new(node: &'n (dyn Node<Any<'n>, Output = Any<'n>> + 'n), path: &'static str) -> Self {
+		Self { node, path }
+	}
+}
+
+pub enum NodeInput {
+	Node(NodeId),
+	Default(ValueNode<Any<'static>>),
+}
+
+#[cfg(test)]
+mod test {
+	use crate::any::DynAnyNode;
+
+	use super::*;
+	use graphene_core::value::ValueNode;
+
+	#[test]
+	fn inject_node() {
+		let inject_node = InjectNode(&ValueNode(4u32), PhantomData);
+		use super::DocumentNode;
+		/*assert_eq!(
+			(&inject_node as &dyn DocumentNode<&[&AnyNode], Output = ComposeNode<&AnyNode, ValueNode<u32>, ()>>).inputs(),
+			vec!["input: ()"]
+		);*/
+		let any_inject = DynAnyNode(&inject_node, PhantomData);
+		let any_inject = Box::leak(Box::new(any_inject));
+		let wrapped = NodeWrapper::new((&any_inject) as &(dyn Node<&[&AnyNode], Output = Any>), "grahpene_core::document::InjectNode");
+		let document_node = DocumentGraphNode::new(0, vec![], wrapped);
+	}
+}
+*/
diff --git a/node-graph/gstd/src/lib.rs b/node-graph/gstd/src/lib.rs
index 76ca35a9..ae9447b1 100644
--- a/node-graph/gstd/src/lib.rs
+++ b/node-graph/gstd/src/lib.rs
@@ -1,22 +1,17 @@
 //pub mod value;
-pub use graphene_core::{generic, ops /*, structural*/};
+//#![feature(const_type_name)]
 
 #[cfg(feature = "memoization")]
 pub mod memo;
 
 pub mod raster;
 
+pub mod any;
+
+pub mod document;
+
 pub use graphene_core::*;
 
-/*use dyn_any::DynAny;
-pub type DynNode<'n, T> = &'n (dyn Node<'n, Output = T> + 'n);
-pub type DynAnyNode<'n> = &'n (dyn Node<'n, Output = &'n dyn DynAny<'n>> + 'n);
-pub trait DynamicInput<'n> {
-	fn set_kwarg_by_name(&mut self, name: &str, value: DynAnyNode<'n>);
-	fn set_arg_by_index(&mut self, index: usize, value: DynAnyNode<'n>);
-}
-
-*/
 use quote::quote;
 use syn::{Expr, ExprPath, Type};
 
@@ -31,6 +26,7 @@ pub struct NodeGraph {
 	pub output: Type,
 	pub input: Type,
 }
+
 pub enum NodeKind {
 	Value(Expr),
 	Input,
diff --git a/node-graph/gstd/src/main.rs b/node-graph/gstd/src/main.rs
index 1fdca03b..5eb05960 100644
--- a/node-graph/gstd/src/main.rs
+++ b/node-graph/gstd/src/main.rs
@@ -99,6 +99,7 @@ fn main() {
 	];
 
 	//println!("{}", node_graph(1));
+	//
 
 	let _nodegraph = NodeGraph {
 		nodes,
diff --git a/node-graph/gstd/src/memo.rs b/node-graph/gstd/src/memo.rs
index 83121fcd..3c1a1e55 100644
--- a/node-graph/gstd/src/memo.rs
+++ b/node-graph/gstd/src/memo.rs
@@ -1,6 +1,5 @@
 use graphene_core::{Cache, Node};
 use once_cell::sync::OnceCell;
-use std::marker::PhantomData;
 
 /// Caches the output of a given Node and acts as a proxy
 pub struct CacheNode<CachedNode: Node<I>, I> {
diff --git a/node-graph/gstd/src/raster.rs b/node-graph/gstd/src/raster.rs
index 0e0676a0..ed4d6b31 100644
--- a/node-graph/gstd/src/raster.rs
+++ b/node-graph/gstd/src/raster.rs
@@ -2,13 +2,7 @@ use core::marker::PhantomData;
 use graphene_core::ops::FlatMapResultNode;
 use graphene_core::raster::color::Color;
 use graphene_core::structural::{ComposeNode, ConsNode};
-use graphene_core::{
-	generic::FnNode,
-	ops::MapResultNode,
-	structural::{After, AfterRef},
-	value::ValueNode,
-	Node,
-};
+use graphene_core::{generic::FnNode, ops::MapResultNode, structural::After, value::ValueNode, Node};
 use image::Pixel;
 use std::path::Path;
 
diff --git a/node-graph/gstd/test-image-1-result.png b/node-graph/gstd/test-image-1-result.png
new file mode 100644
index 0000000000000000000000000000000000000000..67da108e433085ed696fba7e24b3f3a9f44bf48a
GIT binary patch
literal 29388
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
Dih7>0

literal 0
HcmV?d00001