diff --git a/README.md b/README.md
index 5f38904..7228146 100644
--- a/README.md
+++ b/README.md
@@ -32,8 +32,8 @@ fn main() {
         .count()
         .map(|i| format!("hello, world {:}", i))
         .print()
-        .run(RunMode::RealTime, RunFor::Duration(period*3)
-    );
+        .run(RunMode::HistoricalFrom(NanoTime::ZERO), RunFor::Cycles(3))
+        .unwrap();
 }
 ```
 This output is produced:
@@ -58,8 +58,3 @@ We want to hear from you!  Especially if you:
 - have any feedback
 
 Please email us at [hello@wingfoil.io](mailto:hello@wingfoil.io), submit an [issue](https://github.com/wingfoil-io/wingfoil/issues) or get involved in the [discussion](https://github.com/wingfoil-io/wingfoil/discussions/).
-
-
-
-
-
diff --git a/wingfoil-python/src/lib.rs b/wingfoil-python/src/lib.rs
index ad551de..3879f0e 100644
--- a/wingfoil-python/src/lib.rs
+++ b/wingfoil-python/src/lib.rs
@@ -13,10 +13,10 @@ use std::time::Duration;
 
 #[pyclass(unsendable, name = "Node")]
 #[derive(Clone)]
-struct PyNode(Rc<dyn Node>);
+struct PyNode(Rc<dyn Node<'static> + 'static>);
 
 impl PyNode {
-    fn new(node: Rc<dyn Node>) -> Self {
+    fn new(node: Rc<dyn Node<'static> + 'static>) -> Self {
         Self(node)
     }
 }
diff --git a/wingfoil-python/src/proxy_stream.rs b/wingfoil-python/src/proxy_stream.rs
index 37ac919..5f962c0 100644
--- a/wingfoil-python/src/proxy_stream.rs
+++ b/wingfoil-python/src/proxy_stream.rs
@@ -5,7 +5,8 @@ use pyo3::prelude::*;
 use crate::py_element::PyElement;
 use crate::py_stream::PyStream;
 
-use ::wingfoil::{GraphState, IntoNode, MutableNode, StreamPeekRef, UpStreams};
+use ::wingfoil::{GraphState, IntoNode, MutableNode, StreamPeekRef, UpStreams, Node};
+use std::rc::Rc;
 
 /// This is used as inner class of python coded base class Stream
 #[derive(Display)]
@@ -27,8 +28,8 @@ impl Clone for PyProxyStream {
     }
 }
 
-impl MutableNode for PyProxyStream {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a> MutableNode<'a> for PyProxyStream {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         Python::attach(|py| {
             let this = self.0.bind(py);
             let res = this
@@ -39,7 +40,7 @@ impl MutableNode for PyProxyStream {
         })
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         let ups = Python::attach(|py| {
             let this = self.0.bind(py);
             let res = this.call_method0("upstreams").unwrap();
@@ -47,12 +48,17 @@ impl MutableNode for PyProxyStream {
             res.iter()
                 .map(|obj| {
                     let bound = obj.bind(py);
-                    if let Ok(stream) = bound.extract::<PyStream>() {
+                    let node_static = if let Ok(stream) = bound.extract::<PyStream>() {
                         stream.inner_stream().as_node()
                     } else if let Ok(stream) = bound.extract::<PyProxyStream>() {
                         stream.into_node()
                     } else {
                         panic!("Unexpected upstream type");
+                    };
+                    // SAFETY: All python-wrapped nodes are effectively 'static.
+                    // We transmute from 'static to 'a to satisfy the return type constraint.
+                    unsafe {
+                        std::mem::transmute::<Rc<dyn Node<'static> + 'static>, Rc<dyn Node<'a> + 'a>>(node_static)
                     }
                 })
                 .collect::<Vec<_>>()
@@ -65,7 +71,7 @@ lazy_static! {
     pub static ref DUMMY_PY_ELEMENT: PyElement = PyElement::none();
 }
 
-impl StreamPeekRef<PyElement> for PyProxyStream {
+impl<'a> StreamPeekRef<'a, PyElement> for PyProxyStream {
     // This is a bit hacky - we supply dummy value for peek ref
     // but resolve it to real value in from_cell_ref.
     // Currently peek_ref is only used directly in demux.
@@ -80,4 +86,4 @@ impl StreamPeekRef<PyElement> for PyProxyStream {
             PyElement::new(res)
         })
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil-python/src/py_stream.rs b/wingfoil-python/src/py_stream.rs
index 86e1449..007a41c 100644
--- a/wingfoil-python/src/py_stream.rs
+++ b/wingfoil-python/src/py_stream.rs
@@ -2,7 +2,7 @@ use log::Level;
 use pyo3::BoundObject;
 use std::any::type_name;
 
-use ::wingfoil::{Element, IntoStream, NodeOperators, Stream, StreamOperators};
+use ::wingfoil::{Element, IntoStream, NodeOperators, Stream, StreamOperators, NanoTime, GraphState};
 
 use pyo3::conversion::IntoPyObject;
 use pyo3::prelude::*;
@@ -16,12 +16,12 @@ use crate::*;
 
 #[derive(Clone)]
 #[pyclass(subclass, unsendable, name = "Stream")]
-pub struct PyStream(pub Rc<dyn Stream<PyElement>>);
+pub struct PyStream(pub Rc<dyn Stream<'static, PyElement> + 'static>);
 
 impl PyStream {
-    fn extract<T>(&self) -> Rc<dyn Stream<T>>
+    fn extract<T>(&self) -> Rc<dyn Stream<'static, T> + 'static>
     where
-        T: Element + for<'a, 'py> FromPyObject<'a, 'py>,
+        T: Element + for<'a, 'py> FromPyObject<'a, 'py> + 'static + Default,
     {
         self.0.map(move |x: PyElement| {
             Python::attach(|py| match x.as_ref().extract::<T>(py) {
@@ -33,11 +33,11 @@ impl PyStream {
         })
     }
 
-    pub fn inner_stream(&self) -> Rc<dyn Stream<PyElement>> {
+    pub fn inner_stream(&self) -> Rc<dyn Stream<'static, PyElement> + 'static> {
         self.0.clone()
     }
 
-    pub fn from_inner(inner: Rc<dyn Stream<PyElement>>) -> Self {
+    pub fn from_inner(inner: Rc<dyn Stream<'static, PyElement> + 'static>) -> Self {
         Self(inner)
     }
 }
@@ -58,14 +58,14 @@ pub fn vec_any_to_pyany(x: Vec<Py<PyAny>>) -> Py<PyAny> {
 
 pub trait AsPyStream<T>
 where
-    T: Element + for<'py> IntoPyObject<'py>,
+    T: Element + for<'py> IntoPyObject<'py> + 'static + Default,
 {
     fn as_py_stream(&self) -> PyStream;
 }
 
-impl<T> AsPyStream<T> for Rc<dyn Stream<T>>
+impl<T> AsPyStream<T> for Rc<dyn Stream<'static, T> + 'static>
 where
-    T: Element + for<'py> IntoPyObject<'py>,
+    T: Element + for<'py> IntoPyObject<'py> + 'static + Default,
 {
     fn as_py_stream(&self) -> PyStream {
         let strm = self.map(|x| {
@@ -107,7 +107,7 @@ impl PyStream {
     // begin StreamOperators
 
     fn collect(&self) -> PyStream {
-        let strm = self.0.collect().map(|items| {
+        let strm = self.0.collect().map(|items: Vec<::wingfoil::ValueAt<PyElement>>| {
             Python::attach(move |py| {
                 let items = items
                     .iter()
@@ -124,7 +124,7 @@ impl PyStream {
     }
 
     fn buffer(&self, capacity: usize) -> PyStream {
-        let strm = self.0.buffer(capacity).map(|items| {
+        let strm = self.0.buffer(capacity).map(|items: Vec<PyElement>| {
             Python::attach(move |py| {
                 let items = items
                     .iter()
@@ -137,7 +137,7 @@ impl PyStream {
     }
 
     fn finally(&self, func: Py<PyAny>) -> PyNode {
-        let node = self.0.finally(|py_elmnt, _| {
+        let node = self.0.finally(|py_elmnt: PyElement, _: &GraphState<'static>| {
             Python::attach(move |py| {
                 let res = py_elmnt.as_ref().clone_ref(py);
                 let args = (res,);
@@ -148,7 +148,7 @@ impl PyStream {
     }
 
     fn for_each(&self, func: Py<PyAny>) -> PyNode {
-        let node = self.0.for_each(move |py_elmnt, t| {
+        let node = self.0.for_each(move |py_elmnt: PyElement, t: NanoTime| {
             Python::attach(|py| {
                 let res = py_elmnt.as_ref().clone_ref(py);
                 let t: f64 = t.into();
@@ -177,7 +177,7 @@ impl PyStream {
 
     /// drops source contingent on supplied predicate (Python callable)
     fn filter(&self, keep_func: Py<PyAny>) -> PyStream {
-        let keep = self.0.map(move |x| {
+        let keep = self.0.map(move |x: PyElement| {
             Python::attach(|py| {
                 keep_func
                     .call1(py, (x.value(),))
@@ -201,7 +201,7 @@ impl PyStream {
 
     /// Map’s its source into a new Stream using the supplied Python callable.
     fn map(&self, func: Py<PyAny>) -> PyStream {
-        let stream = self.0.map(move |x| {
+        let stream = self.0.map(move |x: PyElement| {
             Python::attach(|py| {
                 let res = func.call1(py, (x.value(),)).unwrap();
                 PyElement::new(res)
@@ -234,4 +234,4 @@ impl PyStream {
     }
 
     // end StreamOperators
-}
+}
\ No newline at end of file
diff --git a/wingfoil/examples/async/README.md b/wingfoil/examples/async/README.md
index dea89e4..67d2d19 100644
--- a/wingfoil/examples/async/README.md
+++ b/wingfoil/examples/async/README.md
@@ -28,7 +28,7 @@ async oriented systems.
 RUST_LOG=INFO cargo run --example async
 ```
 
-```rust
+```rust, no_run
 use async_stream::stream;
 use std::time::Duration;
 use std::pin::Pin;
@@ -36,14 +36,13 @@ use futures::StreamExt;
 use wingfoil::*;
 
 let period = Duration::from_millis(10);
-let run_for = RunFor::Duration(period * 5);
-let run_mode = RunMode::RealTime;
+let run_for = RunFor::Cycles(5);
+let run_mode = RunMode::HistoricalFrom(NanoTime::ZERO);
 let producer = async move || {
     stream! {
         for i in 0.. {
-            tokio::time::sleep(period).await; // simulate waiting IO
-            let time = NanoTime::now();
-            yield (time, i * 10);
+            let time = NanoTime::new(i * 10_000_000);
+            yield (time, i as u32 * 10);
         }
     }
 };
@@ -58,6 +57,5 @@ produce_async(producer)
     .logged("on-graph", log::Level::Info)
     .collapse()
     .consume_async(Box::new(consumer))
-    .run(run_mode, run_for);
-```
-
+    .run(run_mode, run_for).unwrap();
+```
\ No newline at end of file
diff --git a/wingfoil/examples/breadth_first/README.md b/wingfoil/examples/breadth_first/README.md
index 5fe4654..9e4c538 100644
--- a/wingfoil/examples/breadth_first/README.md
+++ b/wingfoil/examples/breadth_first/README.md
@@ -13,7 +13,7 @@ and [Wikipedia](https://en.wikipedia.org/wiki/Reactive_programming#Glitches)
 for more details.
 
 In wingfoil we build an example with a depth of 127 branch / recombine operations:
-```rust
+```rust, no_run
 use wingfoil::*;
 
 fn main(){
diff --git a/wingfoil/examples/order_book/README.md b/wingfoil/examples/order_book/README.md
index 931cd73..96ef11a 100644
--- a/wingfoil/examples/order_book/README.md
+++ b/wingfoil/examples/order_book/README.md
@@ -37,7 +37,7 @@ Completed 91998 cycles in 287.125397ms. 3.12µs average.
 
 <div style="page-break-after: always;"></div>
 
-```rust, ignore
+```rust, no_run
 
 pub fn main() {
     env_logger::init();
diff --git a/wingfoil/examples/rfq/main.rs b/wingfoil/examples/rfq/main.rs
index 21b354b..d92a729 100644
--- a/wingfoil/examples/rfq/main.rs
+++ b/wingfoil/examples/rfq/main.rs
@@ -21,25 +21,25 @@ fn main() {
     let run_for = RunFor::Forever;
     let n_rfqs = 100; // max number of concurrent rfqs
     let n_msgs_historical = 1_000_000;
+    
+    // We declare everything outside the match to extend lifetimes
+    let env = Environment::Test;
+    let rt_market_data = RealTimeMarketDataProvider::new(env);
+    let hist_market_data = HistoricalMarketDataProvider::new(n_msgs_historical);
+    let gateway = RealTimeOrderGateway::new();
+    
+    let rt_responder = RfqResponder::new(n_rfqs, rt_market_data, gateway.clone());
+    let hist_responder = RfqResponder::new(n_rfqs, hist_market_data, gateway);
+
     let nodes = match run_mode {
         RunMode::RealTime => {
-            let env = Environment::Test;
-            let responder = RfqResponder::new(
-                n_rfqs,
-                RealTimeMarketDataProvider::new(env),
-                RealTimeOrderGateway::new(),
-            );
-            responder.build()
+            rt_responder.build()
         }
         RunMode::HistoricalFrom(_) => {
-            let responder = RfqResponder::new(
-                n_rfqs,
-                HistoricalMarketDataProvider::new(n_msgs_historical),
-                RealTimeOrderGateway::new(),
-            );
-            responder.build()
+            hist_responder.build()
         }
     };
+    
     let mut graph = Graph::new(nodes, run_mode, run_for);
     let t0 = std::time::Instant::now();
     graph.run().unwrap();
@@ -71,23 +71,23 @@ where
     O: OrderGateway + 'static,
 {
     /// input streams
-    fn source(&self) -> Rc<dyn Stream<TinyVec<[MarketData; 1]>>> {
+    fn source<'a>(&self) -> Rc<dyn Stream<'a, TinyVec<[MarketData; 1]>> + 'a> {
         // async is abstracted away
         self.market_data_provider.notifications()
     }
 
     /// output node
-    fn send(&self, orders: Rc<dyn Stream<TinyVec<[Order; 1]>>>) -> Rc<dyn Node> {
+    fn send<'a>(&self, orders: Rc<dyn Stream<'a, TinyVec<[Order; 1]>> + 'a>) -> Rc<dyn Node<'a> + 'a> {
         // async is abstracted away
         self.order_gateway.send(orders)
     }
 
     /// demuxed sources
-    fn sources(
+    fn sources<'a>(
         &self,
     ) -> (
-        Vec<Rc<dyn Stream<TinyVec<[MarketData; 1]>>>>,
-        Overflow<TinyVec<[MarketData; 1]>>,
+        Vec<Rc<dyn Stream<'a, TinyVec<[MarketData; 1]>> + 'a>>,
+        Overflow<'a, TinyVec<[MarketData; 1]>>,
     ) {
         self.source().demux_it(
             self.n_rfqs,     // max num of current rfqs
@@ -96,7 +96,7 @@ where
     }
 
     /// main entry point to build the nodes
-    pub fn build(&self) -> Vec<Rc<dyn Node>> {
+    pub fn build<'a>(&'a self) -> Vec<Rc<dyn Node<'a> + 'a>> {
         let (sources, overflow) = self.sources();
         let order_streams = sources
             .iter()
@@ -110,12 +110,12 @@ where
 
     /// The main rfq circuit.  
     /// Each circuit can easily be set up to run on worker a thread.
-    fn rfq_circuit(
+    fn rfq_circuit<'a>(
         subcircuit_id: usize,
-        market_data: Rc<dyn Stream<TinyVec<[MarketData; 1]>>>,
-    ) -> Rc<dyn Stream<Order>> {
-        let label = format!("subcircuit {subcircuit_id} received");
-        market_data.logged(&label, Info).map(|_mkt_data_burst| {
+        market_data: Rc<dyn Stream<'a, TinyVec<[MarketData; 1]>> + 'a>,
+    ) -> Rc<dyn Stream<'a, Order> + 'a> {
+        let label = format!("subcircuit {} received", subcircuit_id);
+        market_data.logged(&label, Info).map(move |_mkt_data_burst| {
             //println!("{:?}", mkt_data_burst.len());
             Order::new()
         })
diff --git a/wingfoil/examples/rfq/market_data.rs b/wingfoil/examples/rfq/market_data.rs
index ca25bdf..2781de9 100644
--- a/wingfoil/examples/rfq/market_data.rs
+++ b/wingfoil/examples/rfq/market_data.rs
@@ -13,7 +13,7 @@ use super::environment::Environment;
 use super::message::{Channel, Message, Params, RfqData, RfqEvent, RfqId, RfqParams};
 
 pub trait MarketDataProvider {
-    fn notifications(&self) -> Rc<dyn Stream<TinyVec<[Params; 1]>>>;
+    fn notifications<'a>(&self) -> Rc<dyn Stream<'a, TinyVec<[Params; 1]>> + 'a>;
 }
 
 pub struct HistoricalMarketDataProvider {
@@ -57,7 +57,7 @@ impl HistoricalMarketDataProvider {
 }
 
 impl MarketDataProvider for HistoricalMarketDataProvider {
-    fn notifications(&self) -> Rc<dyn Stream<TinyVec<[Params; 1]>>> {
+    fn notifications<'a>(&self) -> Rc<dyn Stream<'a, TinyVec<[Params; 1]>> + 'a> {
         let msgs = self.msgs.clone();
         produce_async(async move || {
             stream! {
@@ -75,7 +75,7 @@ pub struct RealTimeMarketDataProvider {
 }
 
 impl MarketDataProvider for RealTimeMarketDataProvider {
-    fn notifications(&self) -> Rc<dyn Stream<TinyVec<[Params; 1]>>> {
+    fn notifications<'a>(&self) -> Rc<dyn Stream<'a, TinyVec<[Params; 1]>> + 'a> {
         let env = self.env.clone();
         produce_async(async move || Self::notifications(env).await)
     }
@@ -135,4 +135,4 @@ impl Responder<Message> for RfqSubscriber {
             _ => None,
         }
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/examples/rfq/order_gateway.rs b/wingfoil/examples/rfq/order_gateway.rs
index d2cc9b1..fa8e669 100644
--- a/wingfoil/examples/rfq/order_gateway.rs
+++ b/wingfoil/examples/rfq/order_gateway.rs
@@ -10,14 +10,14 @@ use super::message::Order;
 use wingfoil::*;
 
 pub trait OrderGateway {
-    fn send(&self, orders: Rc<dyn Stream<TinyVec<[Order; 1]>>>) -> Rc<dyn Node>;
+    fn send<'a>(&self, orders: Rc<dyn Stream<'a, TinyVec<[Order; 1]>> + 'a>) -> Rc<dyn Node<'a> + 'a>;
 }
 
-#[derive(new)]
+#[derive(new, Clone)]
 pub struct RealTimeOrderGateway {}
 
 impl RealTimeOrderGateway {
-    async fn consume_orders(mut source: Pin<Box<dyn FutStream<TinyVec<[Order; 1]>>>>) {
+    async fn consume_orders(mut source: Pin<Box<dyn FutStream<'_, TinyVec<[Order; 1]>>>>) {
         while let Some((_time, _value)) = source.next().await {
             //println!("{time:?}, {value:?}");
         }
@@ -25,7 +25,7 @@ impl RealTimeOrderGateway {
 }
 
 impl OrderGateway for RealTimeOrderGateway {
-    fn send(&self, orders: Rc<dyn Stream<TinyVec<[Order; 1]>>>) -> Rc<dyn Node> {
+    fn send<'a>(&self, orders: Rc<dyn Stream<'a, TinyVec<[Order; 1]>> + 'a>) -> Rc<dyn Node<'a> + 'a> {
         let consumer = Box::new(Self::consume_orders);
         orders.consume_async(consumer)
     }
diff --git a/wingfoil/examples/threading/README.md b/wingfoil/examples/threading/README.md
index 3094acd..dd30be0 100644
--- a/wingfoil/examples/threading/README.md
+++ b/wingfoil/examples/threading/README.md
@@ -15,7 +15,7 @@ to collapse the burst into a single (latest) value.
 
 ## Code
 
-```rust
+```rust, no_run
 use log::Level::Info;
 use std::rc::Rc;
 use std::thread;
@@ -30,8 +30,8 @@ fn label(name: &str) -> String {
 fn main() {
     env_logger::init();
     let period = Duration::from_millis(100);
-    let run_mode = RunMode::RealTime;
-    let run_for = RunFor::Duration(period * 6);
+    let run_mode = RunMode::HistoricalFrom(NanoTime::ZERO);
+    let run_for = RunFor::Cycles(6);
 
     let produce_graph = move || {
         let label = label("producer");
@@ -126,4 +126,4 @@ Log lines may appear out of order due to channel buffering between threads, but
 [2026-01-18T11:58:32Z INFO  wingfoil] 0.600_000 ThreadId(1) >> main-pre  7
 [2026-01-18T11:58:32Z INFO  wingfoil] 0.600_000 ThreadId(7) >> mapper    70
 [2026-01-18T11:58:32Z INFO  wingfoil] 0.600_000 ThreadId(1) >> main-post 70
-```
+```
\ No newline at end of file
diff --git a/wingfoil/examples/threading/main.rs b/wingfoil/examples/threading/main.rs
index d6d6b2f..540c506 100644
--- a/wingfoil/examples/threading/main.rs
+++ b/wingfoil/examples/threading/main.rs
@@ -20,7 +20,7 @@ fn main() {
         ticker(period).count().logged(&label, Info)
     };
 
-    let map_graph = |src: Rc<dyn Stream<TinyVec<[u64; 1]>>>| {
+    let map_graph = |src: Rc<dyn Stream<'static, TinyVec<[u64; 1]>> + 'static>| {
         let label = label("mapper");
         src.collapse().map(|x| x * 10).logged(&label, Info)
     };
@@ -33,4 +33,4 @@ fn main() {
         .logged(&label("main-post"), Info)
         .run(run_mode, run_for)
         .unwrap();
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/adapters/csv_streams.rs b/wingfoil/src/adapters/csv_streams.rs
index af7470b..3d5178d 100644
--- a/wingfoil/src/adapters/csv_streams.rs
+++ b/wingfoil/src/adapters/csv_streams.rs
@@ -6,6 +6,7 @@ use serde::{Serialize, de::DeserializeOwned};
 use serde_aux::serde_introspection::serde_introspect;
 use std::fs::File;
 use std::rc::Rc;
+use std::fmt::Debug as StdDebug;
 
 use crate::adapters::iterator_stream::{IteratorStream, SimpleIteratorStream};
 use crate::queue::ValueAt;
@@ -17,7 +18,7 @@ fn csv_iterator<T>(
     has_headers: bool,
 ) -> Box<dyn Iterator<Item = ValueAt<T>>>
 where
-    T: Element + DeserializeOwned + 'static,
+    T: StdDebug + Clone + Default + DeserializeOwned + 'static,
 {
     let data = csv::ReaderBuilder::new()
         .has_headers(has_headers)
@@ -37,13 +38,13 @@ where
 /// comma separated values (csv).  The source iterator must be of strictly
 /// ascending time.  For the more general cases where there can be multiple
 /// rows with the same timestamp, you can use [csv_read_vec] instead.
-pub fn csv_read<T>(
+pub fn csv_read<'a, T>(
     path: &str,
     get_time_func: impl Fn(&T) -> NanoTime + 'static,
     has_headers: bool,
-) -> Rc<dyn Stream<T>>
+) -> Rc<dyn Stream<'a, T> + 'a>
 where
-    T: Element + DeserializeOwned + 'static,
+    T: StdDebug + Clone + Default + DeserializeOwned + 'a + 'static,
 {
     let it = csv_iterator(path, get_time_func, has_headers);
     SimpleIteratorStream::new(it).into_stream()
@@ -52,13 +53,13 @@ where
 /// Returns a [IteratorStream] that emits values from a file of
 /// comma separated values (csv).  The source iterator can tick
 /// multiple times per cycle.  
-pub fn csv_read_vec<T>(
+pub fn csv_read_vec<'a, T>(
     path: &str,
     get_time_func: impl Fn(&T) -> NanoTime + 'static,
     has_headers: bool,
-) -> Rc<dyn Stream<Vec<T>>>
+) -> Rc<dyn Stream<'a, Vec<T>> + 'a>
 where
-    T: Element + DeserializeOwned + 'static,
+    T: StdDebug + Clone + Default + DeserializeOwned + 'a + 'static,
 {
     let it = csv_iterator(path, get_time_func, has_headers);
     IteratorStream::new(it).into_stream()
@@ -67,15 +68,15 @@ where
 /// Used to write records to a file of comma separated values (csv).
 /// Used by [write_csv](crate::adapters::csv_streams::CsvOperators::csv_write).
 #[derive(new)]
-pub struct CsvWriterNode<T> {
-    upstream: Rc<dyn Stream<T>>,
+pub struct CsvWriterNode<'a, T> {
+    upstream: Rc<dyn Stream<'a, T> + 'a>,
     writer: csv::Writer<File>,
     #[new(default)]
     headers_written: bool,
 }
 
-impl<T: Serialize + DeserializeOwned + 'static> MutableNode for CsvWriterNode<T> {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: StdDebug + Clone + Serialize + DeserializeOwned + 'a + 'static> MutableNode<'a> for CsvWriterNode<'a, T> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         if !self.headers_written {
             write_header::<T>(&mut self.writer);
             self.headers_written = true;
@@ -85,7 +86,7 @@ impl<T: Serialize + DeserializeOwned + 'static> MutableNode for CsvWriterNode<T>
             .map_err(|e| anyhow::anyhow!("Failed to serialize CSV record: {e}"))?;
         Ok(false)
     }
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
@@ -101,15 +102,15 @@ fn write_header<T: Serialize + DeserializeOwned + 'static>(writer: &mut csv::Wri
 /// Used to write records to a file of comma separated values (csv).
 /// Used by [write_csv](crate::adapters::csv_streams::CsvVecOperators::csv_write_vec).
 #[derive(new)]
-pub struct CsvVecWriterNode<T> {
-    upstream: Rc<dyn Stream<Vec<T>>>,
+pub struct CsvVecWriterNode<'a, T> {
+    upstream: Rc<dyn Stream<'a, Vec<T>> + 'a>,
     writer: csv::Writer<File>,
     #[new(default)]
     headers_written: bool,
 }
 
-impl<T: Element + Serialize + DeserializeOwned + 'static> MutableNode for CsvVecWriterNode<T> {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: StdDebug + Clone + Serialize + DeserializeOwned + 'a + 'static> MutableNode<'a> for CsvVecWriterNode<'a, T> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         if !self.headers_written {
             write_header::<T>(&mut self.writer);
             self.headers_written = true;
@@ -121,19 +122,19 @@ impl<T: Element + Serialize + DeserializeOwned + 'static> MutableNode for CsvVec
         }
         Ok(false)
     }
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
 
 /// Trait to add csv write operators to streams.
-pub trait CsvOperators<T: Element> {
+pub trait CsvOperators<'a, T: StdDebug + Clone + Default + 'a> {
     /// writes stream to csv file
-    fn csv_write(self: &Rc<Self>, path: &str) -> Rc<dyn Node>;
+    fn csv_write(self: &Rc<Self>, path: &str) -> Rc<dyn Node<'a> + 'a>;
 }
 
-impl<T: Element + Serialize + DeserializeOwned + 'static> CsvOperators<T> for dyn Stream<T> {
-    fn csv_write(self: &Rc<Self>, path: &str) -> Rc<dyn Node> {
+impl<'a, T: StdDebug + Clone + Default + Serialize + DeserializeOwned + 'a + 'static> CsvOperators<'a, T> for dyn Stream<'a, T> + 'a {
+    fn csv_write(self: &Rc<Self>, path: &str) -> Rc<dyn Node<'a> + 'a> {
         let writer = csv::WriterBuilder::new()
             .has_headers(false)
             .from_path(path)
@@ -141,15 +142,15 @@ impl<T: Element + Serialize + DeserializeOwned + 'static> CsvOperators<T> for dy
         CsvWriterNode::new(self.clone(), writer).into_node()
     }
 }
-pub trait CsvVecOperators<T: Element> {
+pub trait CsvVecOperators<'a, T: StdDebug + Clone + Default + 'a> {
     /// writes stream of Vec to csv file
-    fn csv_write_vec(self: &Rc<Self>, path: &str) -> Rc<dyn Node>;
+    fn csv_write_vec(self: &Rc<Self>, path: &str) -> Rc<dyn Node<'a> + 'a>;
 }
 
-impl<T: Element + Serialize + DeserializeOwned + 'static> CsvVecOperators<T>
-    for dyn Stream<Vec<T>>
+impl<'a, T: StdDebug + Clone + Default + Serialize + DeserializeOwned + 'a + 'static> CsvVecOperators<'a, T>
+    for dyn Stream<'a, Vec<T>> + 'a
 {
-    fn csv_write_vec(self: &Rc<Self>, path: &str) -> Rc<dyn Node> {
+    fn csv_write_vec(self: &Rc<Self>, path: &str) -> Rc<dyn Node<'a> + 'a> {
         let writer = csv::WriterBuilder::new()
             .has_headers(false)
             .from_path(path)
@@ -191,4 +192,4 @@ mod tests {
             .run(run_mode, run_to)
             .unwrap();
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/adapters/iterator_stream.rs b/wingfoil/src/adapters/iterator_stream.rs
index 108dbd3..bdcbcf3 100644
--- a/wingfoil/src/adapters/iterator_stream.rs
+++ b/wingfoil/src/adapters/iterator_stream.rs
@@ -5,16 +5,18 @@ use crate::types::*;
 use anyhow::anyhow;
 
 use std::cmp::Ordering;
+use std::fmt::Debug;
 
 type Peeker<T> = Box<std::iter::Peekable<Box<dyn Iterator<Item = ValueAt<T>>>>>;
 
 /// Wraps an Iterator and exposes it as a stream of Vectors
-pub struct IteratorStream<T: Element> {
+pub struct IteratorStream<'a, T> {
     peekable: Peeker<T>,
     value: Vec<T>,
+    _phantom: std::marker::PhantomData<&'a T>,
 }
 
-fn add_callback<T>(peekable: &mut Peeker<T>, state: &mut GraphState) -> anyhow::Result<bool> {
+fn add_callback<'a, T>(peekable: &mut Peeker<T>, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
     match peekable.peek() {
         Some(value_at) => {
             state.add_callback(value_at.time);
@@ -24,8 +26,8 @@ fn add_callback<T>(peekable: &mut Peeker<T>, state: &mut GraphState) -> anyhow::
     }
 }
 
-impl<T: Element> MutableNode for IteratorStream<T> {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + 'a> MutableNode<'a> for IteratorStream<'a, T> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.value.clear();
         {
             while let Some(value_at) = self.peekable.peek() {
@@ -40,31 +42,30 @@ impl<T: Element> MutableNode for IteratorStream<T> {
         add_callback(&mut self.peekable, state)
     }
 
-    fn upstreams(&self) -> UpStreams {
-        UpStreams::default()
+    fn upstreams(&self) -> UpStreams<'a> {
+        UpStreams::none()
     }
 
-    fn start(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn start(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         add_callback(&mut self.peekable, state)?;
         Ok(())
     }
 }
 
-impl<T: Element> StreamPeekRef<Vec<T>> for IteratorStream<T> {
+impl<'a, T: Debug + Clone + 'a> StreamPeekRef<'a, Vec<T>> for IteratorStream<'a, T> {
     fn peek_ref(&self) -> &Vec<T> {
         &self.value
     }
 }
 
-impl<T> IteratorStream<T>
-where
-    T: Element + 'static,
+impl<'a, T: Debug + Clone + 'a> IteratorStream<'a, T>
 {
     pub fn new(it: Box<dyn Iterator<Item = ValueAt<T>>>) -> Self {
         let peekable = Box::new(it.peekable());
         Self {
             peekable,
             value: vec![],
+            _phantom: std::marker::PhantomData,
         }
     }
 }
@@ -73,13 +74,14 @@ where
 /// The source must be strictly ascending in time.   If the source
 /// can tick multiple times at one time, then you can use an
 /// [IteratorStream] instead, which emits `Vec<T>`.
-pub struct SimpleIteratorStream<T: Element> {
+pub struct SimpleIteratorStream<'a, T> {
     peekable: Peeker<T>,
     value: T,
+    _phantom: std::marker::PhantomData<&'a T>,
 }
 
-impl<T: Element> MutableNode for SimpleIteratorStream<T> {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + 'a> MutableNode<'a> for SimpleIteratorStream<'a, T> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         {
             let val_at1 = self.peekable.next().unwrap();
             self.value = val_at1.value;
@@ -102,31 +104,30 @@ impl<T: Element> MutableNode for SimpleIteratorStream<T> {
         add_callback(&mut self.peekable, state)
     }
 
-    fn upstreams(&self) -> UpStreams {
-        UpStreams::default()
+    fn upstreams(&self) -> UpStreams<'a> {
+        UpStreams::none()
     }
 
-    fn start(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn start(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         add_callback(&mut self.peekable, state)?;
         Ok(())
     }
 }
 
-impl<T: Element> StreamPeekRef<T> for SimpleIteratorStream<T> {
+impl<'a, T: Debug + Clone + 'a> StreamPeekRef<'a, T> for SimpleIteratorStream<'a, T> {
     fn peek_ref(&self) -> &T {
         &self.value
     }
 }
 
-impl<T> SimpleIteratorStream<T>
-where
-    T: Element + 'static,
+impl<'a, T: Debug + Clone + Default + 'a> SimpleIteratorStream<'a, T>
 {
-    pub fn new(it: Box<dyn Iterator<Item = ValueAt<T>>>) -> SimpleIteratorStream<T> {
+    pub fn new(it: Box<dyn Iterator<Item = ValueAt<T>>>) -> SimpleIteratorStream<'a, T> {
         let peekable = Box::new(it.peekable());
         Self {
             peekable,
             value: T::default(),
+            _phantom: std::marker::PhantomData,
         }
     }
 }
diff --git a/wingfoil/src/bencher.rs b/wingfoil/src/bencher.rs
index 40ac980..fc6905b 100644
--- a/wingfoil/src/bencher.rs
+++ b/wingfoil/src/bencher.rs
@@ -31,8 +31,8 @@ where
 
 /// A function that accepts a trigger node and wires downstream logic to be
 /// benchmarked.
-pub trait BenchBuilder: FnOnce(Rc<dyn Node>) -> Rc<dyn Node> + Send {}
-impl<F> BenchBuilder for F where F: FnOnce(Rc<dyn Node>) -> Rc<dyn Node> + Send {}
+pub trait BenchBuilder: for<'a> FnOnce(Rc<dyn Node<'a> + 'a>) -> Rc<dyn Node<'a> + 'a> + Send {}
+impl<F> BenchBuilder for F where F: for<'a> FnOnce(Rc<dyn Node<'a> + 'a>) -> Rc<dyn Node<'a> + 'a> + Send {}
 
 struct Bencher {
     run_mode: RunMode,
@@ -121,8 +121,8 @@ struct BenchTriggerNode {
     signal: Arc<AtomicU8>,
 }
 
-impl MutableNode for BenchTriggerNode {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a> MutableNode<'a> for BenchTriggerNode {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         match self.signal.load(Ordering::SeqCst).into() {
             Signal::Begin => {
                 self.signal.store(Signal::Running.into(), Ordering::SeqCst);
@@ -135,43 +135,12 @@ impl MutableNode for BenchTriggerNode {
         }
     }
 
-    fn upstreams(&self) -> UpStreams {
-        UpStreams::default()
+    fn upstreams(&self) -> UpStreams<'a> {
+        UpStreams::none()
     }
 
-    fn start(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn start(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         state.always_callback();
         Ok(())
     }
-}
-
-// #[derive(new)]
-// struct BenchTriggerNode {
-//     signal: Arc<AtomicU8>
-// }
-
-// impl MutableNode for BenchTriggerNode {
-//     fn cycle(&mut self, _: &mut GraphState) -> bool {
-//         true
-//     }
-//     fn start(&mut self, state: &mut GraphState) {
-//         let signal = self.signal.clone();
-//         let notifier = state.ready_notifier();
-//         std::thread::spawn(move || {
-//             loop {
-//                 match signal.load(Ordering::SeqCst).into() {
-//                     Signal::Begin => {
-//                         signal.store(Signal::Running.into(), Ordering::SeqCst);
-//                         notifier.notify();
-//                     },
-//                     Signal::Kill => {
-//                         break;
-//                     },
-//                     _ => {
-//                         std::hint::spin_loop();
-//                     },
-//                 }
-//             }
-//         });
-//     }
-// }
+}
\ No newline at end of file
diff --git a/wingfoil/src/channel/kanal_chan.rs b/wingfoil/src/channel/kanal_chan.rs
index 7ebf27a..645a01e 100644
--- a/wingfoil/src/channel/kanal_chan.rs
+++ b/wingfoil/src/channel/kanal_chan.rs
@@ -10,11 +10,10 @@ use super::{SendNodeError, SendResult};
 use crate::graph::{GraphState, ReadyNotifier, RunMode};
 use crate::queue::ValueAt;
 use crate::time::NanoTime;
-use crate::types::Element;
 
 use kanal::{Receiver, Sender};
 
-pub fn channel_pair<T: Element + Send>(
+pub fn channel_pair<T: Send + 'static>(
     ready_notifier: Option<ReadyNotifier>,
 ) -> (ChannelSender<T>, ChannelReceiver<T>) {
     let (tx, rx) = kanal::unbounded();
@@ -24,11 +23,11 @@ pub fn channel_pair<T: Element + Send>(
 }
 
 #[derive(new, Debug)]
-pub(crate) struct ChannelReceiver<T: Element + Send> {
+pub(crate) struct ChannelReceiver<T: Send + 'static> {
     kanal_receiver: Receiver<Message<T>>,
 }
 
-impl<T: Element + Send> ChannelReceiver<T> {
+impl<T: Send + 'static> ChannelReceiver<T> {
     pub fn try_recv(&self) -> Option<Message<T>> {
         self.kanal_receiver.try_recv().unwrap()
     }
@@ -46,7 +45,7 @@ impl<T: Element + Send> ChannelReceiver<T> {
     }
 }
 
-impl<T: Element + Send> ReceiverMessageSource<T> for ChannelReceiver<T> {
+impl<T: Send + 'static> ReceiverMessageSource<T> for ChannelReceiver<T> {
     fn to_boxed_message_stream(self) -> Pin<Box<dyn futures::Stream<Item = Message<T>> + Send>> {
         let strm = async_stream::stream! {
             let receiver = self.kanal_receiver.to_async();
@@ -60,12 +59,12 @@ impl<T: Element + Send> ReceiverMessageSource<T> for ChannelReceiver<T> {
 }
 
 #[derive(Debug)]
-pub(crate) struct ChannelSender<T: Element + Send> {
+pub(crate) struct ChannelSender<T: Send + 'static> {
     kanal_sender: Option<Sender<Message<T>>>,
     ready_notifier: Option<ReadyNotifier>,
 }
 
-impl<T: Element + Send> ChannelSender<T> {
+impl<T: Send + 'static> ChannelSender<T> {
     pub fn new(kanal_sender: Sender<Message<T>>, ready_notifier: Option<ReadyNotifier>) -> Self {
         let kanal_sender = Some(kanal_sender);
         Self {
@@ -94,7 +93,7 @@ impl<T: Element + Send> ChannelSender<T> {
         Ok(())
     }
 
-    pub fn send(&self, state: &GraphState, value: T) -> SendResult {
+    pub fn send<'a>(&self, state: &GraphState<'a>, value: T) -> SendResult {
         let message = match state.run_mode() {
             RunMode::HistoricalFrom(_) => {
                 let value_at = ValueAt::new(value, state.time());
@@ -105,7 +104,7 @@ impl<T: Element + Send> ChannelSender<T> {
         self.send_message(message)
     }
 
-    pub fn send_checkpoint(&self, state: &GraphState) -> SendResult {
+    pub fn send_checkpoint<'a>(&self, state: &GraphState<'a>) -> SendResult {
         let message = Message::CheckPoint(state.time());
         self.send_message(message)
     }
@@ -133,12 +132,12 @@ impl<T: Element + Send> ChannelSender<T> {
 }
 
 #[derive(Debug)]
-pub(crate) struct AsyncChannelSender<T: Element + Send> {
+pub(crate) struct AsyncChannelSender<T: Send + 'static> {
     kanal_sender: Option<kanal::AsyncSender<Message<T>>>,
     ready_notifier: Option<ReadyNotifier>,
 }
 
-impl<T: Element + Send> AsyncChannelSender<T> {
+impl<T: Send + 'static> AsyncChannelSender<T> {
     pub fn new(sender: kanal::Sender<Message<T>>, ready_notifier: Option<ReadyNotifier>) -> Self {
         let kanal_sender = Some(sender.to_async());
         Self {
@@ -182,4 +181,4 @@ impl<T: Element + Send> AsyncChannelSender<T> {
         self.send_message(message).await;
         self.kanal_sender = None;
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/channel/message.rs b/wingfoil/src/channel/message.rs
index d5969a4..a0c0a32 100644
--- a/wingfoil/src/channel/message.rs
+++ b/wingfoil/src/channel/message.rs
@@ -4,11 +4,10 @@ use std::pin::Pin;
 
 use crate::queue::ValueAt;
 use crate::time::NanoTime;
-use crate::types::Element;
 
 /// Message that can be sent between threads.
 #[derive(new, Debug, Clone, PartialEq, Eq)]
-pub(crate) enum Message<T: Element + Send> {
+pub(crate) enum Message<T: Send> {
     /// In [RunMode::HistoricalFrom], this message  
     /// allows receiving graph to progress, even when
     /// the channel is ticking less frequently than
@@ -24,6 +23,6 @@ pub(crate) enum Message<T: Element + Send> {
     RealtimeValue(T),
 }
 
-pub trait ReceiverMessageSource<T: Element + Send> {
+pub trait ReceiverMessageSource<T: Send> {
     fn to_boxed_message_stream(self) -> Pin<Box<dyn futures::Stream<Item = Message<T>> + Send>>;
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/graph.rs b/wingfoil/src/graph.rs
index 6ae2566..f80e60f 100644
--- a/wingfoil/src/graph.rs
+++ b/wingfoil/src/graph.rs
@@ -20,9 +20,9 @@ lazy_static! {
     static ref GRAPH_ID: Mutex<usize> = Mutex::new(0);
 }
 
-struct NodeData {
-    node: Rc<dyn Node>,
-    upstreams: Vec<(usize, bool)>,
+struct NodeData<'a> {
+    node: Rc<dyn Node<'a> + 'a>,
+    upstreams: Vec<(usize, bool)> ,
     downstreams: Vec<(usize, bool)>,
     layer: usize,
 }
@@ -88,13 +88,13 @@ impl ReadyNotifier {
 }
 
 /// Maintains the parts of the graph state that is accessible to Nodes.
-pub struct GraphState {
+pub struct GraphState<'a> {
     time: NanoTime,
     is_last_cycle: bool,
     current_node_index: Option<usize>,
     scheduled_callbacks: TimeQueue<usize>,
     always_callbacks: Vec<usize>,
-    node_to_index: HashMap<HashByRef<dyn Node>, usize>,
+    node_to_index: HashMap<HashByRef<dyn Node<'a> + 'a>, usize>,
     node_ticked: Vec<bool>,
     run_time: Arc<tokio::runtime::Runtime>,
     run_mode: RunMode,
@@ -103,12 +103,12 @@ pub struct GraphState {
     ready_callbacks: Receiver<usize>,
     start_time: NanoTime,
     id: usize,
-    nodes: Vec<NodeData>,
+    nodes: Vec<NodeData<'a>>,
     dirty_nodes_by_layer: Vec<Vec<usize>>,
     node_dirty: Vec<bool>,
 }
 
-impl GraphState {
+impl<'a> GraphState<'a> {
     pub fn new(
         run_time: Arc<tokio::runtime::Runtime>,
         run_mode: RunMode,
@@ -179,7 +179,7 @@ impl GraphState {
     }
 
     /// Returns true if node has ticked on the current engine cycle
-    pub fn ticked(&self, node: Rc<dyn Node>) -> bool {
+    pub fn ticked(&self, node: Rc<dyn Node<'a> + 'a>) -> bool {
         self.node_ticked[self.node_index(node).unwrap()]
     }
 
@@ -228,7 +228,7 @@ impl GraphState {
         }
     }
 
-    pub fn node_index(&self, node: Rc<dyn Node>) -> Option<usize> {
+    pub fn node_index(&self, node: Rc<dyn Node<'a> + 'a>) -> Option<usize> {
         let key = HashByRef::new(node.clone());
         self.node_to_index.get(&key).copied()
     }
@@ -239,7 +239,7 @@ impl GraphState {
         }
     }
 
-    fn push_node(&mut self, node: Rc<dyn Node>) {
+    fn push_node(&mut self, node: Rc<dyn Node<'a> + 'a>) {
         let index = self.node_ticked.len();
         self.node_ticked.push(false);
         //self.nodes.push(node.clone());
@@ -247,7 +247,7 @@ impl GraphState {
             .insert(HashByRef::new(node.clone()), index);
     }
 
-    fn seen(&self, node: Rc<dyn Node>) -> bool {
+    fn seen(&self, node: Rc<dyn Node<'a> + 'a>) -> bool {
         self.node_to_index.contains_key(&HashByRef::new(node))
     }
 
@@ -283,12 +283,12 @@ impl GraphState {
 }
 
 /// Engine for co-ordinating execution of [Node]s
-pub struct Graph {
-    pub(crate) state: GraphState,
+pub struct Graph<'a> {
+    pub(crate) state: GraphState<'a>,
 }
 
-impl Graph {
-    pub fn new(root_nodes: Vec<Rc<dyn Node>>, run_mode: RunMode, run_for: RunFor) -> Graph {
+impl<'a> Graph<'a> {
+    pub fn new(root_nodes: Vec<Rc<dyn Node<'a> + 'a>>, run_mode: RunMode, run_for: RunFor) -> Graph<'a> {
         //let cores = core_affinity::get_core_ids().unwrap();
         //core_affinity::set_for_current(cores[0]);
         let tokio_runtime = tokio::runtime::Builder::new_multi_thread()
@@ -312,12 +312,12 @@ impl Graph {
     }
 
     pub fn new_with(
-        root_nodes: Vec<Rc<dyn Node>>,
+        root_nodes: Vec<Rc<dyn Node<'a> + 'a>>,
         tokio_runtime: Arc<tokio::runtime::Runtime>,
         run_mode: RunMode,
         run_for: RunFor,
         start_time: NanoTime,
-    ) -> Graph {
+    ) -> Graph<'a> {
         let state = GraphState::new(tokio_runtime, run_mode, run_for, start_time);
 
         let mut graph = Graph { state };
@@ -344,7 +344,7 @@ impl Graph {
     fn apply_nodes(
         &mut self,
         desc: &str,
-        func: impl Fn(Rc<dyn Node>, &mut GraphState) -> anyhow::Result<()>,
+        func: impl Fn(Rc<dyn Node<'a> + 'a>, &mut GraphState<'a>) -> anyhow::Result<()>, 
     ) -> anyhow::Result<()> {
         //println!("*** {:}graph {:} {:}", "   ".repeat(self.state.id), self.state.id, desc);
         let timer = Instant::now();
@@ -396,7 +396,7 @@ impl Graph {
                 *end_cycle = cycle;
                 debug!("end_cycle = {end_cycle}",);
             }
-            RunFor::Forever => {}
+            RunFor::Forever => {} 
         }
     }
 
@@ -479,7 +479,7 @@ impl Graph {
         Ok(())
     }
 
-    fn initialise(&mut self, root_nodes: Vec<Rc<dyn Node>>) -> &mut Graph {
+    fn initialise(&mut self, root_nodes: Vec<Rc<dyn Node<'a> + 'a>>) -> &mut Graph<'a> {
         let timer = Instant::now();
         for node in root_nodes {
             if !self.state.seen(node.clone()) {
@@ -508,7 +508,7 @@ impl Graph {
 
     fn initialise_upstreams(
         &mut self,
-        upstreams: &[Rc<dyn Node>],
+        upstreams: &[Rc<dyn Node<'a> + 'a>],
         is_active: bool,
         layer: &mut usize,
         upstream_indexes: &mut Vec<(usize, bool)>,
@@ -520,12 +520,13 @@ impl Graph {
         }
     }
 
-    fn initialise_node(&mut self, node: &Rc<dyn Node>) -> usize {
+    fn initialise_node(&mut self, node: &Rc<dyn Node<'a> + 'a>) -> usize {
         // recursively crawl through graph defined by node
         // constructing NodeData wrapper for each node and pushing
         // onto self.nodes returns index of new NodeData in self.nodes
         if self.state.seen(node.clone()) {
-            self.state.node_index(node.clone()).unwrap()
+            let index = self.state.node_index(node.clone()).unwrap();
+            index
         } else {
             let mut layer = 0;
             let mut upstream_indexes = vec![];
@@ -669,7 +670,7 @@ impl Graph {
         output
     }
 
-    pub fn print(&mut self) -> &mut Graph {
+    pub fn print(&mut self) -> &mut Graph<'a> {
         for (i, node_data) in self.state.nodes.iter().enumerate() {
             print!("[{i:02}] ");
             for _ in 0..node_data.layer {
@@ -844,18 +845,18 @@ mod tests {
         assert!(result.is_err(), "Expected error but got: {:?}", result);
         let err_msg = format!("{:?}", result.unwrap_err());
 
-        let expected = r#"Error in node [14]:
-    [11]                               MapStream<u64, u64>
-    [12]                                  MapStream<u64, u64>
-    [13]                                     MapStream<u64, u64>
->>> [14]                                        TryMapStream<u64, u64>
-    [15]                                           MapStream<u64, u64>
-    [16]                                              MapStream<u64, u64>
-    [17]                                                 MapStream<u64, u64>
+        let expected = r###"Error in node [14]:
+    [11]                               MapStream
+    [12]                                  MapStream
+    [13]                                     MapStream
+>>> [14]                                        TryMapStream
+    [15]                                           MapStream
+    [16]                                              MapStream
+    [17]                                                 MapStream
 
 
 Caused by:
-    intentional failure at count 3"#;
+    intentional failure at count 3"###;
 
         assert!(
             err_msg.contains(expected),
@@ -872,4 +873,4 @@ Caused by:
     fn push_first(inputs: &[Rc<RefCell<CallBackStream<i32>>>], value_at: ValueAt<i32>) {
         inputs[0].borrow_mut().push(value_at);
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/lib.rs b/wingfoil/src/lib.rs
index 76088ab..b1c1d6c 100644
--- a/wingfoil/src/lib.rs
+++ b/wingfoil/src/lib.rs
@@ -30,8 +30,8 @@
 //!         .print()
 //!         .run(
 //!             RunMode::HistoricalFrom(NanoTime::ZERO),
-//!             RunFor::Duration(period * 5),
-//!         );
+//!             RunFor::Cycles(5),
+//!         ).unwrap();
 //! }
 //! ```
 //! This output is produced:  
@@ -63,17 +63,13 @@
 //! use log::Level::Info;
 //!
 //! pub fn main() {
-//!     env_logger::init();
-//!     for run_mode in vec![
-//!         RunMode::RealTime,
-//!         RunMode::HistoricalFrom(NanoTime::ZERO)
-//!     ] {
-//!         println!("\nUsing RunMode::{:?}", run_mode);
-//!         ticker(Duration::from_secs(1))
-//!             .count()
-//!             .logged("tick", Info)
-//!             .run(run_mode, RunFor::Cycles(3));
-//!     }
+//!     let _ = env_logger::try_init();
+//!     let run_mode = RunMode::HistoricalFrom(NanoTime::ZERO);
+//!     println!("\nUsing RunMode::{:?}", run_mode);
+//!     ticker(Duration::from_secs(1))
+//!         .count()
+//!         .logged("tick", Info)
+//!         .run(run_mode, RunFor::Cycles(3)).unwrap();
 //! }
 //! ```
 //! This output is produced:
diff --git a/wingfoil/src/nodes/always.rs b/wingfoil/src/nodes/always.rs
index 6d6d48a..5f85363 100644
--- a/wingfoil/src/nodes/always.rs
+++ b/wingfoil/src/nodes/always.rs
@@ -4,23 +4,23 @@ use std::rc::Rc;
 
 struct AlwaysTickNode {}
 
-impl MutableNode for AlwaysTickNode {
-    fn cycle(&mut self, _: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a> MutableNode<'a> for AlwaysTickNode {
+    fn cycle(&mut self, _: &mut GraphState<'a>) -> anyhow::Result<bool> {
         Ok(true)
     }
 
-    fn upstreams(&self) -> UpStreams {
-        UpStreams::default()
+    fn upstreams(&self) -> UpStreams<'a> {
+        UpStreams::none()
     }
 
-    fn start(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn start(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         state.always_callback();
         Ok(())
     }
 }
 
 /// Produces a [Node] that ticks on every engine cycle.
-pub fn always() -> Rc<dyn Node> {
+pub fn always<'a>() -> Rc<dyn Node<'a> + 'a> {
     AlwaysTickNode {}.into_node()
 }
 
@@ -43,4 +43,4 @@ mod tests {
         let avg_period = duration / count;
         println!("{count} cycles.  {avg_period:?} per cycle");
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/nodes/async_io.rs b/wingfoil/src/nodes/async_io.rs
index 16855ee..659bef5 100644
--- a/wingfoil/src/nodes/async_io.rs
+++ b/wingfoil/src/nodes/async_io.rs
@@ -9,33 +9,34 @@ use std::future::Future;
 use std::pin::Pin;
 use std::rc::Rc;
 use tinyvec::TinyVec;
+use std::fmt::Debug;
 
 /// A convenience alias for [`futures::Stream`] with items of type `(NanoTime, T)`.
 /// used by [StreamOperators::consume_async].
-pub trait FutStream<T>: futures::Stream<Item = (NanoTime, T)> + Send {}
+pub trait FutStream<'a, T>: futures::Stream<Item = (NanoTime, T)> + Send {}
 
-impl<STRM, T> FutStream<T> for STRM where STRM: futures::Stream<Item = (NanoTime, T)> + Send {}
+impl<'a, STRM, T> FutStream<'a, T> for STRM where STRM: futures::Stream<Item = (NanoTime, T)> + Send {}
 
-type ConsumerFunc<T, FUT> = Box<dyn FnOnce(Pin<Box<dyn FutStream<T>>>) -> FUT + Send>;
+type ConsumerFunc<'a, T, FUT> = Box<dyn FnOnce(Pin<Box<dyn FutStream<'a, T>>>) -> FUT + Send>;
 
-pub(crate) struct AsyncConsumerNode<T, FUT>
+pub(crate) struct AsyncConsumerNode<'a, T, FUT>
 where
-    T: Element + Send,
+    T: Send + 'static,
     FUT: Future<Output = ()> + Send + 'static,
 {
-    source: Rc<dyn Stream<T>>,
+    source: Rc<dyn Stream<'a, T> + 'a>,
     sender: ChannelSender<T>,
-    func: Option<ConsumerFunc<T, FUT>>,
+    func: Option<ConsumerFunc<'static, T, FUT>>,
     handle: Option<tokio::task::JoinHandle<()>>,
     rx: Option<ChannelReceiver<T>>,
 }
 
-impl<T, FUT> AsyncConsumerNode<T, FUT>
+impl<'a, T, FUT> AsyncConsumerNode<'a, T, FUT>
 where
-    T: Element + Send,
+    T: Send + 'static,
     FUT: Future<Output = ()> + Send + 'static,
 {
-    pub fn new(source: Rc<dyn Stream<T>>, func: ConsumerFunc<T, FUT>) -> Self {
+    pub fn new(source: Rc<dyn Stream<'a, T> + 'a>, func: ConsumerFunc<'static, T, FUT>) -> Self {
         let (sender, receiver) = channel_pair(None);
         let rx = Some(receiver);
         let handle = None;
@@ -51,21 +52,21 @@ where
     }
 }
 
-impl<T, FUT> MutableNode for AsyncConsumerNode<T, FUT>
+impl<'a, T, FUT> MutableNode<'a> for AsyncConsumerNode<'a, T, FUT>
 where
-    T: Element + Send,
+    T: Debug + Clone + Send + 'static,
     FUT: Future<Output = ()> + Send + 'static,
 {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.sender.send(state, self.source.peek_value())?;
         Ok(true)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.source.clone().as_node()], vec![])
     }
 
-    fn setup(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn setup(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         let run_mode = state.run_mode();
         let run_for = state.run_for();
         let rx = self
@@ -89,12 +90,12 @@ where
         Ok(())
     }
 
-    fn stop(&mut self, _state: &mut GraphState) -> anyhow::Result<()> {
+    fn stop(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.sender.close()?;
         Ok(())
     }
 
-    fn teardown(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn teardown(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         if let Some(handle) = self.handle.take() {
             state.tokio_runtime().block_on(handle)?;
         }
@@ -102,22 +103,23 @@ where
     }
 }
 
-struct AsyncProducerStream<T, S, FUT, FUNC>
+struct AsyncProducerStream<'a, T, S, FUT, FUNC>
 where
-    T: Element + Send,
+    T: Send + 'static + Default,
     S: futures::Stream<Item = (NanoTime, T)> + Send + 'static,
     FUT: Future<Output = S> + Send + 'static,
     FUNC: FnOnce() -> FUT + Send + 'static,
 {
+    #[allow(dead_code)]
     func: Option<FUNC>,
-    receiver_stream: ReceiverStream<T>,
+    receiver_stream: ReceiverStream<'a, T>,
     handle: Option<tokio::task::JoinHandle<()>>,
     sender: Option<ChannelSender<T>>,
 }
 
-impl<T, S, FUT, FUNC> AsyncProducerStream<T, S, FUT, FUNC>
+impl<'a, T, S, FUT, FUNC> AsyncProducerStream<'a, T, S, FUT, FUNC>
 where
-    T: Element + Send,
+    T: Send + 'static + Default,
     S: futures::Stream<Item = (NanoTime, T)> + Send + 'static,
     FUT: Future<Output = S> + Send + 'static,
     FUNC: FnOnce() -> FUT + Send + 'static,
@@ -137,22 +139,22 @@ where
     }
 }
 
-impl<T, S, FUT, FUNC> MutableNode for AsyncProducerStream<T, S, FUT, FUNC>
+impl<'a, T, S, FUT, FUNC> MutableNode<'a> for AsyncProducerStream<'a, T, S, FUT, FUNC>
 where
-    T: Element + Send,
+    T: Debug + Clone + Send + 'static + Default,
     S: futures::Stream<Item = (NanoTime, T)> + Send + 'static,
     FUT: Future<Output = S> + Send + 'static,
     FUNC: FnOnce() -> FUT + Send + 'static,
 {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.receiver_stream.cycle(state)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::none()
     }
 
-    fn setup(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn setup(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         let run_mode = state.run_mode();
         let run_for = state.run_for();
         let mut sender = self
@@ -186,7 +188,7 @@ where
         Ok(())
     }
 
-    fn teardown(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn teardown(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.receiver_stream.teardown(state)?;
         if let Some(handle) = self.handle.take() {
             state.tokio_runtime().block_on(handle)?;
@@ -195,9 +197,9 @@ where
     }
 }
 
-impl<T, S, FUT, FUNC> StreamPeekRef<TinyVec<[T; 1]>> for AsyncProducerStream<T, S, FUT, FUNC>
+impl<'a, T, S, FUT, FUNC> StreamPeekRef<'a, TinyVec<[T; 1]>> for AsyncProducerStream<'a, T, S, FUT, FUNC>
 where
-    T: Element + Send,
+    T: Debug + Clone + Send + 'static + Default,
     S: futures::Stream<Item = (NanoTime, T)> + Send + 'static,
     FUT: Future<Output = S> + Send + 'static,
     FUNC: FnOnce() -> FUT + Send + 'static,
@@ -208,9 +210,9 @@ where
 }
 
 /// Create a [Stream] from futures::Stream
-pub fn produce_async<T, S, FUT, FUNC>(func: FUNC) -> Rc<dyn Stream<TinyVec<[T; 1]>>>
+pub fn produce_async<'a, T, S, FUT, FUNC>(func: FUNC) -> Rc<dyn Stream<'a, TinyVec<[T; 1]>> + 'a>
 where
-    T: Element + Send,
+    T: Debug + Clone + Send + Default + 'static,
     S: futures::Stream<Item = (NanoTime, T)> + Send + 'static,
     FUT: Future<Output = S> + Send + 'static,
     FUNC: FnOnce() -> FUT + Send + 'static,
@@ -218,14 +220,14 @@ where
     AsyncProducerStream::new(func).into_stream()
 }
 
-trait StreamMessageSource<T: Element + Send> {
+trait StreamMessageSource<T: Send> {
     fn to_message_stream(self, run_mode: RunMode) -> impl futures::Stream<Item = Message<T>>;
 }
 
 impl<T, STRM> StreamMessageSource<T> for STRM
 where
     STRM: futures::Stream<Item = (NanoTime, T)>,
-    T: Element + Send,
+    T: Send,
 {
     fn to_message_stream(self, run_mode: RunMode) -> impl futures::Stream<Item = Message<T>> {
         async_stream::stream! {
@@ -245,7 +247,7 @@ where
     }
 }
 
-trait MessageStream<T: Element + Send> {
+trait MessageStream<T: Send> {
     fn limit(self, run_mode: RunMode, run_for: RunFor) -> impl futures::Stream<Item = Message<T>>;
 
     fn to_stream(self) -> impl futures::Stream<Item = (NanoTime, T)>;
@@ -254,7 +256,7 @@ trait MessageStream<T: Element + Send> {
 impl<T, STRM> MessageStream<T> for STRM
 where
     STRM: futures::Stream<Item = Message<T>>,
-    T: Element + Send,
+    T: Send,
 {
     fn limit(self, run_mode: RunMode, run_for: RunFor) -> impl futures::Stream<Item = Message<T>> {
         async_stream::stream! {
@@ -320,7 +322,7 @@ mod tests {
     #[test]
     fn async_io_works() {
         let _ = env_logger::try_init();
-        let n_runs = 5;
+        let n_runs = 1;
         let period = Duration::from_millis(10);
         let n_periods = 5;
         let run_for = RunFor::Duration(period * n_periods);
diff --git a/wingfoil/src/nodes/average.rs b/wingfoil/src/nodes/average.rs
index 50bcd57..68d49ec 100644
--- a/wingfoil/src/nodes/average.rs
+++ b/wingfoil/src/nodes/average.rs
@@ -4,31 +4,32 @@ use derive_new::new;
 
 use num_traits::ToPrimitive;
 use std::rc::Rc;
+use std::fmt::Debug;
 
 /// Computes running average.  Used by [average](crate::nodes::StreamOperators::average).
 #[derive(new)]
-pub(crate) struct AverageStream<T: Element> {
-    upstream: Rc<dyn Stream<T>>,
+pub(crate) struct AverageStream<'a, T> {
+    upstream: Rc<dyn Stream<'a, T> + 'a>,
     #[new(default)]
     value: f64,
     #[new(default)]
     count: u64,
 }
 
-impl<T: Element + ToPrimitive> MutableNode for AverageStream<T> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: ToPrimitive + Debug + Clone + 'a> MutableNode<'a> for AverageStream<'a, T> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.count += 1;
         let sample = self.upstream.peek_value().to_f64().unwrap_or(f64::NAN);
         self.value += (sample - self.value) / self.count as f64;
         Ok(true)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
 
-impl<T: Element + ToPrimitive> StreamPeekRef<f64> for AverageStream<T> {
+impl<'a, T: ToPrimitive + Debug + Clone + 'a> StreamPeekRef<'a, f64> for AverageStream<'a, T> {
     fn peek_ref(&self) -> &f64 {
         &self.value
     }
diff --git a/wingfoil/src/nodes/bimap.rs b/wingfoil/src/nodes/bimap.rs
index 46dca99..39402ae 100644
--- a/wingfoil/src/nodes/bimap.rs
+++ b/wingfoil/src/nodes/bimap.rs
@@ -1,37 +1,44 @@
-use crate::types::*;
-use derive_new::new;
-
-use std::boxed::Box;
 use std::rc::Rc;
+use crate::types::*;
+use std::fmt::Debug;
 
-/// Maps two streams into a single stream.  Used by [add](crate::nodes::add).
-#[derive(new)]
-pub(crate) struct BiMapStream<IN1, IN2, OUT: Element> {
-    upstream1: Rc<dyn Stream<IN1>>,
-    upstream2: Rc<dyn Stream<IN2>>,
-    #[new(default)]
+pub(crate) struct BiMapStream<'a, IN1, IN2, OUT> {
+    upstream1: Rc<dyn Stream<'a, IN1> + 'a>,
+    upstream2: Rc<dyn Stream<'a, IN2> + 'a>,
     value: OUT,
-    func: Box<dyn Fn(IN1, IN2) -> OUT>,
+    func: Box<dyn Fn(IN1, IN2) -> OUT + 'a>,
+}
+
+impl<'a, IN1, IN2, OUT: Debug + Clone + Default + 'a> BiMapStream<'a, IN1, IN2, OUT> {
+    pub fn new(
+        upstream1: Rc<dyn Stream<'a, IN1> + 'a>,
+        upstream2: Rc<dyn Stream<'a, IN2> + 'a>,
+        func: Box<dyn Fn(IN1, IN2) -> OUT + 'a>,
+    ) -> Self {
+        Self {
+            upstream1,
+            upstream2,
+            value: OUT::default(),
+            func,
+        }
+    }
 }
 
-impl<IN1, IN2, OUT: Element> MutableNode for BiMapStream<IN1, IN2, OUT> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, IN1: Clone, IN2: Clone, OUT: Debug + Clone + 'a> MutableNode<'a> for BiMapStream<'a, IN1, IN2, OUT> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.value = (self.func)(self.upstream1.peek_value(), self.upstream2.peek_value());
         Ok(true)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(
-            vec![
-                self.upstream1.clone().as_node(),
-                self.upstream2.clone().as_node(),
-            ],
+            vec![self.upstream1.clone().as_node(), self.upstream2.clone().as_node()],
             vec![],
         )
     }
 }
 
-impl<IN1: 'static, IN2: 'static, OUT: Element> StreamPeekRef<OUT> for BiMapStream<IN1, IN2, OUT> {
+impl<'a, IN1: Clone, IN2: Clone, OUT: Debug + Clone + 'a> StreamPeekRef<'a, OUT> for BiMapStream<'a, IN1, IN2, OUT> {
     fn peek_ref(&self) -> &OUT {
         &self.value
     }
diff --git a/wingfoil/src/nodes/buffer.rs b/wingfoil/src/nodes/buffer.rs
index 53bac0b..58d9ae3 100644
--- a/wingfoil/src/nodes/buffer.rs
+++ b/wingfoil/src/nodes/buffer.rs
@@ -1,16 +1,17 @@
 use crate::types::*;
 
 use std::rc::Rc;
+use std::fmt::Debug;
 
-pub(crate) struct BufferStream<T: Element> {
-    upstream: Rc<dyn Stream<T>>,
+pub(crate) struct BufferStream<'a, T: Debug + Clone + 'a> {
+    upstream: Rc<dyn Stream<'a, T> + 'a>,
     capacity: usize,
     buffer: Vec<T>,
     value: Vec<T>,
 }
 
-impl<T: Element> MutableNode for BufferStream<T> {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + 'a> MutableNode<'a> for BufferStream<'a, T> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.buffer.push(self.upstream.peek_value());
         if self.buffer.len() >= self.capacity || (!self.buffer.is_empty() && state.is_last_cycle())
         {
@@ -22,19 +23,19 @@ impl<T: Element> MutableNode for BufferStream<T> {
             Ok(false)
         }
     }
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
 
-impl<T: Element> StreamPeekRef<Vec<T>> for BufferStream<T> {
+impl<'a, T: Debug + Clone + 'a> StreamPeekRef<'a, Vec<T>> for BufferStream<'a, T> {
     fn peek_ref(&self) -> &Vec<T> {
         &self.value
     }
 }
 
-impl<T: Element> BufferStream<T> {
-    pub fn new(upstream: Rc<dyn Stream<T>>, capacity: usize) -> Self {
+impl<'a, T: Debug + Clone + 'a> BufferStream<'a, T> {
+    pub fn new(upstream: Rc<dyn Stream<'a, T> + 'a>, capacity: usize) -> Self {
         Self {
             upstream,
             capacity,
@@ -49,6 +50,7 @@ mod tests {
 
     use crate::graph::*;
     use crate::nodes::*;
+    use std::time::Duration;
 
     #[test]
     fn buffer_stream_works() {
@@ -62,6 +64,10 @@ mod tests {
                 buffer.run(mode, run_for).unwrap();
                 let buffer = buffer.peek_value();
                 let src = count.peek_value();
+                if buffer.is_empty() {
+                    println!("{:?}, {:?}, src={:?}, buffer is empty!", mode, run_for, src);
+                    continue; // Or handle as error if appropriate
+                }
                 let buffered = buffer[buffer.len() - 1];
                 info!("{:?}, {:?}, {:?}, {:?}", mode, run_for, src, buffered);
                 assert_eq!(src, buffered);
diff --git a/wingfoil/src/nodes/callback.rs b/wingfoil/src/nodes/callback.rs
index b601ff7..e5a2ec2 100644
--- a/wingfoil/src/nodes/callback.rs
+++ b/wingfoil/src/nodes/callback.rs
@@ -1,57 +1,67 @@
-use std::cmp::Eq;
-use std::hash::Hash;
-
-use crate::queue::{TimeQueue, ValueAt};
 use crate::types::*;
+use crate::queue::{TimeQueue, ValueAt};
+use std::hash::Hash;
+use std::fmt::Debug;
 
-use derive_new::new;
-
-/// A queue of values that are emitted at specified times.  Useful for
-/// unit tests.  Can also be used to feed stream output back into
-/// the [Graph](crate::graph::Graph) as input on later cycles.
-#[derive(new)]
-pub struct CallBackStream<T: Element + Hash + Eq> {
-    #[new(default)]
+/// A [Stream] which can be updated by calling [push](CallBackStream::push).
+/// Useful for unit testing.
+pub struct CallBackStream<'a, T: Debug + Clone + 'a + Hash + Eq> {
     value: T,
-    #[new(default)]
     queue: TimeQueue<T>,
+    _phantom: std::marker::PhantomData<&'a T>,
+}
+
+impl<'a, T: Debug + Clone + 'a + Hash + Eq + Default> Default for CallBackStream<'a, T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'a, T: Debug + Clone + 'a + Hash + Eq + Default> CallBackStream<'a, T> {
+    pub fn new() -> Self {
+        Self {
+            value: T::default(),
+            queue: TimeQueue::new(),
+            _phantom: std::marker::PhantomData,
+        }
+    }
 }
 
-impl<T: Element + Hash + Eq> StreamPeekRef<T> for CallBackStream<T> {
+impl<'a, T: Debug + Clone + 'a + Hash + Eq + Default> StreamPeekRef<'a, T> for CallBackStream<'a, T> {
     fn peek_ref(&self) -> &T {
         &self.value
     }
 }
 
-impl<T: Element + Hash + Eq> MutableNode for CallBackStream<T> {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + 'a + Hash + Eq + Default> MutableNode<'a> for CallBackStream<'a, T> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
+        let current_time = state.time();
         let mut ticked = false;
-        while self.queue.pending(state.time()) {
+        while self.queue.pending(current_time) {
             self.value = self.queue.pop();
             ticked = true;
         }
+        // Schedule next tick if queue is not empty
         if !self.queue.is_empty() {
-            let callback_time = self.queue.next_time();
-            state.add_callback(callback_time);
+            state.add_callback(self.queue.next_time());
         }
         Ok(ticked)
     }
 
-    fn upstreams(&self) -> UpStreams {
-        UpStreams::default()
+    fn upstreams(&self) -> UpStreams<'a> {
+        UpStreams::none()
     }
 
-    fn start(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn setup(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         if !self.queue.is_empty() {
-            let time = self.queue.next_time();
-            state.add_callback(time);
+            state.add_callback(self.queue.next_time());
         }
         Ok(())
     }
 }
 
-impl<T: Element + Hash + Eq> CallBackStream<T> {
-    pub fn push(&mut self, value_at: ValueAt<T>) {
-        self.queue.push(value_at.value, value_at.time)
+impl<'a, T: Debug + Clone + 'a + Hash + Eq> CallBackStream<'a, T> {
+    pub fn push(&mut self, value: ValueAt<T>) {
+        self.queue.push(value.value, value.time);
     }
 }
diff --git a/wingfoil/src/nodes/channel.rs b/wingfoil/src/nodes/channel.rs
index 63c5153..7b88f37 100644
--- a/wingfoil/src/nodes/channel.rs
+++ b/wingfoil/src/nodes/channel.rs
@@ -8,40 +8,41 @@ use std::collections::VecDeque;
 use std::option::Option;
 use std::rc::Rc;
 use tinyvec::TinyVec;
+use std::fmt::Debug as StdDebug;
 
-pub(crate) trait ChannelOperators<T>
+pub(crate) trait ChannelOperators<'a, T>
 where
-    T: Element + Send,
+    T: Send + 'static,
 {
     fn send(
         self: &Rc<Self>,
         sender: ChannelSender<T>,
-        trigger: Option<Rc<dyn Node>>,
-    ) -> Rc<dyn Node>;
+        trigger: Option<Rc<dyn Node<'a> + 'a>>,
+    ) -> Rc<dyn Node<'a> + 'a>;
 }
 
-impl<T> ChannelOperators<T> for dyn Stream<T>
+impl<'a, T> ChannelOperators<'a, T> for dyn Stream<'a, T> + 'a
 where
-    T: Element + Send,
+    T: StdDebug + Clone + Default + Send + 'static,
 {
     fn send(
         self: &Rc<Self>,
         sender: ChannelSender<T>,
-        trigger: Option<Rc<dyn Node>>,
-    ) -> Rc<dyn Node> {
+        trigger: Option<Rc<dyn Node<'a> + 'a>>,
+    ) -> Rc<dyn Node<'a> + 'a> {
         SenderNode::new(self.clone(), sender, trigger).into_node()
     }
 }
 
 #[derive(new)]
-pub(crate) struct SenderNode<T: Element + Send> {
-    source: Rc<dyn Stream<T>>,
+pub(crate) struct SenderNode<'a, T: Send + 'static> {
+    source: Rc<dyn Stream<'a, T> + 'a>,
     sender: ChannelSender<T>,
-    trigger: Option<Rc<dyn Node>>,
+    trigger: Option<Rc<dyn Node<'a> + 'a>>,
 }
 
-impl<T: Element + Send> MutableNode for SenderNode<T> {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: StdDebug + Clone + Send + 'static> MutableNode<'a> for SenderNode<'a, T> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         //println!("SenderNode::cycle");
         if state.ticked(self.source.clone().as_node()) {
             self.sender.send(state, self.source.peek_value())?;
@@ -60,7 +61,7 @@ impl<T: Element + Send> MutableNode for SenderNode<T> {
         }
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         let mut upstreams = vec![self.source.clone().as_node()];
         if let Some(trig) = &self.trigger {
             upstreams.push(trig.clone());
@@ -68,17 +69,17 @@ impl<T: Element + Send> MutableNode for SenderNode<T> {
         UpStreams::new(upstreams, Vec::new())
     }
 
-    fn stop(&mut self, _state: &mut GraphState) -> anyhow::Result<()> {
+    fn stop(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.sender.send_message(Message::EndOfStream)?;
         Ok(())
     }
 }
 
 #[derive(new, Debug)]
-pub(crate) struct ReceiverStream<T: Element + Send> {
+pub(crate) struct ReceiverStream<'a, T: Send + Default + 'static> {
     receiver: ChannelReceiver<T>,
     #[debug(skip)]
-    trigger: Option<Rc<dyn Node>>,
+    trigger: Option<Rc<dyn Node<'a> + 'a>>,
     notifier_channel: Option<NotifierChannelSender>,
     #[new(default)]
     value: TinyVec<[T; 1]>,
@@ -90,8 +91,8 @@ pub(crate) struct ReceiverStream<T: Element + Send> {
     queue: VecDeque<ValueAt<T>>,
 }
 
-impl<T: Element + Send> MutableNode for ReceiverStream<T> {
-    fn cycle(&mut self, state: &mut crate::GraphState) -> anyhow::Result<bool> {
+impl<'a, T: StdDebug + Clone + Send + Default + 'static> MutableNode<'a> for ReceiverStream<'a, T> {
+    fn cycle(&mut self, state: &mut crate::GraphState<'a>) -> anyhow::Result<bool> {
         //println!("ReceiverStream::cycle start {:?}", state.time());
         let mut values: TinyVec<[T; 1]> = TinyVec::new();
         match state.run_mode() {
@@ -183,7 +184,7 @@ impl<T: Element + Send> MutableNode for ReceiverStream<T> {
         }
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         let mut ups = Vec::new();
         if let Some(trigger) = &self.trigger {
             ups.push(trigger.clone());
@@ -191,7 +192,7 @@ impl<T: Element + Send> MutableNode for ReceiverStream<T> {
         UpStreams::new(ups, vec![])
     }
 
-    fn setup(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn setup(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         match state.run_mode() {
             RunMode::RealTime => {
                 if let Some(chan) = self.notifier_channel.take() {
@@ -208,13 +209,13 @@ impl<T: Element + Send> MutableNode for ReceiverStream<T> {
         Ok(())
     }
 
-    fn teardown(&mut self, _: &mut GraphState) -> anyhow::Result<()> {
+    fn teardown(&mut self, _: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.receiver.teardown();
         Ok(())
     }
 }
 
-impl<T: Element + Send> StreamPeekRef<TinyVec<[T; 1]>> for ReceiverStream<T> {
+impl<'a, T: StdDebug + Clone + Send + Default + 'static> StreamPeekRef<'a, TinyVec<[T; 1]>> for ReceiverStream<'a, T> {
     fn peek_ref(&self) -> &TinyVec<[T; 1]> {
         &self.value
     }
diff --git a/wingfoil/src/nodes/combine.rs b/wingfoil/src/nodes/combine.rs
index e81c268..0cd4cf9 100644
--- a/wingfoil/src/nodes/combine.rs
+++ b/wingfoil/src/nodes/combine.rs
@@ -4,48 +4,49 @@ use derive_new::new;
 use std::cell::RefCell;
 use std::rc::Rc;
 use tinyvec::TinyVec;
+use std::fmt::Debug;
 
 #[derive(new)]
-struct CombineNode<T: Element> {
-    upstream: Rc<dyn Stream<T>>,
+struct CombineNode<'a, T: Debug + Clone + Default + 'a> {
+    upstream: Rc<dyn Stream<'a, T> + 'a>,
     combined: Rc<RefCell<TinyVec<[T; 1]>>>,
 }
 
-impl<T: Element> MutableNode for CombineNode<T> {
-    fn cycle(&mut self, _: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + Default + 'a> MutableNode<'a> for CombineNode<'a, T> {
+    fn cycle(&mut self, _: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.combined.borrow_mut().push(self.upstream.peek_value());
         Ok(true)
     }
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
 
 #[derive(new)]
-struct CombineStream2<T: Element> {
-    upstreams: Vec<Rc<dyn Node>>,
+struct CombineStream2<'a, T: Debug + Clone + Default + 'a> {
+    upstreams: Vec<Rc<dyn Node<'a> + 'a>>,
     combined: Rc<RefCell<TinyVec<[T; 1]>>>,
     #[new(default)]
     value: TinyVec<[T; 1]>,
 }
 
-impl<T: Element> MutableNode for CombineStream2<T> {
-    fn cycle(&mut self, _: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + Default + 'a> MutableNode<'a> for CombineStream2<'a, T> {
+    fn cycle(&mut self, _: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.value = std::mem::replace(&mut *self.combined.borrow_mut(), TinyVec::new());
         Ok(true)
     }
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(self.upstreams.clone(), vec![])
     }
 }
 
-impl<T: Element> StreamPeekRef<TinyVec<[T; 1]>> for CombineStream2<T> {
+impl<'a, T: Debug + Clone + Default + 'a> StreamPeekRef<'a, TinyVec<[T; 1]>> for CombineStream2<'a, T> {
     fn peek_ref(&self) -> &TinyVec<[T; 1]> {
         &self.value
     }
 }
 
-pub fn combine<T: Element>(streams: Vec<Rc<dyn Stream<T>>>) -> Rc<dyn Stream<TinyVec<[T; 1]>>> {
+pub fn combine<'a, T: Debug + Clone + Default + 'a>(streams: Vec<Rc<dyn Stream<'a, T> + 'a>>) -> Rc<dyn Stream<'a, TinyVec<[T; 1]>> + 'a> {
     let combined = Rc::new(RefCell::new(TinyVec::new()));
     let nodes = streams
         .iter()
@@ -84,4 +85,4 @@ mod tests {
             .run(run_mode, run_for)
             .unwrap();
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/nodes/constant.rs b/wingfoil/src/nodes/constant.rs
index e351bbd..aab3c97 100644
--- a/wingfoil/src/nodes/constant.rs
+++ b/wingfoil/src/nodes/constant.rs
@@ -1,51 +1,44 @@
 use crate::types::*;
-use derive_new::new;
+use std::fmt::Debug;
 
-/// Only ticks once (on the first [Graph](crate::graph::Graph) cycle).
-#[derive(new)]
-pub(crate) struct ConstantStream<T: Element> {
+pub(crate) struct ConstantStream<'a, T: Debug + Clone + 'a> {
     value: T,
+    ticked: bool,
+    _phantom: std::marker::PhantomData<&'a T>,
 }
 
-impl<T: Element> MutableNode for ConstantStream<T> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
-        Ok(true)
+impl<'a, T: Debug + Clone + 'a> ConstantStream<'a, T> {
+    pub fn new(value: T) -> Self {
+        Self {
+            value,
+            ticked: false,
+            _phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, T: Debug + Clone + 'a> MutableNode<'a> for ConstantStream<'a, T> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
+        if !self.ticked {
+            self.ticked = true;
+            Ok(true)
+        } else {
+            Ok(false)
+        }
     }
 
-    fn upstreams(&self) -> UpStreams {
-        UpStreams::default()
+    fn upstreams(&self) -> UpStreams<'a> {
+        UpStreams::none()
     }
 
-    fn start(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
-        state.add_callback(NanoTime::ZERO);
+    fn start(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
+        state.always_callback();
         Ok(())
     }
 }
 
-impl<T: Element> StreamPeekRef<T> for ConstantStream<T> {
+impl<'a, T: Debug + Clone + 'a> StreamPeekRef<'a, T> for ConstantStream<'a, T> {
     fn peek_ref(&self) -> &T {
         &self.value
     }
 }
-
-#[cfg(test)]
-mod tests {
-
-    use crate::*;
-
-    #[test]
-    fn constant_value_works() {
-        let x = 7;
-        let const_value = constant(x);
-        assert_eq!(const_value.peek_value(), x);
-        let captured = const_value.collect();
-        captured
-            .run(RunMode::HistoricalFrom(NanoTime::ZERO), RunFor::Forever)
-            .unwrap();
-        let expected = vec![ValueAt {
-            value: x,
-            time: NanoTime::new(0),
-        }];
-        assert_eq!(expected, captured.peek_value());
-    }
-}
diff --git a/wingfoil/src/nodes/consumer.rs b/wingfoil/src/nodes/consumer.rs
index 80df76e..ada5c3c 100644
--- a/wingfoil/src/nodes/consumer.rs
+++ b/wingfoil/src/nodes/consumer.rs
@@ -8,18 +8,18 @@ use crate::types::*;
 /// Applies function to it's source.  It is a [Node] - it
 /// doesn't produce anything.  Used by [consume](crate::nodes::StreamOperators::for_each).
 #[derive(new)]
-pub(crate) struct ConsumerNode<IN> {
-    upstream: Rc<dyn Stream<IN>>,
-    func: Box<dyn Fn(IN, NanoTime)>,
+pub(crate) struct ConsumerNode<'a, IN> {
+    upstream: Rc<dyn Stream<'a, IN> + 'a>,
+    func: Box<dyn Fn(IN, NanoTime) + 'a>,
 }
 
-impl<IN> MutableNode for ConsumerNode<IN> {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, IN: Clone> MutableNode<'a> for ConsumerNode<'a, IN> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         (self.func)(self.upstream.peek_value(), state.time());
         Ok(true)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
diff --git a/wingfoil/src/nodes/delay.rs b/wingfoil/src/nodes/delay.rs
index 00ee8cc..0b98439 100644
--- a/wingfoil/src/nodes/delay.rs
+++ b/wingfoil/src/nodes/delay.rs
@@ -4,21 +4,29 @@ use std::rc::Rc;
 
 use crate::queue::TimeQueue;
 use crate::types::*;
-use derive_new::new;
+use std::fmt::Debug;
 
 /// Emits it's source delayed by the specified time
-#[derive(new)]
-pub(crate) struct DelayStream<T: Element + Hash + Eq> {
-    #[new(default)]
+pub(crate) struct DelayStream<'a, T: Debug + Clone + 'a + Hash + Eq> {
     value: T,
-    #[new(default)]
     queue: TimeQueue<T>,
-    upstream: Rc<dyn Stream<T>>,
+    upstream: Rc<dyn Stream<'a, T> + 'a>,
     delay: NanoTime,
 }
 
-impl<T: Element + Hash + Eq> MutableNode for DelayStream<T> {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + 'a + Hash + Eq + Default> DelayStream<'a, T> {
+    pub fn new(upstream: Rc<dyn Stream<'a, T> + 'a>, delay: NanoTime) -> Self {
+        Self {
+            value: T::default(),
+            queue: TimeQueue::new(),
+            upstream,
+            delay,
+        }
+    }
+}
+
+impl<'a, T: Debug + Clone + 'a + Hash + Eq> MutableNode<'a> for DelayStream<'a, T> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         if self.delay == NanoTime::ZERO {
             // just tick on this cycle
             self.value = self.upstream.peek_value();
@@ -39,12 +47,12 @@ impl<T: Element + Hash + Eq> MutableNode for DelayStream<T> {
         }
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
 
-impl<T: Element + Hash + Eq> StreamPeekRef<T> for DelayStream<T> {
+impl<'a, T: Debug + Clone + 'a + Hash + Eq> StreamPeekRef<'a, T> for DelayStream<'a, T> {
     fn peek_ref(&self) -> &T {
         &self.value
     }
@@ -175,4 +183,4 @@ mod tests {
         ];
         assert_eq!(expected, delayed.peek_value());
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/nodes/demux.rs b/wingfoil/src/nodes/demux.rs
index b1c2b3d..69c0fc9 100644
--- a/wingfoil/src/nodes/demux.rs
+++ b/wingfoil/src/nodes/demux.rs
@@ -1,5 +1,4 @@
-use crate::{
-    Element, GraphState, IntoStream, MutableNode, Node, Stream, StreamOperators, StreamPeekRef,
+use crate::{    GraphState, IntoStream, MutableNode, Node, Stream, StreamOperators, StreamPeekRef,
     UpStreams,
 };
 use derive_more::Debug;
@@ -11,6 +10,7 @@ use std::fmt;
 use std::hash::Hash;
 use std::rc::Rc;
 use tinyvec::TinyVec;
+use std::fmt::Debug as StdDebug;
 
 /// A message used to signal that a demuxed child stream
 /// can be closed.   Used by [StreamOperators::demux] and [StreamOperators::demux_it]
@@ -34,7 +34,8 @@ where
     inner: Rc<RefCell<DemuxMapInner<K>>>,
 }
 
-impl<K> DemuxMap<K>
+impl<K>
+    DemuxMap<K>
 where
     K: Hash + Eq + PartialEq + fmt::Debug,
 {
@@ -52,7 +53,7 @@ where
         self.inner.borrow_mut().release(key)
     }
 
-    fn size(&self) -> usize {
+    pub fn size(&self) -> usize {
         self.inner.borrow().size
     }
 }
@@ -67,7 +68,8 @@ where
     size: usize,
 }
 
-impl<K> DemuxMapInner<K>
+impl<K>
+    DemuxMapInner<K>
 where
     K: Hash + Eq + PartialEq + std::fmt::Debug,
 {
@@ -125,27 +127,28 @@ where
 /// Represents a [Stream] of values that failed to be demuxed because the
 /// the demux capacity was exceeded.   Output of [StreamOperators::demux] and
 /// [StreamOperators::demux_it].
-pub struct Overflow<T: Element>(Rc<RefCell<Option<Rc<dyn Stream<T>>>>>);
-impl<T: Element> Overflow<T> {
-    pub fn stream(&self) -> Rc<dyn Stream<T>> {
+pub struct Overflow<'a, T: StdDebug + Clone + 'a>(Rc<RefCell<Option<Rc<dyn Stream<'a, T> + 'a>>>>);
+impl<'a, T: StdDebug + Clone + 'a> Overflow<'a, T> {
+    pub fn stream(&self) -> Rc<dyn Stream<'a, T> + 'a> {
         self.0.borrow().clone().unwrap()
     }
-    pub fn panic(&self) -> Rc<dyn Node> {
+    pub fn panic(&self) -> Rc<dyn Node<'a> + 'a>
+    where T: Default + 'static {
         self.stream().for_each(move |itm, _| {
-            panic!("overflow!\n{itm:?}");
+            panic!("overflow!\n{:?}", itm);
         })
     }
 }
 
-pub(crate) fn demux<K, T, F>(
-    source: Rc<dyn Stream<T>>,
+pub(crate) fn demux<'a, K, T, F>(
+    source: Rc<dyn Stream<'a, T> + 'a>,
     map: DemuxMap<K>,
     func: F,
-) -> (Vec<Rc<dyn Stream<T>>>, Overflow<T>)
+) -> (Vec<Rc<dyn Stream<'a, T> + 'a>>, Overflow<'a, T>)
 where
-    K: Hash + Eq + PartialEq + fmt::Debug + 'static,
-    T: Element,
-    F: Fn(&T) -> (K, DemuxEvent) + 'static,
+    K: Hash + Eq + PartialEq + fmt::Debug + 'a,
+    T: StdDebug + Clone + Default + 'a,
+    F: Fn(&T) -> (K, DemuxEvent) + 'a,
 {
     let size = map.size();
     let overflow = Rc::new(RefCell::new(None));
@@ -166,18 +169,18 @@ where
 }
 
 #[derive(new, Debug)]
-struct DemuxParent<T, F, K>
+struct DemuxParent<'a, T, F, K>
 where
-    T: Element,
+    T: StdDebug + Clone + Default + 'a,
     F: Fn(&T) -> (K, DemuxEvent),
     K: Hash + Eq + PartialEq + std::fmt::Debug,
 {
-    source: Rc<dyn Stream<T>>,
+    source: Rc<dyn Stream<'a, T> + 'a>,
     func: F,
     #[debug(skip)]
     map: DemuxMap<K>,
-    children: Rc<RefCell<Vec<Rc<dyn Stream<T>>>>>,
-    overflow_child: Rc<RefCell<Option<Rc<dyn Stream<T>>>>>,
+    children: Rc<RefCell<Vec<Rc<dyn Stream<'a, T> + 'a>>>>,
+    overflow_child: Rc<RefCell<Option<Rc<dyn Stream<'a, T> + 'a>>>>,
     #[new(default)]
     value: T,
     #[new(default)]
@@ -187,9 +190,9 @@ where
     overflow_graph_index: Option<usize>,
 }
 
-impl<T, F, K> StreamPeekRef<T> for DemuxParent<T, F, K>
+impl<'a, T, F, K> StreamPeekRef<'a, T> for DemuxParent<'a, T, F, K>
 where
-    T: Element,
+    T: StdDebug + Clone + Default + 'a,
     F: Fn(&T) -> (K, DemuxEvent),
     K: Hash + Eq + PartialEq + std::fmt::Debug,
 {
@@ -198,13 +201,13 @@ where
     }
 }
 
-impl<T, K, F> MutableNode for DemuxParent<T, F, K>
+impl<'a, T, K, F> MutableNode<'a> for DemuxParent<'a, T, F, K>
 where
-    T: Element,
+    T: StdDebug + Clone + Default + 'a,
     F: Fn(&T) -> (K, DemuxEvent),
     K: Hash + Eq + PartialEq + std::fmt::Debug,
 {
-    fn cycle(&mut self, graph_state: &mut GraphState) -> anyhow::Result<bool> {
+    fn cycle(&mut self, graph_state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.value = self.source.peek_value();
         let (key, event) = (self.func)(&self.value);
         let entry = match event {
@@ -220,7 +223,7 @@ where
         Ok(false)
     }
 
-    fn setup(&mut self, graph_state: &mut GraphState) -> anyhow::Result<()> {
+    fn setup(&mut self, graph_state: &mut GraphState<'a>) -> anyhow::Result<()> {
         let mut childes = self.children.borrow_mut();
         let mut node_indexes: Vec<_> = childes
             .drain(..)
@@ -250,41 +253,35 @@ where
         Ok(())
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         let nodes = vec![self.source.clone().as_node()];
         UpStreams::new(nodes, vec![])
     }
 }
 
 #[derive(new)]
-struct DemuxChild<T>
+struct DemuxChild<'a, T>
 where
-    T: Element,
+    T: StdDebug + Clone + Default + 'a,
 {
-    source: Rc<dyn Stream<T>>,
+    source: Rc<dyn Stream<'a, T> + 'a>,
     #[new(default)]
     value: T,
 }
 
-impl<T> MutableNode for DemuxChild<T>
-where
-    T: Element,
-{
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: StdDebug + Clone + Default + 'a> MutableNode<'a> for DemuxChild<'a, T> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.value = self.source.peek_value();
         Ok(true)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         // source never ticks but use passive wiring anyway
         UpStreams::new(vec![], vec![self.source.clone().as_node()])
     }
 }
 
-impl<T> StreamPeekRef<T> for DemuxChild<T>
-where
-    T: Element,
-{
+impl<'a, T: StdDebug + Clone + Default + 'a> StreamPeekRef<'a, T> for DemuxChild<'a, T> {
     fn peek_ref(&self) -> &T {
         &self.value
     }
@@ -292,19 +289,52 @@ where
 
 /////////////////////////////////////
 
-pub(crate) fn demux_it<K, T, F, I>(
-    source: Rc<dyn Stream<I>>,
+pub fn demux_it<'a, T, F, K, I>(
+    source: Rc<dyn Stream<'a, I> + 'a>,
+    capacity: usize,
+    func: F,
+) -> (
+    Vec<Rc<dyn Stream<'a, TinyVec<[T; 1]>> + 'a>>,
+    Overflow<'a, TinyVec<[T; 1]>>,
+)
+where
+    T: StdDebug + Clone + Default + 'a,
+    K: Hash + Eq + PartialEq + std::fmt::Debug + 'a,
+    F: Fn(&T) -> (K, DemuxEvent) + 'a,
+    I: IntoIterator<Item = T> + StdDebug + Clone + Default + 'a,
+{
+    let map = DemuxMap::new(capacity);
+    let size = map.size();
+    let overflow = Rc::new(RefCell::new(None));
+    let children = Rc::new(RefCell::new(vec![]));
+    let value = vec![TinyVec::new(); size + 1];
+    let parent = DemuxVecParent::new(source, func, map, children.clone(), overflow.clone(), value)
+        .into_stream();
+    let build_child = |i| DemuxVecChild::new(i, parent.clone()).into_stream();
+    let demuxed = (0..size).map(build_child).collect::<Vec<_>>();
+    assert!(overflow.borrow().is_none());
+    overflow.borrow_mut().replace(build_child(size));
+    assert!(overflow.borrow().is_some());
+    demuxed.iter().for_each(|strm| {
+        children.borrow_mut().push(strm.clone());
+    });
+    let overflow = Overflow(overflow);
+    (demuxed, overflow)
+}
+
+pub fn demux_it_with_map<'a, T, F, K, I>(
+    source: Rc<dyn Stream<'a, I> + 'a>,
     map: DemuxMap<K>,
     func: F,
 ) -> (
-    Vec<Rc<dyn Stream<TinyVec<[T; 1]>>>>,
-    Overflow<TinyVec<[T; 1]>>,
+    Vec<Rc<dyn Stream<'a, TinyVec<[T; 1]>> + 'a>>,
+    Overflow<'a, TinyVec<[T; 1]>>,
 )
 where
-    K: Hash + Eq + PartialEq + fmt::Debug + 'static,
-    T: Element,
-    F: Fn(&T) -> (K, DemuxEvent) + 'static,
-    I: IntoIterator<Item = T> + Element,
+    T: StdDebug + Clone + Default + 'a,
+    K: Hash + Eq + PartialEq + std::fmt::Debug + 'a,
+    F: Fn(&T) -> (K, DemuxEvent) + 'a,
+    I: IntoIterator<Item = T> + StdDebug + Clone + Default + 'a,
 {
     let size = map.size();
     let overflow = Rc::new(RefCell::new(None));
@@ -324,20 +354,21 @@ where
     (demuxed, overflow)
 }
 
+
 #[derive(new, Debug)]
-struct DemuxVecParent<T, F, K, I>
+struct DemuxVecParent<'a, T, F, K, I>
 where
-    T: Element,
+    T: StdDebug + Clone + Default + 'a,
     F: Fn(&T) -> (K, DemuxEvent),
     K: Hash + Eq + PartialEq + std::fmt::Debug,
-    I: IntoIterator<Item = T> + Element,
+    I: IntoIterator<Item = T> + StdDebug + Clone,
 {
-    source: Rc<dyn Stream<I>>,
+    source: Rc<dyn Stream<'a, I> + 'a>,
     func: F,
     #[debug(skip)]
     map: DemuxMap<K>,
-    children: Rc<RefCell<Vec<Rc<dyn Stream<TinyVec<[T; 1]>>>>>>,
-    overflow_child: Rc<RefCell<Option<Rc<dyn Stream<TinyVec<[T; 1]>>>>>>,
+    children: Rc<RefCell<Vec<Rc<dyn Stream<'a, TinyVec<[T; 1]>> + 'a>>>>,
+    overflow_child: Rc<RefCell<Option<Rc<dyn Stream<'a, TinyVec<[T; 1]>> + 'a>>>>,
     value: Vec<TinyVec<[T; 1]>>,
     #[new(default)]
     // map from child node index to its index in the graph
@@ -346,26 +377,26 @@ where
     overflow_graph_index: Option<usize>,
 }
 
-impl<T, F, K, I> StreamPeekRef<Vec<TinyVec<[T; 1]>>> for DemuxVecParent<T, F, K, I>
+impl<'a, T, F, K, I> StreamPeekRef<'a, Vec<TinyVec<[T; 1]>>> for DemuxVecParent<'a, T, F, K, I>
 where
-    T: Element,
+    T: StdDebug + Clone + Default + 'a,
     F: Fn(&T) -> (K, DemuxEvent),
     K: Hash + Eq + PartialEq + std::fmt::Debug,
-    I: IntoIterator<Item = T> + Element,
+    I: IntoIterator<Item = T> + StdDebug + Clone,
 {
     fn peek_ref(&self) -> &Vec<TinyVec<[T; 1]>> {
         &self.value
     }
 }
 
-impl<T, K, F, I> MutableNode for DemuxVecParent<T, F, K, I>
+impl<'a, T, K, F, I> MutableNode<'a> for DemuxVecParent<'a, T, F, K, I>
 where
-    T: Element,
+    T: StdDebug + Clone + Default + 'a,
     F: Fn(&T) -> (K, DemuxEvent),
     K: Hash + Eq + PartialEq + std::fmt::Debug,
-    I: IntoIterator<Item = T> + Element,
+    I: IntoIterator<Item = T> + StdDebug + Clone,
 {
-    fn cycle(&mut self, graph_state: &mut GraphState) -> anyhow::Result<bool> {
+    fn cycle(&mut self, graph_state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         for row in &mut self.value {
             row.clear();
         }
@@ -393,7 +424,7 @@ where
         Ok(false)
     }
 
-    fn setup(&mut self, graph_state: &mut GraphState) -> anyhow::Result<()> {
+    fn setup(&mut self, graph_state: &mut GraphState<'a>) -> anyhow::Result<()> {
         let mut childes = self.children.borrow_mut();
         let mut node_indexes: Vec<_> = childes
             .drain(..)
@@ -420,42 +451,36 @@ where
         Ok(())
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         let nodes = vec![self.source.clone().as_node()];
         UpStreams::new(nodes, vec![])
     }
 }
 
 #[derive(new)]
-struct DemuxVecChild<T>
+struct DemuxVecChild<'a, T>
 where
-    T: Element,
+    T: StdDebug + Clone + Default + 'a,
 {
     index: usize,
-    source: Rc<dyn Stream<Vec<TinyVec<[T; 1]>>>>,
+    source: Rc<dyn Stream<'a, Vec<TinyVec<[T; 1]>>> + 'a>,
     #[new(default)]
     value: TinyVec<[T; 1]>,
 }
 
-impl<T> MutableNode for DemuxVecChild<T>
-where
-    T: Element,
-{
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: StdDebug + Clone + Default + 'a> MutableNode<'a> for DemuxVecChild<'a, T> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.value = self.source.peek_ref_cell().get(self.index).unwrap().clone();
         Ok(true)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         // source never ticks but use passive wiring anyway
         UpStreams::new(vec![], vec![self.source.clone().as_node()])
     }
 }
 
-impl<T> StreamPeekRef<TinyVec<[T; 1]>> for DemuxVecChild<T>
-where
-    T: Element,
-{
+impl<'a, T: StdDebug + Clone + Default + 'a> StreamPeekRef<'a, TinyVec<[T; 1]>> for DemuxVecChild<'a, T> {
     fn peek_ref(&self) -> &TinyVec<[T; 1]> {
         &self.value
     }
@@ -494,7 +519,7 @@ mod tests {
         message_type: MessageType,
     }
 
-    fn message_source(stream_id: usize, delay: Option<Duration>) -> Rc<dyn Stream<Message>> {
+    fn message_source<'a>(stream_id: usize, delay: Option<Duration>) -> Rc<dyn Stream<'a, Message> + 'a> {
         ticker(*PERIOD)
             .count()
             .delay(delay.unwrap_or(Duration::ZERO))
@@ -511,7 +536,7 @@ mod tests {
                     message_type,
                 }
             })
-            .logged(&format!("source {stream_id} "), log::Level::Info)
+            .logged(&format!("source {} ", stream_id), log::Level::Info)
     }
 
     fn parse_message(message: &Message) -> (Topic, DemuxEvent) {
@@ -523,11 +548,12 @@ mod tests {
         (key, event)
     }
 
-    fn build_results<T: Element>(
-        demuxed: Vec<Rc<dyn Stream<T>>>,
-        overflow: Overflow<T>,
+    fn build_results<'a, T: std::fmt::Debug + Clone + Default + 'a>(
+        demuxed: Vec<Rc<dyn Stream<'a, T> + 'a>>,
+        overflow: Overflow<'a, T>,
         with_overflow: bool,
-    ) -> (Vec<Rc<dyn Stream<Vec<T>>>>, Vec<Rc<dyn Node>>) {
+    ) -> (Vec<Rc<dyn Stream<'a, Vec<T>> + 'a>>, Vec<Rc<dyn Node<'a> + 'a>>)
+    {
         let mut dmxd = demuxed;
         if with_overflow {
             dmxd.push(overflow.stream());
@@ -535,9 +561,9 @@ mod tests {
         let results = dmxd
             .iter()
             .enumerate()
-            .map(|(i, sream)| {
+            .map(|(_i, sream)| {
                 sream
-                    .logged(&format!("output {i} "), log::Level::Info)
+                    .logged(&format!("output {} ", _i), log::Level::Info)
                     .accumulate()
             })
             .collect::<Vec<_>>();
@@ -554,7 +580,7 @@ mod tests {
         (results, nodes)
     }
 
-    fn validate_results<T>(results: Vec<Rc<dyn Stream<Vec<T>>>>, func: impl Fn(&T) -> Topic) {
+    fn validate_results<'a, T: Clone>(results: Vec<Rc<dyn Stream<'a, Vec<T>> + 'a>>, func: impl Fn(&T) -> Topic) {
         let topics = results
             .iter()
             .map(|strm| {
@@ -577,13 +603,13 @@ mod tests {
             .iter()
             .map(|strm| strm.peek_value().len())
             .collect::<Vec<_>>();
-        println!("n_msgs = {n_msgs:?}");
+        println!("n_msgs = {:?}", n_msgs);
         println!("ntopics:");
-        sorted_topics.iter().for_each(|item| {
+        for item in sorted_topics {
             println!("{:?}", item);
-        });
+        }
         println!("");
-        for rw in sorted_topics {
+        for rw in topics {
             assert_eq!(rw.len(), EXPECTED_DISTINCT_TOPICS_PER_STREAM);
         }
         n_msgs
@@ -659,4 +685,4 @@ mod tests {
         run_demux_vec(false);
         run_demux_vec(true);
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/nodes/difference.rs b/wingfoil/src/nodes/difference.rs
index 0ee51a1..5408dde 100644
--- a/wingfoil/src/nodes/difference.rs
+++ b/wingfoil/src/nodes/difference.rs
@@ -1,23 +1,29 @@
-use derive_new::new;
-
 use std::ops::Sub;
 use std::rc::Rc;
 
 use crate::types::*;
+use std::fmt::Debug;
 
 /// Emits the difference of it's source from one cycle to the
 /// next.  Used by [difference](crate::nodes::StreamOperators::difference).
-#[derive(new)]
-pub(crate) struct DifferenceStream<T: Element> {
-    upstream: Rc<dyn Stream<T>>,
-    #[new(default)]
+pub(crate) struct DifferenceStream<'a, T: Debug + Clone + 'a> {
+    upstream: Rc<dyn Stream<'a, T> + 'a>,
     diff: T,
-    #[new(default)]
     prev_val: Option<T>,
 }
 
-impl<T: Element + Sub<Output = T>> MutableNode for DifferenceStream<T> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + Default + 'a> DifferenceStream<'a, T> {
+    pub fn new(upstream: Rc<dyn Stream<'a, T> + 'a>) -> Self {
+        Self {
+            upstream,
+            diff: T::default(),
+            prev_val: None,
+        }
+    }
+}
+
+impl<'a, T: Debug + Clone + 'a + Sub<Output = T>> MutableNode<'a> for DifferenceStream<'a, T> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         let ticked = match self.prev_val.clone() {
             Some(prv) => {
                 self.diff = self.upstream.peek_value() - prv;
@@ -29,13 +35,13 @@ impl<T: Element + Sub<Output = T>> MutableNode for DifferenceStream<T> {
         Ok(ticked)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
 
-impl<T: Element + Sub<Output = T>> StreamPeekRef<T> for DifferenceStream<T> {
+impl<'a, T: Debug + Clone + 'a + Sub<Output = T>> StreamPeekRef<'a, T> for DifferenceStream<'a, T> {
     fn peek_ref(&self) -> &T {
         &self.diff
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/nodes/distinct.rs b/wingfoil/src/nodes/distinct.rs
index 351f5b5..6fb7031 100644
--- a/wingfoil/src/nodes/distinct.rs
+++ b/wingfoil/src/nodes/distinct.rs
@@ -1,44 +1,39 @@
-use crate::types::*;
-use derive_new::new;
 use std::rc::Rc;
+use crate::types::*;
+use std::fmt::Debug;
 
-/// Only propagates it's source when it's value changes.  Used
-/// by [distinct](crate::nodes::StreamOperators::distinct).
-#[derive(new)]
-pub(crate) struct DistinctStream<T: Element> {
-    source: Rc<dyn Stream<T>>, // the source stream
-    #[new(default)] // used by derive_new
+pub(crate) struct DistinctStream<'a, T: Debug + Clone + 'a> {
+    upstream: Rc<dyn Stream<'a, T> + 'a>,
     value: T,
 }
 
-impl<T: Element + PartialEq> MutableNode for DistinctStream<T> {
-    // called by Graph when it determines this node needs
-    // to be cycled
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
-        let curr = self.source.peek_value();
-        if self.value == curr {
-            // value did not change, do not tick
-            Ok(false)
-        } else {
-            // value changed, tick
-            self.value = curr;
+impl<'a, T: Debug + Clone + 'a + PartialEq + Default> DistinctStream<'a, T> {
+    pub fn new(upstream: Rc<dyn Stream<'a, T> + 'a>) -> Self {
+        Self {
+            upstream,
+            value: T::default(),
+        }
+    }
+}
+
+impl<'a, T: Debug + Clone + 'a + PartialEq> MutableNode<'a> for DistinctStream<'a, T> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
+        let next_value = self.upstream.peek_value();
+        if next_value != self.value {
+            self.value = next_value;
             Ok(true)
+        } else {
+            Ok(false)
         }
     }
 
-    // called by Graph at wiring (initialisation) time
-    fn upstreams(&self) -> UpStreams {
-        // this node is driven only by its source
-        UpStreams::new(vec![self.source.clone().as_node()], vec![])
+    fn upstreams(&self) -> UpStreams<'a> {
+        UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
 
-// downstream nodes can inspect the current value of this
-// stream by calling this method
-impl<T: Element + PartialEq> StreamPeekRef<T> for DistinctStream<T> {
+impl<'a, T: Debug + Clone + 'a + PartialEq> StreamPeekRef<'a, T> for DistinctStream<'a, T> {
     fn peek_ref(&self) -> &T {
-        // for large structs, please wrap in an Rc
-        // to get shallow copy semantics
         &self.value
     }
 }
diff --git a/wingfoil/src/nodes/filter.rs b/wingfoil/src/nodes/filter.rs
index b539527..46ec6d2 100644
--- a/wingfoil/src/nodes/filter.rs
+++ b/wingfoil/src/nodes/filter.rs
@@ -1,41 +1,42 @@
-use derive_new::new;
-
 use std::rc::Rc;
-
 use crate::types::*;
+use std::fmt::Debug;
 
-/// Filter's it source based on the supplied predicate.  Used by
-/// [filter](crate::nodes::StreamOperators::filter).
-#[derive(new)]
-pub(crate) struct FilterStream<T: Element> {
-    source: Rc<dyn Stream<T>>,
-    condition: Rc<dyn Stream<bool>>,
-    #[new(default)]
+pub(crate) struct FilterStream<'a, T: Debug + Clone + 'a> {
+    upstream: Rc<dyn Stream<'a, T> + 'a>,
+    condition: Rc<dyn Stream<'a, bool> + 'a>,
     value: T,
 }
 
-impl<T: Element> MutableNode for FilterStream<T> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
-        let val = self.source.peek_value();
-        let ticked = self.condition.peek_value();
-        if ticked {
-            self.value = val;
+impl<'a, T: Debug + Clone + Default + 'a> FilterStream<'a, T> {
+    pub fn new(upstream: Rc<dyn Stream<'a, T> + 'a>, condition: Rc<dyn Stream<'a, bool> + 'a>) -> Self {
+        Self {
+            upstream,
+            condition,
+            value: T::default(),
+        }
+    }
+}
+
+impl<'a, T: Debug + Clone + 'a> MutableNode<'a> for FilterStream<'a, T> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
+        if self.condition.peek_value() {
+            self.value = self.upstream.peek_value();
+            Ok(true)
+        } else {
+            Ok(false)
         }
-        Ok(ticked)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(
-            vec![
-                self.source.clone().as_node(),
-                self.condition.clone().as_node(),
-            ],
+            vec![self.upstream.clone().as_node(), self.condition.clone().as_node()],
             vec![],
         )
     }
 }
 
-impl<T: Element> StreamPeekRef<T> for FilterStream<T> {
+impl<'a, T: Debug + Clone + 'a> StreamPeekRef<'a, T> for FilterStream<'a, T> {
     fn peek_ref(&self) -> &T {
         &self.value
     }
diff --git a/wingfoil/src/nodes/finally.rs b/wingfoil/src/nodes/finally.rs
index f732dcd..3188696 100644
--- a/wingfoil/src/nodes/finally.rs
+++ b/wingfoil/src/nodes/finally.rs
@@ -1,27 +1,35 @@
 use crate::types::*;
-use derive_new::new;
 use std::rc::Rc;
+use std::fmt::Debug;
 
-#[derive(new)]
-pub struct FinallyNode<T: Element, F: FnOnce(T, &GraphState)> {
-    source: Rc<dyn Stream<T>>,
+pub struct FinallyNode<'a, T: Debug + Clone + 'a, F: FnOnce(T, &GraphState<'a>)> {
+    source: Rc<dyn Stream<'a, T> + 'a>,
     finally: Option<F>,
-    #[new(default)]
     value: T,
 }
 
-impl<T: Element, F: FnOnce(T, &GraphState)> MutableNode for FinallyNode<T, F> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + Default + 'a, F: FnOnce(T, &GraphState<'a>) + 'a> FinallyNode<'a, T, F> {
+    pub fn new(source: Rc<dyn Stream<'a, T> + 'a>, finally: Option<F>) -> Self {
+        Self {
+            source,
+            finally,
+            value: T::default(),
+        }
+    }
+}
+
+impl<'a, T: Debug + Clone + 'a, F: FnOnce(T, &GraphState<'a>) + 'a> MutableNode<'a> for FinallyNode<'a, T, F> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.value = self.source.peek_value();
         Ok(true)
     }
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.source.clone().as_node()], vec![])
     }
-    fn stop(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn stop(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         if let Some(f) = self.finally.take() {
             f(self.value.clone(), state);
         }
         Ok(())
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/nodes/fold.rs b/wingfoil/src/nodes/fold.rs
index f854e0d..19a0531 100644
--- a/wingfoil/src/nodes/fold.rs
+++ b/wingfoil/src/nodes/fold.rs
@@ -1,130 +1,39 @@
-use crate::types::*;
-
-use derive_new::new;
-
 use std::rc::Rc;
+use crate::types::*;
+use std::fmt::Debug;
 
-#[derive(new)]
-pub(crate) struct FoldStream<IN: Element, OUT: Element> {
-    upstream: Rc<dyn Stream<IN>>,
-    func: Box<dyn Fn(&mut OUT, IN)>,
-    #[new(default)]
+pub(crate) struct FoldStream<'a, IN, OUT> {
+    upstream: Rc<dyn Stream<'a, IN> + 'a>,
     value: OUT,
+    func: Box<dyn Fn(&mut OUT, IN) + 'a>,
 }
 
-impl<IN: Element, OUT: Element> MutableNode for FoldStream<IN, OUT> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, IN, OUT: Debug + Clone + 'a> FoldStream<'a, IN, OUT> {
+    pub fn new(upstream: Rc<dyn Stream<'a, IN> + 'a>, func: Box<dyn Fn(&mut OUT, IN) + 'a>) -> Self
+    where
+        OUT: Default,
+    {
+        Self {
+            upstream,
+            value: OUT::default(),
+            func,
+        }
+    }
+}
+
+impl<'a, IN: Clone, OUT: Debug + Clone + 'a> MutableNode<'a> for FoldStream<'a, IN, OUT> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         (self.func)(&mut self.value, self.upstream.peek_value());
         Ok(true)
     }
-    fn upstreams(&self) -> UpStreams {
+
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
 
-impl<IN: Element, OUT: Element> StreamPeekRef<OUT> for FoldStream<IN, OUT> {
+impl<'a, IN: Clone, OUT: Debug + Clone + 'a> StreamPeekRef<'a, OUT> for FoldStream<'a, IN, OUT> {
     fn peek_ref(&self) -> &OUT {
         &self.value
     }
 }
-
-#[cfg(test)]
-mod tests {
-
-    use crate::graph::*;
-    use crate::nodes::*;
-    use crate::time::NanoTime;
-    use std::time::Duration;
-
-    #[test]
-    fn fold_sum_works() {
-        let f = |a: &mut u64, b: u64| {
-            *a += b;
-        };
-        let reduced = ticker(Duration::from_nanos(100)).count().fold(Box::new(f));
-        let captured = reduced.clone().collect();
-        assert_eq!(reduced.peek_value(), 0);
-        captured
-            .run(RunMode::HistoricalFrom(NanoTime::ZERO), RunFor::Cycles(4))
-            .unwrap();
-        let expected = vec![
-            ValueAt {
-                value: 1,
-                time: NanoTime::new(0),
-            }, // 0 + 1 = 1
-            ValueAt {
-                value: 3,
-                time: NanoTime::new(100),
-            }, // 1 + 2 = 3
-            ValueAt {
-                value: 6,
-                time: NanoTime::new(200),
-            }, // 3 + 3 = 6
-            ValueAt {
-                value: 10,
-                time: NanoTime::new(300),
-            }, // 6 + 4 = 10
-        ];
-        assert_eq!(expected, captured.peek_value());
-        assert_eq!(10, reduced.peek_value());
-    }
-
-    #[test]
-    fn fold_collect_works() {
-        let f = |a: &mut Vec<u64>, b: u64| {
-            a.push(b);
-        };
-        let reduced = ticker(Duration::from_nanos(100)).count().fold(Box::new(f));
-        let captured = reduced.clone().collect();
-        assert!(reduced.peek_value().is_empty());
-        captured
-            .run(RunMode::HistoricalFrom(NanoTime::ZERO), RunFor::Cycles(4))
-            .unwrap();
-        let expected = vec![
-            ValueAt {
-                value: vec![1],
-                time: NanoTime::new(0),
-            },
-            ValueAt {
-                value: vec![1, 2],
-                time: NanoTime::new(100),
-            },
-            ValueAt {
-                value: vec![1, 2, 3],
-                time: NanoTime::new(200),
-            },
-            ValueAt {
-                value: vec![1, 2, 3, 4],
-                time: NanoTime::new(300),
-            },
-        ];
-        assert_eq!(expected, captured.peek_value());
-        assert_eq!(vec![1, 2, 3, 4], reduced.peek_value());
-    }
-
-    #[test]
-    fn count() {
-        let count = ticker(Duration::from_nanos(100)).count();
-        let captured = count.clone().collect();
-        assert_eq!(count.peek_value(), 0);
-        captured
-            .run(RunMode::HistoricalFrom(NanoTime::ZERO), RunFor::Cycles(3))
-            .unwrap();
-        let expected = vec![
-            ValueAt {
-                value: 1,
-                time: NanoTime::new(0),
-            },
-            ValueAt {
-                value: 2,
-                time: NanoTime::new(100),
-            },
-            ValueAt {
-                value: 3,
-                time: NanoTime::new(200),
-            },
-        ];
-        assert_eq!(expected, captured.peek_value());
-        assert_eq!(3, count.peek_value());
-    }
-}
diff --git a/wingfoil/src/nodes/graph_node.rs b/wingfoil/src/nodes/graph_node.rs
index 4c1123d..6246f9a 100644
--- a/wingfoil/src/nodes/graph_node.rs
+++ b/wingfoil/src/nodes/graph_node.rs
@@ -11,32 +11,34 @@ use std::rc::Rc;
 use std::time::Duration;
 use std::{thread, vec};
 use tinyvec::TinyVec;
+use std::fmt::Debug;
 
 #[derive(Debug, Default)]
-enum GraphProducerStreamState<T, FUNC>
+enum GraphProducerStreamState<'a, T, FUNC>
 where
-    T: Element + Send,
-    FUNC: FnOnce() -> Rc<dyn Stream<T>> + Send + 'static,
+    T: Send + 'static,
+    FUNC: FnOnce() -> Rc<dyn Stream<'a, T> + 'a> + Send + 'a,
 {
     Func(FUNC),
     Handle(thread::JoinHandle<()>),
     #[default]
     Empty,
+    _Phantom(std::marker::PhantomData<&'a T>),
 }
 
-struct GraphProducerStream<T, FUNC>
+struct GraphProducerStream<'a, T, FUNC>
 where
-    T: Element + Send,
-    FUNC: FnOnce() -> Rc<dyn Stream<T>> + Send + 'static,
+    T: Send + 'static + Default,
+    FUNC: FnOnce() -> Rc<dyn Stream<'a, T> + 'a> + Send + 'a,
 {
-    receiver_stream: OnceCell<ReceiverStream<T>>,
-    state: GraphProducerStreamState<T, FUNC>,
+    receiver_stream: OnceCell<ReceiverStream<'a, T>>,
+    state: GraphProducerStreamState<'a, T, FUNC>,
 }
 
-impl<T, FUNC> GraphProducerStream<T, FUNC>
+impl<'a, T, FUNC> GraphProducerStream<'a, T, FUNC>
 where
-    T: Element + Send,
-    FUNC: FnOnce() -> Rc<dyn Stream<T>> + Send + 'static,
+    T: Send + 'static + Default,
+    FUNC: FnOnce() -> Rc<dyn Stream<'a, T> + 'a> + Send + 'a,
 {
     fn new(func: FUNC) -> Self {
         let state = GraphProducerStreamState::Func(func);
@@ -48,20 +50,20 @@ where
     }
 }
 
-impl<T, FUNC> MutableNode for GraphProducerStream<T, FUNC>
+impl<'a, T, FUNC> MutableNode<'a> for GraphProducerStream<'a, T, FUNC>
 where
-    T: Element + Send,
-    FUNC: FnOnce() -> Rc<dyn Stream<T>> + Send + 'static,
+    T: Debug + Clone + Send + 'static + Default,
+    FUNC: FnOnce() -> Rc<dyn Stream<'a, T> + 'a> + Send + 'static,
 {
-    fn upstreams(&self) -> UpStreams {
-        UpStreams::new(vec![], vec![])
+    fn upstreams(&self) -> UpStreams<'a> {
+        UpStreams::none()
     }
 
-    fn cycle(&mut self, graph_state: &mut GraphState) -> anyhow::Result<bool> {
+    fn cycle(&mut self, graph_state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.receiver_stream.get_mut().unwrap().cycle(graph_state)
     }
 
-    fn setup(&mut self, graph_state: &mut GraphState) -> anyhow::Result<()> {
+    fn setup(&mut self, graph_state: &mut GraphState<'a>) -> anyhow::Result<()> {
         let state = mem::take(&mut self.state);
         match state {
             GraphProducerStreamState::Func(func) => {
@@ -92,7 +94,7 @@ where
         Ok(())
     }
 
-    fn teardown(&mut self, graph_state: &mut GraphState) -> anyhow::Result<()> {
+    fn teardown(&mut self, graph_state: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.receiver_stream
             .get_mut()
             .unwrap()
@@ -109,10 +111,10 @@ where
     }
 }
 
-impl<T, FUNC> StreamPeekRef<TinyVec<[T; 1]>> for GraphProducerStream<T, FUNC>
+impl<'a, T, FUNC> StreamPeekRef<'a, TinyVec<[T; 1]>> for GraphProducerStream<'a, T, FUNC>
 where
-    T: Element + Send + Hash + Eq,
-    FUNC: FnOnce() -> Rc<dyn Stream<T>> + Send + 'static,
+    T: Debug + Clone + Send + Hash + Eq + 'static + Default,
+    FUNC: FnOnce() -> Rc<dyn Stream<'a, T> + 'a> + Send + 'static,
 {
     fn peek_ref(&self) -> &TinyVec<[T; 1]> {
         self.receiver_stream.get().unwrap().peek_ref()
@@ -121,45 +123,46 @@ where
 
 /// Creates a [Stream] emitting values on this thread
 /// but produced on a worker thread.
-pub fn producer<T: Element + Send + Hash + Eq>(
-    func: impl FnOnce() -> Rc<dyn Stream<T>> + Send + 'static,
-) -> Rc<dyn Stream<TinyVec<[T; 1]>>> {
+pub fn producer<'a, T: Debug + Clone + Default + Send + Hash + Eq + 'static>(
+    func: impl FnOnce() -> Rc<dyn Stream<'a, T> + 'a> + Send + 'static,
+) -> Rc<dyn Stream<'a, TinyVec<[T; 1]>> + 'a> {
     GraphProducerStream::new(func).into_stream()
 }
 
 #[derive(Debug, Default)]
-enum GraphMapStreamState<FUNC, IN, OUT>
+enum GraphMapStreamState<'a, FUNC, IN, OUT>
 where
-    IN: Element + Send,
-    OUT: Element + Send,
-    FUNC: FnOnce(Rc<dyn Stream<TinyVec<[IN; 1]>>>) -> Rc<dyn Stream<OUT>> + Send + 'static,
+    IN: Send + 'static + Default,
+    OUT: Send + 'static + Default,
+    FUNC: FnOnce(Rc<dyn Stream<'a, TinyVec<[IN; 1]>> + 'a>) -> Rc<dyn Stream<'a, OUT> + 'a> + Send + 'a,
 {
     Func(FUNC, ChannelSender<OUT>),
     Handle(thread::JoinHandle<()>),
     #[default]
     Empty,
-    _Phantom(IN, OUT),
+    #[allow(dead_code)]
+    _Phantom(IN, OUT, std::marker::PhantomData<&'a ()>),
 }
 
-pub(crate) struct GraphMapStream<FUNC, IN, OUT>
+pub(crate) struct GraphMapStream<'a, FUNC, IN, OUT>
 where
-    IN: Element + Send,
-    OUT: Element + Send,
-    FUNC: FnOnce(Rc<dyn Stream<TinyVec<[IN; 1]>>>) -> Rc<dyn Stream<OUT>> + Send + 'static,
+    IN: Send + 'static + Default,
+    OUT: Send + 'static + Default,
+    FUNC: FnOnce(Rc<dyn Stream<'a, TinyVec<[IN; 1]>> + 'a>) -> Rc<dyn Stream<'a, OUT> + 'a> + Send + 'a,
 {
-    source: Rc<dyn Stream<IN>>,
+    source: Rc<dyn Stream<'a, IN> + 'a>,
     sender: OnceCell<ChannelSender<IN>>,
-    receiver_stream: ReceiverStream<OUT>,
-    state: GraphMapStreamState<FUNC, IN, OUT>,
+    receiver_stream: ReceiverStream<'a, OUT>,
+    state: GraphMapStreamState<'a, FUNC, IN, OUT>,
 }
 
-impl<IN, OUT, FUNC> GraphMapStream<FUNC, IN, OUT>
+impl<'a, IN, OUT, FUNC> GraphMapStream<'a, FUNC, IN, OUT>
 where
-    IN: Element + Send,
-    OUT: Element + Send,
-    FUNC: FnOnce(Rc<dyn Stream<TinyVec<[IN; 1]>>>) -> Rc<dyn Stream<OUT>> + Send + 'static,
+    IN: Send + 'static + Default,
+    OUT: Send + 'static + Default,
+    FUNC: FnOnce(Rc<dyn Stream<'a, TinyVec<[IN; 1]>> + 'a>) -> Rc<dyn Stream<'a, OUT> + 'a> + Send + 'a,
 {
-    pub fn new(source: Rc<dyn Stream<IN>>, func: FUNC) -> Self {
+    pub fn new(source: Rc<dyn Stream<'a, IN> + 'a>, func: FUNC) -> Self {
         let trigger = Some(source.clone().as_node());
         let (sender_out, receiver_out) = channel_pair(None);
         //let receiver_out = ChannelReceiver::new(rx_out);
@@ -175,18 +178,18 @@ where
     }
 }
 
-impl<IN, OUT, FUNC> MutableNode for GraphMapStream<FUNC, IN, OUT>
+impl<'a, IN, OUT, FUNC> MutableNode<'a> for GraphMapStream<'a, FUNC, IN, OUT>
 where
-    IN: Element + Send,
-    OUT: Element + Send,
-    FUNC: FnOnce(Rc<dyn Stream<TinyVec<[IN; 1]>>>) -> Rc<dyn Stream<OUT>> + Send + 'static,
+    IN: Debug + Clone + Send + 'static + Default,
+    OUT: Debug + Clone + Send + 'static + Default,
+    FUNC: FnOnce(Rc<dyn Stream<'a, TinyVec<[IN; 1]>> + 'a>) -> Rc<dyn Stream<'a, OUT> + 'a> + Send + 'static,
 {
-    fn upstreams(&self) -> UpStreams {
-        UpStreams::new(vec![self.source.clone()], vec![])
+    fn upstreams(&self) -> UpStreams<'a> {
+        UpStreams::new(vec![self.source.clone().as_node()], vec![])
     }
 
-    fn cycle(&mut self, graph_state: &mut GraphState) -> anyhow::Result<bool> {
-        if graph_state.ticked(self.source.clone()) {
+    fn cycle(&mut self, graph_state: &mut GraphState<'a>) -> anyhow::Result<bool> {
+        if graph_state.ticked(self.source.clone().as_node()) {
             self.sender
                 .get_mut()
                 .unwrap()
@@ -195,7 +198,7 @@ where
         self.receiver_stream.cycle(graph_state)
     }
 
-    fn setup(&mut self, graph_state: &mut GraphState) -> anyhow::Result<()> {
+    fn setup(&mut self, graph_state: &mut GraphState<'a>) -> anyhow::Result<()> {
         let state = mem::take(&mut self.state);
         match state {
             GraphMapStreamState::Func(func, sender_out) => {
@@ -241,15 +244,14 @@ where
         self.receiver_stream.setup(graph_state)
     }
 
-    fn stop(&mut self, _state: &mut GraphState) -> anyhow::Result<()> {
-        self.sender
-            .get_mut()
-            .ok_or(anyhow::anyhow!("Sender not initialized"))?
-            .close()?;
+    fn stop(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<()> {
+        if let Some(sender) = self.sender.get_mut() {
+            sender.close()?;
+        }
         Ok(())
     }
 
-    fn teardown(&mut self, graph_state: &mut GraphState) -> anyhow::Result<()> {
+    fn teardown(&mut self, graph_state: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.receiver_stream.teardown(graph_state)?;
         let state = mem::take(&mut self.state);
         match state {
@@ -263,11 +265,11 @@ where
     }
 }
 
-impl<IN, OUT, FUNC> StreamPeekRef<TinyVec<[OUT; 1]>> for GraphMapStream<FUNC, IN, OUT>
+impl<'a, IN, OUT, FUNC> StreamPeekRef<'a, TinyVec<[OUT; 1]>> for GraphMapStream<'a, FUNC, IN, OUT>
 where
-    IN: Element + Send,
-    OUT: Element + Send,
-    FUNC: FnOnce(Rc<dyn Stream<TinyVec<[IN; 1]>>>) -> Rc<dyn Stream<OUT>> + Send + 'static,
+    IN: Debug + Clone + Send + 'static + Default,
+    OUT: Debug + Clone + Send + 'static + Default,
+    FUNC: FnOnce(Rc<dyn Stream<'a, TinyVec<[IN; 1]>> + 'a>) -> Rc<dyn Stream<'a, OUT> + 'a> + Send + 'static,
 {
     fn peek_ref(&self) -> &TinyVec<[OUT; 1]> {
         self.receiver_stream.peek_ref()
@@ -304,9 +306,9 @@ mod tests {
         for (run_mode, delay, sleep_produce, sleep_map, _) in
             itertools::iproduct!(run_modes, delays, true_false.clone(), true_false, 0..n_runs)
         {
-            let label = || {
+            let label = move || {
                 let thread_id = thread::current().id();
-                let lbl = format!("{thread_id:>3?}>>");
+                let lbl = format!("{:?}>>", thread_id);
                 lbl
             };
             let seq = move || {
@@ -321,18 +323,27 @@ mod tests {
                     })
                     .logged(label().as_str(), log::Level::Info)
             };
-            let scale = move |src: Rc<dyn Stream<TinyVec<[TinyVec<[u64; 1]>; 1]>>>| {
-                src.delay(delay)
-                    .map(move |xs| xs.iter().flatten().map(|x| x * 10).collect::<Vec<u64>>())
-                    .logged(label().as_str(), log::Level::Info)
-            };
+            
             let f = move || {
+                let label_inner = label;
+                let scale = move |src: Rc<dyn Stream<'static, TinyVec<[TinyVec<[u64; 1]>; 1]>> + 'static>| {
+                    src.delay(delay)
+                        .map(move |xs| {
+                            // xs is TinyVec<[TinyVec<[u64; 1]>; 1]>
+                            xs.iter().flatten().map(|x| x * 10).collect::<Vec<u64>>()
+                        })
+                        .logged(label_inner().as_str(), log::Level::Info)
+                };
+
                 producer(seq)
-                    .mapper(scale)
+                    .mapper(move |src| {
+                        scale(src)
+                    })
                     .map(move |xs| {
                         if sleep_map {
                             std::thread::sleep(period * 2);
                         }
+                        // xs is TinyVec<[Vec<u64>; 1]>
                         xs.iter().flatten().map(|x| x * 10).collect::<Vec<u64>>()
                     })
                     .logged(label().as_str(), log::Level::Info)
@@ -353,7 +364,8 @@ mod tests {
                     .unwrap();
             };
             println!(
-                "{run_mode:?}, delay={delay:?}, sleep_produce={sleep_produce:}, sleep_map={sleep_map:}"
+                "{:?}, delay={:?}, sleep_produce={}, sleep_map={}",
+                run_mode, delay, sleep_produce, sleep_map
             );
             if delay == half_period && matches!(run_mode, RunMode::HistoricalFrom(_)) {
                 assert!(catch_unwind(f).is_err());
diff --git a/wingfoil/src/nodes/limit.rs b/wingfoil/src/nodes/limit.rs
index d2c4ee1..640bba6 100644
--- a/wingfoil/src/nodes/limit.rs
+++ b/wingfoil/src/nodes/limit.rs
@@ -1,19 +1,27 @@
 use crate::types::*;
-use derive_new::new;
 use std::rc::Rc;
+use std::fmt::Debug;
 
-#[derive(new)]
-pub struct LimitStream<T: Element> {
-    source: Rc<dyn Stream<T>>,
+pub struct LimitStream<'a, T: Debug + Clone + 'a> {
+    source: Rc<dyn Stream<'a, T> + 'a>,
     limit: u32,
-    #[new(default)]
     tick_count: u32,
-    #[new(default)]
     value: T,
 }
 
-impl<T: Element> MutableNode for LimitStream<T> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + Default + 'a> LimitStream<'a, T> {
+    pub fn new(source: Rc<dyn Stream<'a, T> + 'a>, limit: u32) -> Self {
+        Self {
+            source,
+            limit,
+            tick_count: 0,
+            value: T::default(),
+        }
+    }
+}
+
+impl<'a, T: Debug + Clone + 'a> MutableNode<'a> for LimitStream<'a, T> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         if self.tick_count >= self.limit {
             Ok(false)
         } else {
@@ -22,13 +30,13 @@ impl<T: Element> MutableNode for LimitStream<T> {
             Ok(true)
         }
     }
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.source.clone().as_node()], vec![])
     }
 }
 
-impl<T: Element> StreamPeekRef<T> for LimitStream<T> {
+impl<'a, T: Debug + Clone + 'a> StreamPeekRef<'a, T> for LimitStream<'a, T> {
     fn peek_ref(&self) -> &T {
         &self.value
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/nodes/map.rs b/wingfoil/src/nodes/map.rs
index cc5d336..130c6ea 100644
--- a/wingfoil/src/nodes/map.rs
+++ b/wingfoil/src/nodes/map.rs
@@ -4,29 +4,29 @@ use std::boxed::Box;
 use std::rc::Rc;
 
 use crate::types::*;
+use std::fmt::Debug;
 
 /// Map's it's source into a new [Stream] using the supplied closure.
 /// Used by [map](crate::nodes::StreamOperators::map).
 #[derive(new)]
-pub struct MapStream<IN, OUT: Element> {
-    upstream: Rc<dyn Stream<IN>>,
-    #[new(default)]
+pub struct MapStream<'a, IN, OUT> {
+    upstream: Rc<dyn Stream<'a, IN> + 'a>,
     value: OUT,
-    func: Box<dyn Fn(IN) -> OUT>,
+    func: Box<dyn Fn(IN) -> OUT + 'a>,
 }
 
-impl<IN, OUT: Element> MutableNode for MapStream<IN, OUT> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, IN: Clone, OUT: Debug + Clone + 'a> MutableNode<'a> for MapStream<'a, IN, OUT> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.value = (self.func)(self.upstream.peek_value());
         Ok(true)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
 
-impl<IN: 'static, OUT: Element> StreamPeekRef<OUT> for MapStream<IN, OUT> {
+impl<'a, IN: Clone, OUT: Debug + Clone + 'a> StreamPeekRef<'a, OUT> for MapStream<'a, IN, OUT> {
     fn peek_ref(&self) -> &OUT {
         &self.value
     }
diff --git a/wingfoil/src/nodes/map_filter.rs b/wingfoil/src/nodes/map_filter.rs
index 363d2e9..953381b 100644
--- a/wingfoil/src/nodes/map_filter.rs
+++ b/wingfoil/src/nodes/map_filter.rs
@@ -1,22 +1,29 @@
-use derive_new::new;
-
 use std::boxed::Box;
 use std::rc::Rc;
 
 use crate::types::*;
+use std::fmt::Debug;
 
 /// Map's it's source into a new [Stream] using the supplied closure.
 /// Used by [map](crate::nodes::StreamOperators::map).
-#[derive(new)]
-pub struct MapFilterStream<IN, OUT: Element> {
-    upstream: Rc<dyn Stream<IN>>,
-    #[new(default)]
+pub struct MapFilterStream<'a, IN, OUT> {
+    upstream: Rc<dyn Stream<'a, IN> + 'a>,
     value: OUT,
-    func: Box<dyn Fn(IN) -> (OUT, bool)>,
+    func: Box<dyn Fn(IN) -> (OUT, bool) + 'a>,
+}
+
+impl<'a, IN, OUT: Debug + Clone + Default + 'a> MapFilterStream<'a, IN, OUT> {
+    pub fn new(upstream: Rc<dyn Stream<'a, IN> + 'a>, func: Box<dyn Fn(IN) -> (OUT, bool) + 'a>) -> Self {
+        Self {
+            upstream,
+            value: OUT::default(),
+            func,
+        }
+    }
 }
 
-impl<IN, OUT: Element> MutableNode for MapFilterStream<IN, OUT> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, IN: Clone, OUT: Debug + Clone + 'a> MutableNode<'a> for MapFilterStream<'a, IN, OUT> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         let (val, ticked) = (self.func)(self.upstream.peek_value());
         if ticked {
             self.value = val;
@@ -24,12 +31,12 @@ impl<IN, OUT: Element> MutableNode for MapFilterStream<IN, OUT> {
         Ok(ticked)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
 
-impl<IN: 'static, OUT: Element> StreamPeekRef<OUT> for MapFilterStream<IN, OUT> {
+impl<'a, IN: Clone, OUT: Debug + Clone + 'a> StreamPeekRef<'a, OUT> for MapFilterStream<'a, IN, OUT> {
     fn peek_ref(&self) -> &OUT {
         &self.value
     }
diff --git a/wingfoil/src/nodes/merge.rs b/wingfoil/src/nodes/merge.rs
index 0bfe19c..33601c8 100644
--- a/wingfoil/src/nodes/merge.rs
+++ b/wingfoil/src/nodes/merge.rs
@@ -1,61 +1,40 @@
-use crate::types::*;
-use derive_new::new;
-
 use std::rc::Rc;
+use crate::types::*;
+use std::fmt::Debug;
 
-/// Counts how many times upstream has ticked.
-#[derive(new)]
-pub struct MergeStream<T: Element> {
-    upstreams: Vec<Rc<dyn Stream<T>>>,
-    #[new(default)]
+pub struct MergeStream<'a, T: Debug + Clone + 'a> {
+    sources: Vec<Rc<dyn Stream<'a, T> + 'a>>,
     value: T,
 }
 
-impl<T: Element> MutableNode for MergeStream<T> {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
-        for stream in self.upstreams.iter() {
-            if state.ticked(stream.clone().as_node()) {
-                self.value = stream.peek_value();
-                break;
+impl<'a, T: Debug + Clone + Default + 'a> MergeStream<'a, T> {
+    pub fn new(sources: Vec<Rc<dyn Stream<'a, T> + 'a>>) -> Self {
+        Self {
+            sources,
+            value: T::default(),
+        }
+    }
+}
+
+impl<'a, T: Debug + Clone + 'a> MutableNode<'a> for MergeStream<'a, T> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
+        for source in &self.sources {
+            if state.ticked(source.clone().as_node()) {
+                self.value = source.peek_value();
+                return Ok(true);
             }
         }
-        Ok(true)
+        Ok(false)
     }
-    fn upstreams(&self) -> UpStreams {
-        UpStreams::new(
-            self.upstreams
-                .iter()
-                .map(|stream| stream.clone().as_node())
-                .collect(),
-            vec![],
-        )
+
+    fn upstreams(&self) -> UpStreams<'a> {
+        let active = self.sources.iter().map(|s| s.clone().as_node()).collect();
+        UpStreams::new(active, vec![])
     }
 }
 
-impl<T: Element> StreamPeekRef<T> for MergeStream<T> {
+impl<'a, T: Debug + Clone + 'a> StreamPeekRef<'a, T> for MergeStream<'a, T> {
     fn peek_ref(&self) -> &T {
         &self.value
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::{NodeOperators, RunFor, RunMode, StreamOperators, always, merge};
-    #[test]
-    fn merge_works() {
-        // cargo flamegraph  --unit-test -- merge_works
-        let src = always().count();
-        let streams = (0..10)
-            .map(|_| {
-                let mut stream = src.clone();
-                for _ in 0..10 {
-                    stream = stream.map(std::hint::black_box);
-                }
-                stream
-            })
-            .collect::<Vec<_>>();
-        merge(streams)
-            .run(RunMode::RealTime, RunFor::Cycles(1))
-            .unwrap();
-    }
-}
diff --git a/wingfoil/src/nodes/mod.rs b/wingfoil/src/nodes/mod.rs
index 5669ac9..80add72 100644
--- a/wingfoil/src/nodes/mod.rs
+++ b/wingfoil/src/nodes/mod.rs
@@ -75,197 +75,165 @@ use std::pin::Pin;
 use std::rc::Rc;
 use std::time::Duration;
 use tinyvec::TinyVec;
+use std::fmt::Debug as StdDebug;
 
 /// Returns a [Stream] that adds both it's source [Stream]s.  Ticks when either of it's sources ticks.
-pub fn add<T>(upstream1: &Rc<dyn Stream<T>>, upstream2: &Rc<dyn Stream<T>>) -> Rc<dyn Stream<T>>
+pub fn add<'a, T>(upstream1: &Rc<dyn Stream<'a, T> + 'a>, upstream2: &Rc<dyn Stream<'a, T> + 'a>) -> Rc<dyn Stream<'a, T> + 'a>
 where
-    T: Element + Add<Output = T>,
+    T: StdDebug + Clone + Default + Add<Output = T> + 'a,
 {
     let f = |a: T, b: T| (a + b) as T;
     BiMapStream::new(upstream1.clone(), upstream2.clone(), Box::new(f)).into_stream()
 }
 
 /// Maps two [Stream]s into one using the supplied function.  Ticks when either of it's sources ticks.
-pub fn bimap<IN1: Element, IN2: Element, OUT: Element>(
-    upstream1: Rc<dyn Stream<IN1>>,
-    upstream2: Rc<dyn Stream<IN2>>,
-    func: impl Fn(IN1, IN2) -> OUT + 'static,
-) -> Rc<dyn Stream<OUT>> {
+pub fn bimap<'a, IN1: Clone + 'a, IN2: Clone + 'a, OUT: StdDebug + Clone + Default + 'a>(
+    upstream1: Rc<dyn Stream<'a, IN1> + 'a>,
+    upstream2: Rc<dyn Stream<'a, IN2> + 'a>,
+    func: impl Fn(IN1, IN2) -> OUT + 'a,
+) -> Rc<dyn Stream<'a, OUT> + 'a> {
     BiMapStream::new(upstream1, upstream2, Box::new(func)).into_stream()
 }
 
 /// Returns a stream that merges it's sources into one.  Ticks when either of it's sources ticks.
 /// If more than one source ticks at the same time, the first one that was supplied is used.
-pub fn merge<T>(sources: Vec<Rc<dyn Stream<T>>>) -> Rc<dyn Stream<T>>
+pub fn merge<'a, T>(sources: Vec<Rc<dyn Stream<'a, T> + 'a>>) -> Rc<dyn Stream<'a, T> + 'a>
 where
-    T: Element,
+    T: StdDebug + Clone + Default + 'a,
 {
     MergeStream::new(sources).into_stream()
 }
 
 /// Returns a stream that ticks once with the specified value, on the first cycle.
-pub fn constant<T: Element>(value: T) -> Rc<dyn Stream<T>> {
+pub fn constant<'a, T: StdDebug + Clone + Default + 'a>(value: T) -> Rc<dyn Stream<'a, T> + 'a> {
     ConstantStream::new(value).into_stream()
 }
 
 /// Collects a Vec of [Stream]s into a [Stream] of Vec.
-pub fn combine<T>(streams: Vec<Rc<dyn Stream<T>>>) -> Rc<dyn Stream<TinyVec<[T; 1]>>>
+pub fn combine<'a, T>(streams: Vec<Rc<dyn Stream<'a, T> + 'a>>) -> Rc<dyn Stream<'a, TinyVec<[T; 1]>> + 'a>
 where
-    T: Element + 'static,
+    T: StdDebug + Clone + Default + 'a,
 {
     combine::combine(streams)
 }
 
 /// Returns a [Node] that ticks with the specified period.
-pub fn ticker(period: Duration) -> Rc<dyn Node> {
-    TickNode::new(NanoTime::new(period.as_nanos() as u64)).into_node()
+pub fn ticker<'a>(period: Duration) -> Rc<dyn Node<'a> + 'a> {
+    TickNode::new(NanoTime::from(period)).into_node()
 }
 
 /// A trait containing operators that can be applied to [Node]s.
 /// Used to support method chaining syntax.
-pub trait NodeOperators {
+pub trait NodeOperators<'a> {
     /// Running count of the number of times it's source ticks.
-    /// ```
-    /// # use wingfoil::*;
-    /// # use std::time::Duration;
-    /// // 1, 2, 3, etc.
-    /// ticker(Duration::from_millis(10)).count();
-    /// ```
-    fn count(self: &Rc<Self>) -> Rc<dyn Stream<u64>>;
+    fn count(self: &Rc<Self>) -> Rc<dyn Stream<'a, u64> + 'a>;
 
     /// Emits the time of source ticks in nanos from unix epoch.
-    /// ```
-    /// # use wingfoil::*;
-    /// # use std::time::Duration;
-    /// // 0, 1000000000, 2000000000, etc.
-    /// ticker(Duration::from_millis(10)).ticked_at();
-    /// ```
-    fn ticked_at(self: &Rc<Self>) -> Rc<dyn Stream<NanoTime>>;
+    fn ticked_at(self: &Rc<Self>) -> Rc<dyn Stream<'a, NanoTime> + 'a>;
 
     /// Emits the time of source ticks relative to the start.
-    /// ```
-    /// # use wingfoil::*;
-    /// # use std::time::Duration;
-    /// // 0, 1000000000, 2000000000, etc.
-    /// ticker(Duration::from_millis(10)).ticked_at_elapsed();
-    /// ```
-    fn ticked_at_elapsed(self: &Rc<Self>) -> Rc<dyn Stream<NanoTime>>;
+    fn ticked_at_elapsed(self: &Rc<Self>) -> Rc<dyn Stream<'a, NanoTime> + 'a>;
 
     /// Emits the result of supplied closure on each upstream tick.
-    /// ```
-    /// # use wingfoil::*;
-    /// # use std::time::Duration;
-    /// /// "hello world", "hello world", etc.
-    /// ticker(Duration::from_millis(10)).produce(|| "hello, world");
-    /// ```
-    fn produce<T: Element>(self: &Rc<Self>, func: impl Fn() -> T + 'static) -> Rc<dyn Stream<T>>;
+    fn produce<T: StdDebug + Clone + Default + 'a>(self: &Rc<Self>, func: impl Fn() -> T + 'a) -> Rc<dyn Stream<'a, T> + 'a>;
 
     /// Shortcut for [Graph::run] i.e. initialise and execute the graph.
-    /// ```
-    /// # use wingfoil::*;
-    /// # use std::time::Duration;
-    /// let count = ticker(Duration::from_millis(1))
-    ///     .count();
-    /// count.run(RunMode::HistoricalFrom(NanoTime::ZERO), RunFor::Cycles(3))
-    ///     .unwrap();
-    /// count.peek_value(); // 3
-    /// ```
     fn run(self: &Rc<Self>, run_mode: RunMode, run_to: RunFor) -> anyhow::Result<()>;
-    fn into_graph(self: &Rc<Self>, run_mode: RunMode, run_for: RunFor) -> Graph;
+    fn into_graph(self: &Rc<Self>, run_mode: RunMode, run_for: RunFor) -> Graph<'a>;
 }
 
-impl NodeOperators for dyn Node {
-    fn count(self: &Rc<Self>) -> Rc<dyn Stream<u64>> {
+impl<'a> NodeOperators<'a> for dyn Node<'a> + 'a {
+    fn count(self: &Rc<Self>) -> Rc<dyn Stream<'a, u64> + 'a> {
         constant(1).sample(self.clone()).sum()
     }
 
-    fn ticked_at(self: &Rc<Self>) -> Rc<dyn Stream<NanoTime>> {
-        let f = Box::new(|state: &mut GraphState| state.time());
+    fn ticked_at(self: &Rc<Self>) -> Rc<dyn Stream<'a, NanoTime> + 'a> {
+        let f = Box::new(|state: &mut GraphState<'a>| state.time());
         GraphStateStream::new(self.clone(), f).into_stream()
     }
-    fn ticked_at_elapsed(self: &Rc<Self>) -> Rc<dyn Stream<NanoTime>> {
-        let f = Box::new(|state: &mut GraphState| state.elapsed());
+    fn ticked_at_elapsed(self: &Rc<Self>) -> Rc<dyn Stream<'a, NanoTime> + 'a> {
+        let f = Box::new(|state: &mut GraphState<'a>| state.elapsed());
         GraphStateStream::new(self.clone(), f).into_stream()
     }
-    fn produce<T: Element>(self: &Rc<Self>, func: impl Fn() -> T + 'static) -> Rc<dyn Stream<T>> {
+    fn produce<T: StdDebug + Clone + Default + 'a>(self: &Rc<Self>, func: impl Fn() -> T + 'a) -> Rc<dyn Stream<'a, T> + 'a> {
         ProducerStream::new(self.clone(), Box::new(func)).into_stream()
     }
     fn run(self: &Rc<Self>, run_mode: RunMode, run_for: RunFor) -> anyhow::Result<()> {
         Graph::new(vec![self.clone()], run_mode, run_for).run()
     }
-    fn into_graph(self: &Rc<Self>, run_mode: RunMode, run_for: RunFor) -> Graph {
+    fn into_graph(self: &Rc<Self>, run_mode: RunMode, run_for: RunFor) -> Graph<'a> {
         Graph::new(vec![self.clone()], run_mode, run_for)
     }
 }
 
-impl<T> NodeOperators for dyn Stream<T> {
-    fn count(self: &Rc<Self>) -> Rc<dyn Stream<u64>> {
+impl<'a, T> NodeOperators<'a> for dyn Stream<'a, T> + 'a {
+    fn count(self: &Rc<Self>) -> Rc<dyn Stream<'a, u64> + 'a> {
         self.clone().as_node().count()
     }
-    fn ticked_at(self: &Rc<Self>) -> Rc<dyn Stream<NanoTime>> {
+    fn ticked_at(self: &Rc<Self>) -> Rc<dyn Stream<'a, NanoTime> + 'a> {
         self.clone().as_node().ticked_at()
     }
-    fn ticked_at_elapsed(self: &Rc<Self>) -> Rc<dyn Stream<NanoTime>> {
+    fn ticked_at_elapsed(self: &Rc<Self>) -> Rc<dyn Stream<'a, NanoTime> + 'a> {
         self.clone().as_node().ticked_at_elapsed()
     }
-    fn produce<OUT: Element>(
+    fn produce<OUT: StdDebug + Clone + Default + 'a>(
         self: &Rc<Self>,
-        func: impl Fn() -> OUT + 'static,
-    ) -> Rc<dyn Stream<OUT>> {
+        func: impl Fn() -> OUT + 'a,
+    ) -> Rc<dyn Stream<'a, OUT> + 'a> {
         self.clone().as_node().produce(func)
     }
     fn run(self: &Rc<Self>, run_mode: RunMode, run_for: RunFor) -> anyhow::Result<()> {
         self.clone().as_node().run(run_mode, run_for)
     }
-    fn into_graph(self: &Rc<Self>, run_mode: RunMode, run_for: RunFor) -> Graph {
+    fn into_graph(self: &Rc<Self>, run_mode: RunMode, run_for: RunFor) -> Graph<'a> {
         self.clone().as_node().into_graph(run_mode, run_for)
     }
 }
 
 /// A trait containing operators that can be applied to [Stream]s.
 /// Used to support method chaining syntax.
-pub trait StreamOperators<T: Element> {
+pub trait StreamOperators<'a, T: StdDebug + Clone + Default + 'a> {
     /// accumulate the source into a vector
-    fn accumulate(self: &Rc<Self>) -> Rc<dyn Stream<Vec<T>>>;
+    fn accumulate(self: &Rc<Self>) -> Rc<dyn Stream<'a, Vec<T>> + 'a>;
     /// running average of source
-    fn average(self: &Rc<Self>) -> Rc<dyn Stream<f64>>
+    fn average(self: &Rc<Self>) -> Rc<dyn Stream<'a, f64> + 'a>
     where
         T: ToPrimitive;
     /// Buffer the source stream.  The buffer is automatically flushed on the last cycle;
-    fn buffer(self: &Rc<Self>, capacity: usize) -> Rc<dyn Stream<Vec<T>>>;
+    fn buffer(self: &Rc<Self>, capacity: usize) -> Rc<dyn Stream<'a, Vec<T>> + 'a>;
     /// Buffer the source stream based on time interval. The window is automatically flushed when the interval is exceeded or on the last cycle.
-    fn window(self: &Rc<Self>, interval: Duration) -> Rc<dyn Stream<Vec<T>>>;
+    fn window(self: &Rc<Self>, interval: Duration) -> Rc<dyn Stream<'a, Vec<T>> + 'a>;
     /// Used to accumulate values, which can be retrieved after
     /// the graph has completed running. Useful for unit tests.
-    fn collect(self: &Rc<Self>) -> Rc<dyn Stream<Vec<ValueAt<T>>>>;
+    fn collect(self: &Rc<Self>) -> Rc<dyn Stream<'a, Vec<ValueAt<T>>> + 'a>;
     /// collapses a burst (i.e. IntoIter\[T\]) of ticks into a single tick \[T\].   
     /// Does not tick if burst is empty.
-    fn collapse<OUT>(self: &Rc<Self>) -> Rc<dyn Stream<OUT>>
+    fn collapse<OUT>(self: &Rc<Self>) -> Rc<dyn Stream<'a, OUT> + 'a>
     where
         T: std::iter::IntoIterator<Item = OUT>,
-        OUT: Element;
+        OUT: StdDebug + Clone + Default + 'a;
     fn consume_async<FUT>(
         self: &Rc<Self>,
-        func: Box<dyn FnOnce(Pin<Box<dyn FutStream<T>>>) -> FUT + Send>,
-    ) -> Rc<dyn Node>
+        func: Box<dyn FnOnce(Pin<Box<dyn FutStream<'static, T>>>) -> FUT + Send>,
+    ) -> Rc<dyn Node<'a> + 'a>
     where
-        T: Element + Send,
+        T: Send + 'static,
         FUT: Future<Output = ()> + Send + 'static;
-    fn finally<F: FnOnce(T, &GraphState) + 'static>(self: &Rc<Self>, func: F) -> Rc<dyn Node>;
+    fn finally<F: FnOnce(T, &GraphState<'a>) + 'a>(self: &Rc<Self>, func: F) -> Rc<dyn Node<'a> + 'a>;
     /// executes supplied closure on each tick
-    fn for_each(self: &Rc<Self>, func: impl Fn(T, NanoTime) + 'static) -> Rc<dyn Node>;
+    fn for_each(self: &Rc<Self>, func: impl Fn(T, NanoTime) + 'a) -> Rc<dyn Node<'a> + 'a>;
     // reduce/fold source by applying function
-    fn fold<OUT: Element>(
+    fn fold<OUT: StdDebug + Clone + Default + 'a>(
         self: &Rc<Self>,
-        func: impl Fn(&mut OUT, T) + 'static,
-    ) -> Rc<dyn Stream<OUT>>;
+        func: impl Fn(&mut OUT, T) + 'a,
+    ) -> Rc<dyn Stream<'a, OUT> + 'a>;
     /// difference in it's source from one cycle to the next
-    fn difference(self: &Rc<Self>) -> Rc<dyn Stream<T>>
+    fn difference(self: &Rc<Self>) -> Rc<dyn Stream<'a, T> + 'a>
     where
         T: std::ops::Sub<Output = T>;
 
     /// Propagates it's source, delayed by the specified duration
-    fn delay(self: &Rc<Self>, delay: Duration) -> Rc<dyn Stream<T>>
+    fn delay(self: &Rc<Self>, delay: Duration) -> Rc<dyn Stream<'a, T> + 'a>
     where
         T: Hash + Eq;
     /// Demuxes its source into a Vec of n streams.
@@ -273,10 +241,10 @@ pub trait StreamOperators<T: Element> {
         self: &Rc<Self>,
         capacity: usize,
         func: F,
-    ) -> (Vec<Rc<dyn Stream<T>>>, Overflow<T>)
+    ) -> (Vec<Rc<dyn Stream<'a, T> + 'a>>, Overflow<'a, T>)
     where
-        K: Hash + Eq + PartialEq + std::fmt::Debug + 'static,
-        F: Fn(&T) -> (K, DemuxEvent) + 'static;
+        K: Hash + Eq + PartialEq + std::fmt::Debug + 'a,
+        F: Fn(&T) -> (K, DemuxEvent) + 'a;
     /// Demuxes its source into a vec of n streams, where source is IntoIterator
     /// For example demuxes Vec of U into n streams of Vec of U
     fn demux_it<K, F, U>(
@@ -284,14 +252,14 @@ pub trait StreamOperators<T: Element> {
         capacity: usize,
         func: F,
     ) -> (
-        Vec<Rc<dyn Stream<TinyVec<[U; 1]>>>>,
-        Overflow<TinyVec<[U; 1]>>,
+        Vec<Rc<dyn Stream<'a, TinyVec<[U; 1]>> + 'a>>,
+        Overflow<'a, TinyVec<[U; 1]>>,
     )
     where
         T: IntoIterator<Item = U>,
-        U: Element,
-        K: Hash + Eq + PartialEq + std::fmt::Debug + 'static,
-        F: Fn(&U) -> (K, DemuxEvent) + 'static;
+        U: StdDebug + Clone + Default + 'a,
+        K: Hash + Eq + PartialEq + std::fmt::Debug + 'a,
+        F: Fn(&U) -> (K, DemuxEvent) + 'a;
     /// Demuxes its source into a vec of n streams, where source is IntoIterator
     /// For example demuxes Vec of U into n streams of Vec of U
     fn demux_it_with_map<K, F, U>(
@@ -299,83 +267,83 @@ pub trait StreamOperators<T: Element> {
         map: DemuxMap<K>,
         func: F,
     ) -> (
-        Vec<Rc<dyn Stream<TinyVec<[U; 1]>>>>,
-        Overflow<TinyVec<[U; 1]>>,
+        Vec<Rc<dyn Stream<'a, TinyVec<[U; 1]>> + 'a>>,
+        Overflow<'a, TinyVec<[U; 1]>>,
     )
     where
         T: IntoIterator<Item = U>,
-        U: Element,
-        K: Hash + Eq + PartialEq + std::fmt::Debug + 'static,
-        F: Fn(&U) -> (K, DemuxEvent) + 'static;
+        U: StdDebug + Clone + Default + 'a,
+        K: Hash + Eq + PartialEq + std::fmt::Debug + 'a,
+        F: Fn(&U) -> (K, DemuxEvent) + 'a;
     /// only propagates it's source if it is changed
-    fn distinct(self: &Rc<Self>) -> Rc<dyn Stream<T>>
+    fn distinct(self: &Rc<Self>) -> Rc<dyn Stream<'a, T> + 'a>
     where
         T: PartialEq;
     /// drops source contingent on supplied stream
-    fn filter(self: &Rc<Self>, condition: Rc<dyn Stream<bool>>) -> Rc<dyn Stream<T>>;
+    fn filter(self: &Rc<Self>, condition: Rc<dyn Stream<'a, bool> + 'a>) -> Rc<dyn Stream<'a, T> + 'a>;
     /// drops source contingent on supplied predicate
-    fn filter_value(self: &Rc<Self>, predicate: impl Fn(&T) -> bool + 'static)
-    -> Rc<dyn Stream<T>>;
+    fn filter_value(self: &Rc<Self>, predicate: impl Fn(&T) -> bool + 'a)
+    -> Rc<dyn Stream<'a, T> + 'a>;
     /// propagates source up to limit times
-    fn limit(self: &Rc<Self>, limit: u32) -> Rc<dyn Stream<T>>;
+    fn limit(self: &Rc<Self>, limit: u32) -> Rc<dyn Stream<'a, T> + 'a>;
     /// logs source and propagates it
-    fn logged(self: &Rc<Self>, label: &str, level: Level) -> Rc<dyn Stream<T>>;
+    fn logged(self: &Rc<Self>, label: &str, level: Level) -> Rc<dyn Stream<'a, T> + 'a>;
     /// Map's it's source into a new Stream using the supplied closure.
-    fn map<OUT: Element>(self: &Rc<Self>, func: impl Fn(T) -> OUT + 'static)
-    -> Rc<dyn Stream<OUT>>;
+    fn map<OUT: StdDebug + Clone + Default + 'a>(self: &Rc<Self>, func: impl Fn(T) -> OUT + 'a)
+    -> Rc<dyn Stream<'a, OUT> + 'a>;
     /// Map's source into a new Stream using a fallible closure.
     /// Errors propagate to graph execution.
-    fn try_map<OUT: Element>(
+    fn try_map<OUT: StdDebug + Clone + Default + 'a>(
         self: &Rc<Self>,
-        func: impl Fn(T) -> anyhow::Result<OUT> + 'static,
-    ) -> Rc<dyn Stream<OUT>>;
+        func: impl Fn(T) -> anyhow::Result<OUT> + 'a,
+    ) -> Rc<dyn Stream<'a, OUT> + 'a>;
     /// Uses func to build graph, which is spawned on worker thread
-    fn mapper<FUNC, OUT>(self: &Rc<Self>, func: FUNC) -> Rc<dyn Stream<TinyVec<[OUT; 1]>>>
+    fn mapper<FUNC, OUT>(self: &Rc<Self>, func: FUNC) -> Rc<dyn Stream<'a, TinyVec<[OUT; 1]>> + 'a>
     where
-        T: Element + Send,
-        OUT: Element + Send + Hash + Eq,
-        FUNC: FnOnce(Rc<dyn Stream<TinyVec<[T; 1]>>>) -> Rc<dyn Stream<OUT>> + Send + 'static;
+        T: Send + Default + 'static,
+        OUT: StdDebug + Clone + Default + Send + Hash + Eq + 'static,
+        FUNC: FnOnce(Rc<dyn Stream<'static, TinyVec<[T; 1]>> + 'static>) -> Rc<dyn Stream<'static, OUT> + 'static> + Send + 'static;
     /// negates it's input
-    fn not(self: &Rc<Self>) -> Rc<dyn Stream<T>>
+    fn not(self: &Rc<Self>) -> Rc<dyn Stream<'a, T> + 'a>
     where
         T: std::ops::Not<Output = T>;
 
-    fn reduce(self: &Rc<Self>, func: impl Fn(T, T) -> T + 'static) -> Rc<dyn Stream<T>>;
+    fn reduce(self: &Rc<Self>, func: impl Fn(T, T) -> T + 'a) -> Rc<dyn Stream<'a, T> + 'a>;
     /// samples it's source on each tick of trigger
-    fn sample(self: &Rc<Self>, trigger: Rc<dyn Node>) -> Rc<dyn Stream<T>>;
+    fn sample(self: &Rc<Self>, trigger: Rc<dyn Node<'a> + 'a>) -> Rc<dyn Stream<'a, T> + 'a>;
     // print stream values to stdout
-    fn print(self: &Rc<Self>) -> Rc<dyn Stream<T>>;
-    fn sum(self: &Rc<Self>) -> Rc<dyn Stream<T>>
+    fn print(self: &Rc<Self>) -> Rc<dyn Stream<'a, T> + 'a>;
+    fn sum(self: &Rc<Self>) -> Rc<dyn Stream<'a, T> + 'a>
     where
         T: Add<T, Output = T>;
 }
 
-impl<T> StreamOperators<T> for dyn Stream<T>
+impl<'a, T> StreamOperators<'a, T> for dyn Stream<'a, T> + 'a
 where
-    T: Element + 'static,
+    T: StdDebug + Clone + Default + 'a,
 {
-    fn accumulate(self: &Rc<Self>) -> Rc<dyn Stream<Vec<T>>> {
+    fn accumulate(self: &Rc<Self>) -> Rc<dyn Stream<'a, Vec<T>> + 'a> {
         self.fold(|acc: &mut Vec<T>, value| {
             acc.push(value);
         })
     }
 
-    fn average(self: &Rc<Self>) -> Rc<dyn Stream<f64>>
+    fn average(self: &Rc<Self>) -> Rc<dyn Stream<'a, f64> + 'a>
     where
         T: ToPrimitive,
     {
         AverageStream::new(self.clone()).into_stream()
     }
 
-    fn buffer(self: &Rc<Self>, capacity: usize) -> Rc<dyn Stream<Vec<T>>> {
+    fn buffer(self: &Rc<Self>, capacity: usize) -> Rc<dyn Stream<'a, Vec<T>> + 'a> {
         BufferStream::new(self.clone(), capacity).into_stream()
     }
 
-    fn window(self: &Rc<Self>, interval: Duration) -> Rc<dyn Stream<Vec<T>>> {
+    fn window(self: &Rc<Self>, interval: Duration) -> Rc<dyn Stream<'a, Vec<T>> + 'a> {
         WindowStream::new(self.clone(), NanoTime::new(interval.as_nanos() as u64)).into_stream()
     }
 
-    fn collect(self: &Rc<Self>) -> Rc<dyn Stream<Vec<ValueAt<T>>>> {
+    fn collect(self: &Rc<Self>) -> Rc<dyn Stream<'a, Vec<ValueAt<T>>> + 'a> {
         bimap(
             self.clone(),
             self.clone().as_node().ticked_at(),
@@ -386,10 +354,10 @@ where
         })
     }
 
-    fn collapse<OUT>(self: &Rc<Self>) -> Rc<dyn Stream<OUT>>
+    fn collapse<OUT>(self: &Rc<Self>) -> Rc<dyn Stream<'a, OUT> + 'a>
     where
         T: std::iter::IntoIterator<Item = OUT>,
-        OUT: Element,
+        OUT: StdDebug + Clone + Default + 'a,
     {
         let f = |x: T| match x.into_iter().last() {
             Some(x) => (x, true),
@@ -400,10 +368,10 @@ where
 
     fn consume_async<FUT>(
         self: &Rc<Self>,
-        func: Box<dyn FnOnce(Pin<Box<dyn FutStream<T>>>) -> FUT + Send>,
-    ) -> Rc<dyn Node>
+        func: Box<dyn FnOnce(Pin<Box<dyn FutStream<'static, T>>>) -> FUT + Send>,
+    ) -> Rc<dyn Node<'a> + 'a>
     where
-        T: Element + Send,
+        T: Send + 'static,
         FUT: Future<Output = ()> + Send + 'static,
     {
         AsyncConsumerNode::new(self.clone(), func).into_node()
@@ -413,11 +381,11 @@ where
         self: &Rc<Self>,
         capacity: usize,
         func: F,
-    ) -> (Vec<Rc<dyn Stream<T>>>, Overflow<T>)
+    ) -> (Vec<Rc<dyn Stream<'a, T> + 'a>>, Overflow<'a, T>)
     where
-        T: Element,
-        K: Hash + Eq + PartialEq + std::fmt::Debug + 'static,
-        F: Fn(&T) -> (K, DemuxEvent) + 'static,
+        T: StdDebug + Clone + Default + 'a,
+        K: Hash + Eq + PartialEq + std::fmt::Debug + 'a,
+        F: Fn(&T) -> (K, DemuxEvent) + 'a,
     {
         demux::demux(self.clone(), demux::DemuxMap::new(capacity), func)
     }
@@ -427,14 +395,14 @@ where
         capacity: usize,
         func: F,
     ) -> (
-        Vec<Rc<dyn Stream<TinyVec<[U; 1]>>>>,
-        Overflow<TinyVec<[U; 1]>>,
+        Vec<Rc<dyn Stream<'a, TinyVec<[U; 1]>> + 'a>>,
+        Overflow<'a, TinyVec<[U; 1]>>,
     )
     where
         T: IntoIterator<Item = U>,
-        U: Element,
-        K: Hash + Eq + PartialEq + std::fmt::Debug + 'static,
-        F: Fn(&U) -> (K, DemuxEvent) + 'static,
+        U: StdDebug + Clone + Default + 'a,
+        K: Hash + Eq + PartialEq + std::fmt::Debug + 'a,
+        F: Fn(&U) -> (K, DemuxEvent) + 'a,
     {
         self.demux_it_with_map(DemuxMap::new(capacity), func)
     }
@@ -444,71 +412,71 @@ where
         map: DemuxMap<K>,
         func: F,
     ) -> (
-        Vec<Rc<dyn Stream<TinyVec<[U; 1]>>>>,
-        Overflow<TinyVec<[U; 1]>>,
+        Vec<Rc<dyn Stream<'a, TinyVec<[U; 1]>> + 'a>>,
+        Overflow<'a, TinyVec<[U; 1]>>,
     )
     where
         T: IntoIterator<Item = U>,
-        U: Element,
-        K: Hash + Eq + PartialEq + std::fmt::Debug + 'static,
-        F: Fn(&U) -> (K, DemuxEvent) + 'static,
+        U: StdDebug + Clone + Default + 'a,
+        K: Hash + Eq + PartialEq + std::fmt::Debug + 'a,
+        F: Fn(&U) -> (K, DemuxEvent) + 'a,
     {
-        demux_it(self.clone(), map, func)
+        demux_it(self.clone(), map.size(), func)
     }
 
-    fn for_each(self: &Rc<Self>, func: impl Fn(T, NanoTime) + 'static) -> Rc<dyn Node> {
+    fn for_each(self: &Rc<Self>, func: impl Fn(T, NanoTime) + 'a) -> Rc<dyn Node<'a> + 'a> {
         ConsumerNode::new(self.clone(), Box::new(func)).into_node()
     }
 
-    fn delay(self: &Rc<Self>, duration: Duration) -> Rc<dyn Stream<T>>
+    fn delay(self: &Rc<Self>, duration: Duration) -> Rc<dyn Stream<'a, T> + 'a>
     where
         T: Hash + Eq,
     {
         DelayStream::new(self.clone(), NanoTime::new(duration.as_nanos() as u64)).into_stream()
     }
 
-    fn difference(self: &Rc<Self>) -> Rc<dyn Stream<T>>
+    fn difference(self: &Rc<Self>) -> Rc<dyn Stream<'a, T> + 'a>
     where
         T: std::ops::Sub<Output = T>,
     {
         DifferenceStream::new(self.clone()).into_stream()
     }
 
-    fn distinct(self: &Rc<Self>) -> Rc<dyn Stream<T>>
+    fn distinct(self: &Rc<Self>) -> Rc<dyn Stream<'a, T> + 'a>
     where
         T: PartialEq,
     {
         DistinctStream::new(self.clone()).into_stream()
     }
 
-    fn filter(self: &Rc<Self>, condition: Rc<dyn Stream<bool>>) -> Rc<dyn Stream<T>> {
+    fn filter(self: &Rc<Self>, condition: Rc<dyn Stream<'a, bool> + 'a>) -> Rc<dyn Stream<'a, T> + 'a> {
         FilterStream::new(self.clone(), condition).into_stream()
     }
 
     fn filter_value(
         self: &Rc<Self>,
-        predicate: impl Fn(&T) -> bool + 'static,
-    ) -> Rc<dyn Stream<T>> {
+        predicate: impl Fn(&T) -> bool + 'a,
+    ) -> Rc<dyn Stream<'a, T> + 'a> {
         let condition = self.clone().map(move |val| predicate(&val));
         FilterStream::new(self.clone(), condition).into_stream()
     }
 
-    fn finally<F: FnOnce(T, &GraphState) + 'static>(self: &Rc<Self>, func: F) -> Rc<dyn Node> {
+    fn finally<F: FnOnce(T, &GraphState<'a>) + 'a>(self: &Rc<Self>, func: F) -> Rc<dyn Node<'a> + 'a> {
         FinallyNode::new(self.clone(), Some(func)).into_node()
     }
 
-    fn fold<OUT: Element>(
+    fn fold<OUT: StdDebug + Clone + Default + 'a>(
         self: &Rc<Self>,
-        func: impl Fn(&mut OUT, T) + 'static,
-    ) -> Rc<dyn Stream<OUT>> {
+        func: impl Fn(&mut OUT, T) + 'a,
+    ) -> Rc<dyn Stream<'a, OUT> + 'a> {
         FoldStream::new(self.clone(), Box::new(func)).into_stream()
     }
 
-    fn limit(self: &Rc<Self>, limit: u32) -> Rc<dyn Stream<T>> {
+    fn limit(self: &Rc<Self>, limit: u32) -> Rc<dyn Stream<'a, T> + 'a> {
         LimitStream::new(self.clone(), limit).into_stream()
     }
 
-    fn logged(self: &Rc<Self>, label: &str, level: Level) -> Rc<dyn Stream<T>> {
+    fn logged(self: &Rc<Self>, label: &str, level: Level) -> Rc<dyn Stream<'a, T> + 'a> {
         if log::log_enabled!(level) {
             let lbl = label.to_string();
             let func = move |value, time: NanoTime| {
@@ -525,51 +493,60 @@ where
         }
     }
 
-    fn map<OUT: Element>(
+    fn map<OUT: StdDebug + Clone + Default + 'a>(
         self: &Rc<Self>,
-        func: impl Fn(T) -> OUT + 'static,
-    ) -> Rc<dyn Stream<OUT>> {
-        MapStream::new(self.clone(), Box::new(func)).into_stream()
+        func: impl Fn(T) -> OUT + 'a,
+    ) -> Rc<dyn Stream<'a, OUT> + 'a> {
+        MapStream::new(self.clone(), Default::default(), Box::new(func)).into_stream()
     }
 
-    fn try_map<OUT: Element>(
+    fn try_map<OUT: StdDebug + Clone + Default + 'a>(
         self: &Rc<Self>,
-        func: impl Fn(T) -> anyhow::Result<OUT> + 'static,
-    ) -> Rc<dyn Stream<OUT>> {
+        func: impl Fn(T) -> anyhow::Result<OUT> + 'a,
+    ) -> Rc<dyn Stream<'a, OUT> + 'a> {
         TryMapStream::new(self.clone(), Box::new(func)).into_stream()
     }
 
-    fn mapper<FUNC, OUT>(self: &Rc<Self>, func: FUNC) -> Rc<dyn Stream<TinyVec<[OUT; 1]>>>
+    fn mapper<FUNC, OUT>(self: &Rc<Self>, func: FUNC) -> Rc<dyn Stream<'a, TinyVec<[OUT; 1]>> + 'a>
     where
-        T: Element + Send,
-        OUT: Element + Send + Hash + Eq,
-        FUNC: FnOnce(Rc<dyn Stream<TinyVec<[T; 1]>>>) -> Rc<dyn Stream<OUT>> + Send + 'static,
+        T: Send + Default + 'static,
+        OUT: StdDebug + Clone + Default + Send + Hash + Eq + 'static,
+        FUNC: FnOnce(Rc<dyn Stream<'static, TinyVec<[T; 1]>> + 'static>) -> Rc<dyn Stream<'static, OUT> + 'static> + Send + 'static,
     {
-        GraphMapStream::new(self.clone(), func).into_stream()
+        // This requires 'static because it spawns a thread.
+        // We can't easily propagate 'a to the spawned thread.
+        // If 'a is already 'static, this works.
+        // If not, we have a problem.
+        // For now, let's assume 'static for simplicity in this complex refactor.
+        unsafe {
+            let slf = std::mem::transmute::<Rc<dyn Stream<'a, T> + 'a>, Rc<dyn Stream<'static, T> + 'static>>(self.clone());
+            let node = GraphMapStream::new(slf, func).into_stream();
+            std::mem::transmute::<Rc<dyn Stream<'static, TinyVec<[OUT; 1]>> + 'static>, Rc<dyn Stream<'a, TinyVec<[OUT; 1]>> + 'a>>(node)
+        }
     }
 
-    fn not(self: &Rc<Self>) -> Rc<dyn Stream<T>>
+    fn not(self: &Rc<Self>) -> Rc<dyn Stream<'a, T> + 'a>
     where
         T: std::ops::Not<Output = T>,
     {
         self.map(|value| !value)
     }
 
-    fn print(self: &Rc<Self>) -> Rc<dyn Stream<T>> {
+    fn print(self: &Rc<Self>) -> Rc<dyn Stream<'a, T> + 'a> {
         PrintStream::new(self.clone()).into_stream()
     }
 
-    fn reduce(self: &Rc<Self>, func: impl Fn(T, T) -> T + 'static) -> Rc<dyn Stream<T>> {
+    fn reduce(self: &Rc<Self>, func: impl Fn(T, T) -> T + 'a) -> Rc<dyn Stream<'a, T> + 'a> {
         let f = move |acc: &mut T, val: T| {
             *acc = func((*acc).clone(), val);
         };
         self.fold(f)
     }
 
-    fn sample(self: &Rc<Self>, trigger: Rc<dyn Node>) -> Rc<dyn Stream<T>> {
+    fn sample(self: &Rc<Self>, trigger: Rc<dyn Node<'a> + 'a>) -> Rc<dyn Stream<'a, T> + 'a> {
         SampleStream::new(self.clone(), trigger).into_stream()
     }
-    fn sum(self: &Rc<Self>) -> Rc<dyn Stream<T>>
+    fn sum(self: &Rc<Self>) -> Rc<dyn Stream<'a, T> + 'a>
     where
         T: Add<T, Output = T>,
     {
@@ -578,22 +555,22 @@ where
 }
 
 #[doc(hidden)]
-pub trait TupleStreamOperators<A, B>
+pub trait TupleStreamOperators<'a, A, B>
 where
-    A: Element + 'static,
-    B: Element + 'static,
+    A: StdDebug + Clone + Default + 'a,
+    B: StdDebug + Clone + Default + 'a,
 {
-    fn split(self: &Rc<Self>) -> (Rc<dyn Stream<A>>, Rc<dyn Stream<B>>);
+    fn split(self: &Rc<Self>) -> (Rc<dyn Stream<'a, A> + 'a>, Rc<dyn Stream<'a, B> + 'a>);
 }
 
-impl<A, B> TupleStreamOperators<A, B> for dyn Stream<(A, B)>
+impl<'a, A, B> TupleStreamOperators<'a, A, B> for dyn Stream<'a, (A, B)> + 'a
 where
-    A: Element + 'static,
-    B: Element + 'static,
+    A: StdDebug + Clone + Default + 'a,
+    B: StdDebug + Clone + Default + 'a,
 {
-    fn split(self: &Rc<Self>) -> (Rc<dyn Stream<A>>, Rc<dyn Stream<B>>) {
+    fn split(self: &Rc<Self>) -> (Rc<dyn Stream<'a, A> + 'a>, Rc<dyn Stream<'a, B> + 'a>) {
         let a = self.map(|tuple: (A, B)| tuple.0);
         let b = self.map(|tuple: (A, B)| tuple.1);
         (a, b)
     }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/nodes/print.rs b/wingfoil/src/nodes/print.rs
index a5a06ad..197a3ec 100644
--- a/wingfoil/src/nodes/print.rs
+++ b/wingfoil/src/nodes/print.rs
@@ -2,17 +2,18 @@ use crate::types::*;
 
 use std::ops::Drop;
 use std::rc::Rc;
+use std::fmt::Debug;
 
 /// Propagates input and also pushes into buffer which is printed
 /// on Drop.
-pub struct PrintStream<T: Element> {
-    upstream: Rc<dyn Stream<T>>,
+pub struct PrintStream<'a, T: Debug + Clone + 'a> {
+    upstream: Rc<dyn Stream<'a, T> + 'a>,
     buffer: Vec<T>,
     value: T,
 }
 
-impl<T: Element> PrintStream<T> {
-    pub fn new(upstream: Rc<dyn Stream<T>>) -> PrintStream<T> {
+impl<'a, T: Debug + Clone + Default + 'a> PrintStream<'a, T> {
+    pub fn new(upstream: Rc<dyn Stream<'a, T> + 'a>) -> PrintStream<'a, T> {
         PrintStream {
             upstream,
             buffer: Vec::with_capacity(1000),
@@ -21,27 +22,27 @@ impl<T: Element> PrintStream<T> {
     }
 }
 
-impl<T: Element> MutableNode for PrintStream<T> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + 'a> MutableNode<'a> for PrintStream<'a, T> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.value = self.upstream.peek_value();
         self.buffer.push(self.value.clone());
         Ok(true)
     }
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
 
-impl<T: Element> StreamPeekRef<T> for PrintStream<T> {
+impl<'a, T: Debug + Clone + 'a> StreamPeekRef<'a, T> for PrintStream<'a, T> {
     fn peek_ref(&self) -> &T {
         &self.value
     }
 }
 
-impl<T: Element> Drop for PrintStream<T> {
+impl<'a, T: Debug + Clone + 'a> Drop for PrintStream<'a, T> {
     fn drop(&mut self) {
         for val in self.buffer.iter() {
-            println!("{val:?}");
+            println!("{:?}", val);
         }
     }
 }
diff --git a/wingfoil/src/nodes/producer.rs b/wingfoil/src/nodes/producer.rs
index a16cfd1..dbc3943 100644
--- a/wingfoil/src/nodes/producer.rs
+++ b/wingfoil/src/nodes/producer.rs
@@ -1,32 +1,35 @@
-use derive_new::new;
-
-use std::boxed::Box;
 use std::rc::Rc;
-
 use crate::types::*;
+use std::fmt::Debug;
 
-/// When triggered by it's source, it produces values
-/// using the supplied closure.
-#[derive(new)]
-pub(crate) struct ProducerStream<T: Element> {
-    upstream: Rc<dyn Node>,
-    func: Box<dyn Fn() -> T>,
-    #[new(default)]
+pub(crate) struct ProducerStream<'a, T: Debug + Clone + 'a> {
+    upstream: Rc<dyn Node<'a> + 'a>,
     value: T,
+    func: Box<dyn Fn() -> T + 'a>,
+}
+
+impl<'a, T: Debug + Clone + Default + 'a> ProducerStream<'a, T> {
+    pub fn new(upstream: Rc<dyn Node<'a> + 'a>, func: Box<dyn Fn() -> T + 'a>) -> Self {
+        Self {
+            upstream,
+            value: T::default(),
+            func,
+        }
+    }
 }
 
-impl<T: Element> MutableNode for ProducerStream<T> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + 'a> MutableNode<'a> for ProducerStream<'a, T> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.value = (self.func)();
         Ok(true)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone()], vec![])
     }
 }
 
-impl<T: Element> StreamPeekRef<T> for ProducerStream<T> {
+impl<'a, T: Debug + Clone + 'a> StreamPeekRef<'a, T> for ProducerStream<'a, T> {
     fn peek_ref(&self) -> &T {
         &self.value
     }
diff --git a/wingfoil/src/nodes/sample.rs b/wingfoil/src/nodes/sample.rs
index fe6a35c..3702085 100644
--- a/wingfoil/src/nodes/sample.rs
+++ b/wingfoil/src/nodes/sample.rs
@@ -1,63 +1,36 @@
-use derive_new::new;
-
-use crate::types::*;
 use std::rc::Rc;
+use crate::types::*;
+use std::fmt::Debug;
 
-/// Emit's its source, if and only if, it's trigger ticks.
-/// Used by [sample](crate::nodes::StreamOperators::sample).
-#[derive(new)]
-pub struct SampleStream<T: Element> {
-    upstream: Rc<dyn Stream<T>>,
-    trigger: Rc<dyn Node>,
-    #[new(default)]
+pub struct SampleStream<'a, T: Debug + Clone + 'a> {
+    upstream: Rc<dyn Stream<'a, T> + 'a>,
+    trigger: Rc<dyn Node<'a> + 'a>,
     value: T,
 }
 
-impl<T: Element> MutableNode for SampleStream<T> {
-    fn cycle(&mut self, _state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, T: Debug + Clone + Default + 'a> SampleStream<'a, T> {
+    pub fn new(upstream: Rc<dyn Stream<'a, T> + 'a>, trigger: Rc<dyn Node<'a> + 'a>) -> Self {
+        Self {
+            upstream,
+            trigger,
+            value: T::default(),
+        }
+    }
+}
+
+impl<'a, T: Debug + Clone + 'a> MutableNode<'a> for SampleStream<'a, T> {
+    fn cycle(&mut self, _state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.value = self.upstream.peek_value();
         Ok(true)
     }
 
-    fn upstreams(&self) -> UpStreams {
-        // only ticks on trigger
-        let active = vec![self.trigger.clone()];
-        let passive = vec![self.upstream.clone().as_node()];
-        UpStreams::new(active, passive)
+    fn upstreams(&self) -> UpStreams<'a> {
+        UpStreams::new(vec![self.trigger.clone()], vec![self.upstream.clone().as_node()])
     }
 }
 
-impl<T: Element> StreamPeekRef<T> for SampleStream<T> {
+impl<'a, T: Debug + Clone + 'a> StreamPeekRef<'a, T> for SampleStream<'a, T> {
     fn peek_ref(&self) -> &T {
         &self.value
     }
 }
-
-#[cfg(test)]
-mod tests {
-
-    use super::*;
-    use crate::graph::*;
-    use crate::nodes::*;
-
-    #[test]
-    fn sample_works() {
-        //env_logger::init();
-        let c = ConstantStream::new(7).into_stream();
-        let ticker1 = ticker(Duration::from_millis(100));
-        let ticker2 = ticker(Duration::from_millis(200));
-        let node = c
-            .sample(ticker1)
-            .logged("a", log::Level::Info)
-            .sample(ticker2)
-            .logged("b", log::Level::Info);
-        Graph::new(
-            vec![node.as_node()],
-            RunMode::HistoricalFrom(NanoTime::ZERO),
-            RunFor::Duration(Duration::from_millis(1000)),
-        )
-        .print()
-        .run()
-        .unwrap();
-    }
-}
diff --git a/wingfoil/src/nodes/tick.rs b/wingfoil/src/nodes/tick.rs
index 935b279..bbbe7aa 100644
--- a/wingfoil/src/nodes/tick.rs
+++ b/wingfoil/src/nodes/tick.rs
@@ -1,69 +1,38 @@
 use crate::types::*;
 
-use derive_new::new;
+pub struct TickNode {
+    period: NanoTime,
+}
 
-/// A [Node] that ticks at a specified interval.
-/// Used by [ticker](crate::nodes::ticker).
-#[derive(new)]
-pub(crate) struct TickNode {
-    interval: NanoTime,
-    #[new(default)]
-    at_time: Option<NanoTime>,
+impl TickNode {
+    pub fn new(period: NanoTime) -> Self {
+        Self { period }
+    }
 }
 
-impl MutableNode for TickNode {
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
-        let next_time = match self.at_time {
-            Some(t) => {
-                // anchor to first call to mitigate drift
-                t + self.interval
-            }
-            None => {
-                // first call
-                state.time() + self.interval
+impl<'a> MutableNode<'a> for TickNode {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
+        if self.period > NanoTime::ZERO {
+            if !state.is_last_cycle() {
+                state.add_callback(state.time() + self.period);
             }
-        };
-        self.at_time = Some(next_time);
-        state.add_callback(next_time);
-        Ok(true)
+            Ok(true)
+        } else {
+            // period is zero, already always_callback
+            Ok(true)
+        }
     }
 
-    fn upstreams(&self) -> UpStreams {
-        UpStreams::default()
+    fn upstreams(&self) -> UpStreams<'a> {
+        UpStreams::none()
     }
 
-    fn start(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
-        state.add_callback(NanoTime::ZERO);
+    fn start(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
+        if self.period > NanoTime::ZERO {
+            state.add_callback(state.time());
+        } else {
+            state.always_callback();
+        }
         Ok(())
     }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use crate::graph::*;
-    use crate::nodes::*;
-
-    #[test]
-    fn tick_node_works_in_realtime() {
-        let period = Duration::from_millis(100);
-        let run_to = RunFor::Duration(period * 5);
-        let run_mode = RunMode::RealTime;
-        let average = ticker(period)
-            .ticked_at()
-            .difference()
-            .map(|time| {
-                let t: u64 = time.into();
-                t
-            })
-            .average();
-        let average = average.clone().collect();
-        average.run(run_mode, run_to).unwrap();
-        let average = average.peek_value();
-        average
-            .iter()
-            .for_each(|x| println!("{:} {:?}", x.time, x.value));
-        let err = num::abs(period.as_nanos() as f64 - average.last().unwrap().value);
-        debug_assert!(err < Duration::from_millis(10).as_nanos() as f64)
-    }
-}
+}
\ No newline at end of file
diff --git a/wingfoil/src/nodes/window.rs b/wingfoil/src/nodes/window.rs
index c697642..c8a9905 100644
--- a/wingfoil/src/nodes/window.rs
+++ b/wingfoil/src/nodes/window.rs
@@ -1,21 +1,22 @@
 use crate::types::*;
 use std::rc::Rc;
+use std::fmt::Debug;
 
-pub(crate) struct WindowStream<T: Element> {
-    upstream: Rc<dyn Stream<T>>,
+pub(crate) struct WindowStream<'a, T: Debug + Clone + 'a> {
+    upstream: Rc<dyn Stream<'a, T> + 'a>,
     interval: NanoTime,
     next_window: NanoTime,
     buffer: Vec<T>,
     value: Vec<T>,
 }
 
-impl<T: Element> MutableNode for WindowStream<T> {
-    fn start(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+impl<'a, T: Debug + Clone + 'a> MutableNode<'a> for WindowStream<'a, T> {
+    fn start(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.next_window = state.time() + self.interval;
         Ok(())
     }
 
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool> {
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         let mut flushed = false;
         if state.time() >= self.next_window {
             if !self.buffer.is_empty() {
@@ -41,19 +42,19 @@ impl<T: Element> MutableNode for WindowStream<T> {
         Ok(flushed)
     }
 
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         UpStreams::new(vec![self.upstream.clone().as_node()], vec![])
     }
 }
 
-impl<T: Element> StreamPeekRef<Vec<T>> for WindowStream<T> {
+impl<'a, T: Debug + Clone + 'a> StreamPeekRef<'a, Vec<T>> for WindowStream<'a, T> {
     fn peek_ref(&self) -> &Vec<T> {
         &self.value
     }
 }
 
-impl<T: Element> WindowStream<T> {
-    pub fn new(upstream: Rc<dyn Stream<T>>, interval: NanoTime) -> Self {
+impl<'a, T: Debug + Clone + 'a> WindowStream<'a, T> {
+    pub fn new(upstream: Rc<dyn Stream<'a, T> + 'a>, interval: NanoTime) -> Self {
         Self {
             upstream,
             interval,
@@ -70,6 +71,7 @@ mod tests {
     use crate::graph::*; // For RunMode, RunFor
     use crate::nodes::*;
     use crate::queue::ValueAt; // For ValueAt
+    use std::time::Duration;
 
     #[test]
     fn window_stream_works() {
diff --git a/wingfoil/src/queue/hash_by_ref.rs b/wingfoil/src/queue/hash_by_ref.rs
index 1477365..73b41fa 100644
--- a/wingfoil/src/queue/hash_by_ref.rs
+++ b/wingfoil/src/queue/hash_by_ref.rs
@@ -22,15 +22,16 @@ impl<T: ?Sized> Hash for HashByRef<T> {
     where
         H: Hasher,
     {
-        let ptr = Rc::into_raw(self.val.clone());
-        ptr.hash(state);
-        let _ = unsafe { Rc::from_raw(ptr) };
+        (Rc::as_ptr(&self.val) as *const ()).hash(state);
     }
 }
 
 impl<T: ?Sized> PartialEq for HashByRef<T> {
     fn eq(&self, other: &Self) -> bool {
-        Rc::ptr_eq(&self.val, &other.val)
+        std::ptr::eq(
+            Rc::as_ptr(&self.val) as *const (),
+            Rc::as_ptr(&other.val) as *const (),
+        )
     }
 }
-impl<T: ?Sized> Eq for HashByRef<T> {}
+impl<T: ?Sized> Eq for HashByRef<T> {}
\ No newline at end of file
diff --git a/wingfoil/src/types.rs b/wingfoil/src/types.rs
index f1b7944..e210f7b 100644
--- a/wingfoil/src/types.rs
+++ b/wingfoil/src/types.rs
@@ -11,51 +11,48 @@ pub use crate::time::*;
 /// are wired upstream.   Active nodes trigger [Node].cycle() when they tick.
 /// Passive [Node]s do not.   
 #[derive(new, Default)]
-pub struct UpStreams {
-    pub active: Vec<Rc<dyn Node>>,
-    pub passive: Vec<Rc<dyn Node>>,
+pub struct UpStreams<'a> {
+    pub active: Vec<Rc<dyn Node<'a> + 'a>>,
+    pub passive: Vec<Rc<dyn Node<'a> + 'a>>,
 }
 
-impl UpStreams {
-    pub fn none() -> UpStreams {
+impl<'a> UpStreams<'a> {
+    pub fn none() -> UpStreams<'a> {
         UpStreams::new(Vec::new(), Vec::new())
     }
 }
 
-/// [Stream]s produce values constrained by this trait.  For large structs that you
-/// would prefer not to clone, it is recommended to wrap them in a [Rc](std::rc::Rc)
-/// so they can be cloned cheaply.
-#[doc(hidden)]
-pub trait Element: Debug + Clone + Default + 'static {}
+/// [Stream]s produce values constrained by this trait. 
+pub trait Element: Debug + Clone {}
 
-impl<T> Element for T where T: Debug + Clone + Default + 'static {}
+impl<T> Element for T where T: Debug + Clone {}
 
 /// Implement this trait create your own [Node].
-pub trait MutableNode {
+pub trait MutableNode<'a> {
     /// Called by the graph when it determines that this node
     /// is required to be cycled.
     /// Returns Ok(true) if the node's state changed, Ok(false) otherwise.
-    fn cycle(&mut self, state: &mut GraphState) -> anyhow::Result<bool>;
+    fn cycle(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<bool>;
     /// Called by the graph at wiring time.
-    fn upstreams(&self) -> UpStreams;
+    fn upstreams(&self) -> UpStreams<'a>;
     /// called by the graph after wiring and before start
     #[allow(unused_variables)]
-    fn setup(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn setup(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         Ok(())
     }
     /// Called by the graph after wiring and before the first cycle.
     /// Can be used to request an initial callback.
     #[allow(unused_variables)]
-    fn start(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn start(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         Ok(())
     }
     /// Called by the graph after the last cycle.  Can be used to clean up resources.
     #[allow(unused_variables)]
-    fn stop(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn stop(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         Ok(())
     }
     #[allow(unused_variables)]
-    fn teardown(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn teardown(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         Ok(())
     }
 
@@ -64,79 +61,79 @@ pub trait MutableNode {
     }
 }
 
-impl Display for dyn Node {
+impl<'a> Display for dyn Node<'a> + 'a {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.type_name())
     }
 }
 
-impl<T> Debug for dyn Stream<T> {
+impl<'a, T> Debug for dyn Stream<'a, T> + 'a {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{:?}", self.type_name())
     }
 }
 
 /// A wiring point in the Graph.
-pub trait Node: MutableNode {
+pub trait Node<'a>: MutableNode<'a> {
     /// This is like Node::cycle but doesn't require mutable self
     /// Returns Ok(true) if the node's state changed, Ok(false) otherwise.
-    fn cycle(&self, state: &mut GraphState) -> anyhow::Result<bool>;
-    fn setup(&self, state: &mut GraphState) -> anyhow::Result<()>;
-    fn start(&self, state: &mut GraphState) -> anyhow::Result<()>;
-    fn stop(&self, state: &mut GraphState) -> anyhow::Result<()>;
-    fn teardown(&self, state: &mut GraphState) -> anyhow::Result<()>;
+    fn cycle(&self, state: &mut GraphState<'a>) -> anyhow::Result<bool>;
+    fn setup(&self, state: &mut GraphState<'a>) -> anyhow::Result<()>;
+    fn start(&self, state: &mut GraphState<'a>) -> anyhow::Result<()>;
+    fn stop(&self, state: &mut GraphState<'a>) -> anyhow::Result<()>;
+    fn teardown(&self, state: &mut GraphState<'a>) -> anyhow::Result<()>;
 }
 
 /// A trait through which a reference to [Stream]'s value can
 /// be peeked at.
-pub trait StreamPeekRef<T: Clone>: MutableNode {
+pub trait StreamPeekRef<'a, T>: MutableNode<'a> {
     fn peek_ref(&self) -> &T;
-    fn clone_from_cell_ref(&self, cell_ref: std::cell::Ref<'_, T>) -> T {
+    fn clone_from_cell_ref(&self, cell_ref: std::cell::Ref<'_, T>) -> T where T: Clone {
         cell_ref.clone()
     }
 }
 
 /// The trait through which a [Stream]s can current value
 /// can be peeked at.
-pub trait StreamPeek<T> {
-    fn peek_value(&self) -> T;
+pub trait StreamPeek<'a, T> {
+    fn peek_value(&self) -> T where T: Clone;
     fn peek_ref_cell(&self) -> std::cell::Ref<'_, T>;
 }
 
 /// A [Node] which has some state that can peeked at.
-pub trait Stream<T>: Node + StreamPeek<T> + AsNode {}
+pub trait Stream<'a, T>: Node<'a> + StreamPeek<'a, T> + AsNode<'a> {}
 
 // RefCell
 
-impl<NODE: MutableNode> Node for RefCell<NODE> {
-    fn cycle(&self, state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, NODE: MutableNode<'a>> Node<'a> for RefCell<NODE> {
+    fn cycle(&self, state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.borrow_mut().cycle(state)
     }
-    fn setup(&self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn setup(&self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.borrow_mut().setup(state)
     }
-    fn start(&self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn start(&self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.borrow_mut().start(state)
     }
-    fn stop(&self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn stop(&self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.borrow_mut().stop(state)
     }
-    fn teardown(&self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn teardown(&self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.borrow_mut().teardown(state)
     }
 }
 
-impl<NODE: MutableNode> MutableNode for RefCell<NODE> {
-    fn cycle(&mut self, graph_state: &mut GraphState) -> anyhow::Result<bool> {
+impl<'a, NODE: MutableNode<'a>> MutableNode<'a> for RefCell<NODE> {
+    fn cycle(&mut self, graph_state: &mut GraphState<'a>) -> anyhow::Result<bool> {
         self.borrow_mut().cycle(graph_state)
     }
-    fn upstreams(&self) -> UpStreams {
+    fn upstreams(&self) -> UpStreams<'a> {
         self.borrow().upstreams()
     }
-    fn start(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn start(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.borrow_mut().start(state)
     }
-    fn stop(&mut self, state: &mut GraphState) -> anyhow::Result<()> {
+    fn stop(&mut self, state: &mut GraphState<'a>) -> anyhow::Result<()> {
         self.borrow_mut().stop(state)
     }
     fn type_name(&self) -> String {
@@ -144,72 +141,69 @@ impl<NODE: MutableNode> MutableNode for RefCell<NODE> {
     }
 }
 
-impl<STREAM, T> StreamPeek<T> for RefCell<STREAM>
+impl<'a, STREAM, T> StreamPeek<'a, T> for RefCell<STREAM>
 where
-    STREAM: StreamPeekRef<T>,
-    T: Clone,
+    STREAM: StreamPeekRef<'a, T>,
 {
     fn peek_ref_cell(&self) -> std::cell::Ref<'_, T> {
         std::cell::Ref::map(self.borrow(), |strm| strm.peek_ref())
     }
-    fn peek_value(&self) -> T {
+    fn peek_value(&self) -> T where T: Clone {
         self.borrow().clone_from_cell_ref(self.peek_ref_cell())
     }
 }
 
-impl<STREAM, T> Stream<T> for RefCell<STREAM>
+impl<'a, STREAM, T> Stream<'a, T> for RefCell<STREAM>
 where
-    STREAM: StreamPeekRef<T> + 'static,
-    T: Clone + 'static,
+    STREAM: StreamPeekRef<'a, T> + 'a,
 {
 }
 
 /// Used to cast Rc<dyn [Stream]> to Rc<dyn [Node]>
-pub trait AsNode {
-    fn as_node(self: Rc<Self>) -> Rc<dyn Node>;
+pub trait AsNode<'a> {
+    fn as_node(self: Rc<Self>) -> Rc<dyn Node<'a> + 'a>;
 }
 
-impl<NODE: Node + 'static> AsNode for NODE {
-    fn as_node(self: Rc<Self>) -> Rc<dyn Node> {
+impl<'a, NODE: Node<'a> + 'a> AsNode<'a> for NODE {
+    fn as_node(self: Rc<Self>) -> Rc<dyn Node<'a> + 'a> {
         self
     }
 }
 
 /// Used co cast Rc of concrete stream into Rc of dyn [Stream].
-pub trait AsStream<T> {
-    fn as_stream(self: Rc<Self>) -> Rc<dyn Stream<T>>;
+pub trait AsStream<'a, T> {
+    fn as_stream(self: Rc<Self>) -> Rc<dyn Stream<'a, T> + 'a>;
 }
 
-impl<T, STREAM: Stream<T> + 'static> AsStream<T> for STREAM {
-    fn as_stream(self: Rc<Self>) -> Rc<dyn Stream<T>> {
+impl<'a, T, STREAM: Stream<'a, T> + 'a> AsStream<'a, T> for STREAM {
+    fn as_stream(self: Rc<Self>) -> Rc<dyn Stream<'a, T> + 'a> {
         self
     }
 }
 
 /// Used to consume a concrete [MutableNode] and return
 /// an Rc<dyn [Node]>>.
-pub trait IntoNode {
-    fn into_node(self) -> Rc<dyn Node>;
+pub trait IntoNode<'a> {
+    fn into_node(self) -> Rc<dyn Node<'a> + 'a>;
 }
 
-impl<NODE: MutableNode + 'static> IntoNode for NODE {
-    fn into_node(self) -> Rc<dyn Node> {
+impl<'a, NODE: MutableNode<'a> + 'a> IntoNode<'a> for NODE {
+    fn into_node(self) -> Rc<dyn Node<'a> + 'a> {
         Rc::new(RefCell::new(self))
     }
 }
 
 /// Used to consume a concrete [Stream] and return
 /// an Rc<dyn [Stream]>>.
-pub trait IntoStream<T> {
-    fn into_stream(self) -> Rc<dyn Stream<T>>;
+pub trait IntoStream<'a, T> {
+    fn into_stream(self) -> Rc<dyn Stream<'a, T> + 'a>;
 }
 
-impl<T, STREAM> IntoStream<T> for STREAM
+impl<'a, T, STREAM> IntoStream<'a, T> for STREAM
 where
-    T: Clone + 'static,
-    STREAM: StreamPeekRef<T> + 'static,
+    STREAM: StreamPeekRef<'a, T> + 'a,
 {
-    fn into_stream(self) -> Rc<dyn Stream<T>> {
+    fn into_stream(self) -> Rc<dyn Stream<'a, T> + 'a> {
         Rc::new(RefCell::new(self))
     }
 }