diff --git a/include/pipes2/detail/api/ensureValidOutput.hpp b/include/pipes2/detail/api/ensureValidInputOutput.hpp
similarity index 100%
rename from include/pipes2/detail/api/ensureValidOutput.hpp
rename to include/pipes2/detail/api/ensureValidInputOutput.hpp
diff --git a/include/pipes2/detail/api/makePipes.hpp b/include/pipes2/detail/api/makePipes.hpp
index 6979a49..1763157 100644
--- a/include/pipes2/detail/api/makePipes.hpp
+++ b/include/pipes2/detail/api/makePipes.hpp
@@ -11,7 +11,7 @@
 #include "pipes2/detail/pipes/makeSource.hpp"
 #include "pipes2/detail/pipes/makeSink.hpp"
 
-#include "pipes2/detail/api/ensureValidOutput.hpp"
+#include "pipes2/detail/api/ensureValidInputOutput.hpp"
 
 // throughput pipes
 namespace tillh::pipes2
diff --git a/include/pipes2/detail/api/pipingOperator.hpp b/include/pipes2/detail/api/pipingOperator.hpp
index 6331364..0f52e55 100644
--- a/include/pipes2/detail/api/pipingOperator.hpp
+++ b/include/pipes2/detail/api/pipingOperator.hpp
@@ -3,13 +3,11 @@
 
 #include "pipes2/detail/core/connect.hpp"
 
-#include "pipes2/detail/api/ensureValidOutput.hpp"
-
 namespace tillh::pipes2
 {
   template<class Lhs, class Rhs, std::enable_if_t<(detail::sends<Lhs> || detail::canSend<Lhs>) && (detail::receives<Rhs> || detail::canReceive<Rhs>), bool> = true>
   auto operator>>=(Lhs && lhs, Rhs && rhs)
   {
-    return connectPrimary(std::forward<Lhs>(lhs), std::forward<Rhs>(rhs));
+    return connectPrimary(FWD(lhs), FWD(rhs));
   }
 }
diff --git a/include/pipes2/detail/core/Node.hpp b/include/pipes2/detail/core/Node.hpp
index 289694f..f3be329 100644
--- a/include/pipes2/detail/core/Node.hpp
+++ b/include/pipes2/detail/core/Node.hpp
@@ -5,40 +5,43 @@
 
 #include "pipes2/detail/util/metaprogramming.hpp"
 #include "pipes2/detail/util/ignoreWarning.hpp"
+#include "pipes2/detail/util/FWD.hpp"
 
 #include "pipes2/detail/core/traits.hpp"
 
 namespace tillh::pipes2
 {
-  template<class OpT, class ConnectionsT, class PrimaryConnectionT>
+  template<class OpT, class ConnectionsT>
   struct Node
   {
     using Op = OpT;
     using Connections = ConnectionsT;
-    using PrimaryConnection = PrimaryConnectionT;
 
-    template<class Connections_, class PrimaryConnection_, class Op_>
-    Node(Connections_&& _connections, PrimaryConnection_&& _connectPrimaryion,
-         Op_&& _op): primaryConnection(std::forward<PrimaryConnection_>(_connectPrimaryion)), connections(
-           std::forward<Connections_>(_connections)),
-      op(std::forward<Op_>(_op))
+    template<class Connections_, class Op_>
+    Node(Connections_&& _connections, Op_&& _op):
+      connections(std::forward<Connections_>(_connections)), op(std::forward<Op_>(_op))
     {}
 
-    PrimaryConnection primaryConnection;
+    template<class... Rhss>
+    auto operator()(Rhss&& ... rhss) const
+    {
+      return connectSecondary(*this, FWD(rhss)...);
+    }
+
     Connections connections;
     Op op;
   };
 
-  struct NoPrimary {};
   struct OpenConnectionPlaceHolder {};
+  struct PrimaryOpenConnectionPlaceHolder {};
 }
 
 namespace tillh::pipes2
 {
-  template<class Op, class Connections, class PrimaryConnection>
-  auto makeNode(Op op, Connections connections, PrimaryConnection primaryConnection)
+  template<class Op, class Connections>
+  auto makeNode(Op op, Connections connections)
   {
-    return Node<Op, Connections, PrimaryConnection>(std::move(connections), std::move(primaryConnection), std::move(op));
+    return Node<Op, Connections>(std::move(connections), std::move(op));
   }
 
 
@@ -58,7 +61,17 @@ namespace tillh::pipes2
   template<bool hasPrimaryConnection, std::size_t secondaryConnections, class Op>
   auto makeNode(Op op)
   {
-    constexpr auto makePrimary = [] {if constexpr(hasPrimaryConnection) { return OpenConnectionPlaceHolder(); } else { return NoPrimary(); }};
-    return makeNode(op, makeOpenConnections(std::make_index_sequence<secondaryConnections>()), makePrimary());
+    constexpr auto makePrimary = [] 
+    {
+      if constexpr(hasPrimaryConnection) 
+      {
+        return std::make_tuple(PrimaryOpenConnectionPlaceHolder()); 
+      }
+      else 
+      { 
+        return std::tuple<>();
+      }
+    };
+    return makeNode(op, std::tuple_cat(makeOpenConnections(std::make_index_sequence<secondaryConnections>()), makePrimary()));
   }
 }
diff --git a/include/pipes2/detail/core/connect.hpp b/include/pipes2/detail/core/connect.hpp
index 7b1405a..e36e40d 100644
--- a/include/pipes2/detail/core/connect.hpp
+++ b/include/pipes2/detail/core/connect.hpp
@@ -20,8 +20,8 @@ namespace tillh::pipes2
   template<>
   struct openCountT<OpenConnectionPlaceHolder> : int_constant<1> {};
 
-  template<class Op, class... Connections, class Primary>
-  struct openCountT<Node<Op, std::tuple<Connections...>, Primary>> : sum<openCountT<Connections>...> {};
+  template<class Op, class... Connections>
+  struct openCountT<Node<Op, std::tuple<Connections...>>> : sum<openCountT<Connections>...> {};
 
   template<class T>
   constexpr static std::size_t openCount = openCountT<T>::value;
@@ -77,15 +77,34 @@ namespace tillh::pipes2
       ));
   }
 }
+
 namespace tillh::pipes2
 {
-  enum class ConnectMode{Primary, Secondary};
+  enum class ConnectMode { Primary, Secondary, Any };
 
   template<ConnectMode mode>
   using mode_constant = std::integral_constant<ConnectMode, mode>;
 
   using primary_constant = mode_constant<ConnectMode::Primary>;
   using secondary_constant = mode_constant<ConnectMode::Secondary>;
+  using any_constant = mode_constant<ConnectMode::Secondary>;
+
+  template<class T>
+  decltype(auto) clearPrimary(T&& t)
+  {
+    return FWD(t);
+  }
+
+  inline auto clearPrimary(PrimaryOpenConnectionPlaceHolder)
+  {
+    return OpenConnectionPlaceHolder();
+  }
+
+  template<class Op, class Connections>
+  auto clearPrimary(Node<Op, Connections>&& node)
+  {
+    return makeNode(std::move(node.op), tuple_replace<tuple_back<Connections>>(std::move(node.connections), clearPrimary(getLast(node.connections))));
+  }
 
   template<class Connection, std::size_t... Indices, class NewConnects>
   auto connectIndices(Connection&& connection, std::index_sequence<Indices...>, NewConnects newConnects)
@@ -96,7 +115,7 @@ namespace tillh::pipes2
     }
     else
     {
-      return connectImpl(secondary_constant(), std::forward<Connection>(connection), std::get<Indices>(newConnects)...);
+      return clearPrimary(connectImpl(secondary_constant(), std::forward<Connection>(connection), std::get<Indices>(newConnects)...));
     }
   }
 
@@ -114,6 +133,7 @@ namespace tillh::pipes2
     return connectIndexWise_impl(std::forward<Connections>(connections), indices, newConnects, std::make_index_sequence<connectionCount>());
   }
 }
+
 namespace tillh::pipes2
 {
   template<class Node, class... Children>
@@ -122,37 +142,48 @@ namespace tillh::pipes2
     static_assert(sizeof...(children) > 0);
     static_assert(sizeof...(children) <= openCount<remove_cv_ref_t<Node>>);
     auto indices = getIndices<sizeof...(children), remove_cv_ref_t<Node>>();
-    return makeNode(std::forward<Node>(node).op, connectIndexWise(std::forward<Node>(node).connections, indices, std::forward_as_tuple(children...)), std::forward<Node>(node).primaryConnection);
+    return makeNode(std::forward<Node>(node).op, connectIndexWise(std::forward<Node>(node).connections, indices, std::forward_as_tuple(children...)));
   }
 
   template<class Node, class Child>
   auto connectPrimaryImpl(Node&& node, Child&& child)
   {
-    return makeNode(FWD(node).op, FWD(node).connections, connectImpl(primary_constant(), FWD(node).primaryConnection, FWD(child)));
+    static_assert(canPrimaryConnect<remove_cv_ref_t<Node>>);
+    constexpr std::size_t lastIndex = tuple_back<typename remove_cv_ref_t<Node>::Connections>;
+    return makeNode(FWD(node).op, tuple_replace<lastIndex>(FWD(node).connections, connectImpl(primary_constant(), getLast(FWD(node).connections), FWD(child))));
   }
-  
+
   template<ConnectMode mode, class Lhs, class... Rhss>
   auto connectImpl(mode_constant<mode>, Lhs&& lhs, Rhss&& ... rhss)
   {
     static_assert(sizeof...(Rhss) > 0, "at least 1 rhs needed");
 
-    if constexpr(std::is_same_v<remove_cv_ref_t<Lhs>, OpenConnectionPlaceHolder>)
+    if constexpr(mode == ConnectMode::Secondary)
     {
-      static_assert(sizeof...(Rhss) == 1, "there should never be a call to connect one placeholder with multiple nodes");
-      return getFirst(FWD(rhss)...);
+      if constexpr(std::is_same_v<remove_cv_ref_t<Lhs>, OpenConnectionPlaceHolder>)
+      {
+        static_assert(sizeof...(Rhss) == 1, "there should never be a call to connect one placeholder with multiple nodes");
+        return getFirst(FWD(rhss)...);
+      }
+      else
+      {
+        return evaluateIfFinished(connectSecondaryImpl(FWD(lhs), FWD(rhss)...));
+      }
     }
-    else
+    else if(mode == ConnectMode::Primary)
     {
-      if constexpr(mode == ConnectMode::Secondary)
+      if constexpr(std::is_same_v<remove_cv_ref_t<Lhs>, PrimaryOpenConnectionPlaceHolder>)
       {
-        return evaluateIfFinished(connectSecondaryImpl(FWD(lhs), FWD(rhss)...));
+        static_assert(sizeof...(Rhss) == 1, "there should never be a call to connect one placeholder with multiple nodes");
+        return getFirst(FWD(rhss)...);
       }
-      else if(mode == ConnectMode::Primary)
+      else
       {
         static_assert(sizeof...(Rhss) == 1, "can only primaryconnect 1 at a time");
         return evaluateIfFinished(connectPrimaryImpl(FWD(lhs), FWD(rhss)...));
       }
     }
+
   }
 
   template<ConnectMode mode, class Source, class Node, class... Rhss>
diff --git a/include/pipes2/detail/core/evaluate.hpp b/include/pipes2/detail/core/evaluate.hpp
index 578324c..1fe9983 100644
--- a/include/pipes2/detail/core/evaluate.hpp
+++ b/include/pipes2/detail/core/evaluate.hpp
@@ -7,21 +7,14 @@
 
 namespace tillh::pipes2
 {
-  template<class Op, class Connections, class PrimaryConnection>
-  auto evaluate(Node<Op, Connections, PrimaryConnection>&& node)
+  template<class Op, class Connections>
+  auto evaluate(Node<Op, Connections>&& node)
   {
-    using NodeT = Node<Op, Connections, PrimaryConnection>;
+    using NodeT = Node<Op, Connections>;
     static_assert(!canSecondaryConnect<NodeT>);
     static_assert(!canPrimaryConnect<NodeT>);
 
-    if constexpr(hasPrimary_v<NodeT>)
-    {
-      return makeOutput(std::move(node.op), std::tuple_cat(std::move(node.connections), std::make_tuple(std::move(node.primaryConnection))));
-    }
-    else
-    {
-      return makeOutput(std::move(node.op), std::move(node.connections));
-    }
+    return makeOutput(std::move(node.op), std::move(node.connections));
   }
 
   template<class Node>
diff --git a/include/pipes2/detail/core/traits.hpp b/include/pipes2/detail/core/traits.hpp
index 52388ea..1e978de 100644
--- a/include/pipes2/detail/core/traits.hpp
+++ b/include/pipes2/detail/core/traits.hpp
@@ -57,15 +57,3 @@ namespace tillh::pipes2
   template<class T>
   constexpr static bool canSecondaryConnect = canSecondaryConnectT<T>::value;
 }
-
-namespace tillh::pipes2
-{
-  template<class T>
-  struct hasPrimaryT : std::false_type
-  {
-    static_assert(fail_assert<T>);
-  };
-
-  template<class T>
-  constexpr static bool hasPrimary_v = hasPrimaryT<T>::value;
-}
diff --git a/include/pipes2/detail/core/traits.impl.hpp b/include/pipes2/detail/core/traits.impl.hpp
index f59148d..a5924c4 100644
--- a/include/pipes2/detail/core/traits.impl.hpp
+++ b/include/pipes2/detail/core/traits.impl.hpp
@@ -16,14 +16,14 @@ namespace tillh::pipes2::detail
   template<class Source, class Tree>
   struct isSender<Input<Source, Tree>> : std::true_type {};
 
-  template<class Op, class Connections, class PrimaryConnection>
-  struct isSender<Node<Op, Connections, PrimaryConnection>> : std::true_type {};
+  template<class Op, class Connections>
+  struct isSender<Node<Op, Connections>> : std::true_type {};
 
   template<class Op, class Connections>
   struct isReceiver<Output<Op, Connections>> : std::true_type {};
 
-  template<class Op, class Connections, class PrimaryConnection>
-  struct isReceiver<Node<Op, Connections, PrimaryConnection>> : std::true_type {};
+  template<class Op, class Connections>
+  struct isReceiver<Node<Op, Connections>> : std::true_type {};
 
   template<>
   struct isReceiver<OpenConnectionPlaceHolder> : std::true_type {};
@@ -46,17 +46,17 @@ namespace tillh::pipes2::detail
 
 namespace tillh::pipes2
 {
-  template<>
-  struct canPrimaryConnectT<NoPrimary> : std::false_type {};
-
   template<class Op, class Connections>
   struct canPrimaryConnectT<Output<Op, Connections>> : std::false_type {};
 
   template<>
-  struct canPrimaryConnectT<OpenConnectionPlaceHolder> : std::true_type {};
+  struct canPrimaryConnectT<PrimaryOpenConnectionPlaceHolder> : std::true_type {};
 
-  template<class Op, class Connections, class PrimaryConnection>
-  struct canPrimaryConnectT<Node<Op, Connections, PrimaryConnection>> : canPrimaryConnectT<PrimaryConnection> {};
+  template<>
+  struct canPrimaryConnectT<OpenConnectionPlaceHolder> : std::false_type {};
+
+  template<class Op, class Connections>
+  struct canPrimaryConnectT<Node<Op, Connections>> : canPrimaryConnectT<last_element<Connections>> {};
 }
 
 namespace tillh::pipes2
@@ -64,15 +64,12 @@ namespace tillh::pipes2
   template<>
   struct canSecondaryConnectT<OpenConnectionPlaceHolder> : std::true_type {};
 
+  template<>
+  struct canSecondaryConnectT<PrimaryOpenConnectionPlaceHolder> : std::false_type {};
+
   template<class Op, class Connections>
   struct canSecondaryConnectT<Output<Op, Connections>> : std::false_type {};
 
-  template<class Op, class... Connections, class PrimaryConnection>
-  struct canSecondaryConnectT<Node<Op, std::tuple<Connections...>, PrimaryConnection>> : std::disjunction<canSecondaryConnectT<Connections>...> {};
-}
-
-namespace tillh::pipes2
-{
-  template<class Op, class Connections, class PrimaryConnection>
-  struct hasPrimaryT<Node<Op, Connections, PrimaryConnection>> : std::negation<std::is_same<PrimaryConnection, NoPrimary>> {};
+  template<class Op, class... Connections>
+  struct canSecondaryConnectT<Node<Op, std::tuple<Connections...>>> : std::disjunction<canSecondaryConnectT<Connections>...> {};
 }
diff --git a/include/pipes2/detail/pipes/makeSource.hpp b/include/pipes2/detail/pipes/makeSource.hpp
index 0c1d666..ba93d00 100644
--- a/include/pipes2/detail/pipes/makeSource.hpp
+++ b/include/pipes2/detail/pipes/makeSource.hpp
@@ -17,7 +17,7 @@ namespace tillh::pipes2::detail
   template<class T>
   auto makeSourceInput(T&& t)
   {
-    return makeInput(std::forward<T>(t), OpenConnectionPlaceHolder());
+    return makeInput(std::forward<T>(t), PrimaryOpenConnectionPlaceHolder());
   }
 
   template<class Range, std::enable_if_t<is_range_v<remove_cv_ref_t<Range>>, bool> = true>
diff --git a/include/pipes2/detail/util/metaprogramming.hpp b/include/pipes2/detail/util/metaprogramming.hpp
index 10b9bcc..ad426d7 100644
--- a/include/pipes2/detail/util/metaprogramming.hpp
+++ b/include/pipes2/detail/util/metaprogramming.hpp
@@ -3,6 +3,8 @@
 #include <type_traits>
 #include <tuple>
 
+#include "pipes2/detail/util/FWD.hpp"
+
 namespace tillh::pipes2
 {
   template<class... T>
@@ -20,28 +22,28 @@ namespace tillh::pipes2
   template<class T> using remove_cv_ref_t = typename remove_cv_ref<T>::type;
 
   template<std::size_t pickIndex, std::size_t currentIndex, class Tuple, class T >
-  auto pick(Tuple& tuple, T& t)
+  auto pick(Tuple&& tuple, T&& t)
   {
     if constexpr(pickIndex == currentIndex)
     {
-      return std::move(t);
+      return FWD(t);
     }
     else
     {
-      return std::move(std::get<currentIndex>(tuple));
+      return std::get<currentIndex>(FWD(tuple));
     }
   }
 
   template<std::size_t index, std::size_t... Is, class Tuple, class T>
-  auto tuple_replace_impl(Tuple& tuple, T& t, std::index_sequence<Is...>)
+  auto tuple_replace_impl(Tuple&& tuple, T&& t, std::index_sequence<Is...>)
   {
-    return std::make_tuple(std::move(pick<index, Is>(tuple, t))...);
+    return std::make_tuple(std::move(pick<index, Is>(FWD(tuple), FWD(t)))...);
   }
 
   template<std::size_t index, class Tuple, class T>
-  auto tuple_replace(Tuple& tuple, T& t)
+  auto tuple_replace(Tuple&& tuple, T&& t)
   {
-    return tuple_replace_impl<index>(tuple, t, std::make_index_sequence<std::tuple_size_v<Tuple>>());
+    return tuple_replace_impl<index>(FWD(tuple), FWD(t), std::make_index_sequence<std::tuple_size_v<remove_cv_ref_t<Tuple>>>());
   }
 
   template<class T>
@@ -55,11 +57,17 @@ namespace tillh::pipes2
   struct TypeList {};
 
   template<class... Ts>
-  auto typeList(Type<std::tuple<Ts...>>)
+  constexpr auto typeList(Type<std::tuple<Ts...>>)
   {
     return TypeList<Ts...>{};
   }
 
+  template<class... Ts, class T>
+  constexpr auto append(TypeList<Ts...>, Type<T>)
+  {
+    return TypeList<Ts..., T>();
+  }
+
   namespace detail
   {
     template<typename...>
@@ -137,3 +145,18 @@ namespace tillh::pipes2
   template<class... Ts>
   using sum = int_constant<(Ts::value + ...)>;
 }
+
+namespace tillh::pipes2
+{
+  template<class Tuple>
+  constexpr static std::size_t tuple_back = std::tuple_size_v<Tuple> -1;
+
+  template<class Tuple>
+  using last_element = std::tuple_element_t<tuple_back<Tuple>, Tuple>;
+
+  template<class Tuple>
+  decltype(auto) getLast(Tuple&& tuple)
+  {
+    return std::get<tuple_back<remove_cv_ref_t<Tuple>>>(FWD(tuple));
+  }
+}
diff --git a/test/src/detail/SyntaxTree.cpp b/test/src/detail/SyntaxTree.cpp
index d87888a..7cf647d 100644
--- a/test/src/detail/SyntaxTree.cpp
+++ b/test/src/detail/SyntaxTree.cpp
@@ -1,26 +1,31 @@
 #include <gtest/gtest.h>
 
-#include <pipes2/detail/core/connect.hpp>
-#include <pipes2/detail/core/traits.impl.hpp>
+#include <pipes2/pipes.hpp>
 
 #include "../Dummy.hpp"
 #include "is_node.hpp"
 
-using namespace tillh::pipes2;
+namespace pipes = tillh::pipes2;
 
-using Open = OpenConnectionPlaceHolder;
+using Open = pipes::OpenConnectionPlaceHolder;
 using Closed = DummyOutput;
 auto makeOutput() { return Closed{DummyOp(), {}}; }
 
 template<std::size_t index, class Node1, class Node2>
 auto replace(Node1 node1, Node2 node2)
 {
-  return makeNode(node1.op, tuple_replace<index>(node1.connections, node2), node1.primaryConnection);
+  return pipes::makeNode(node1.op, pipes::tuple_replace<index>(node1.connections, node2));
+}
+
+template<bool hasPrimary, std::size_t secondaries>
+constexpr auto node()
+{
+  return pipes::makeNode<hasPrimary, secondaries>(DummyOp());
 }
 
 TEST(isNode, node)
 {
-  using NodeT = Node<DummyOp, std::tuple<>, Open>;
+  using NodeT = pipes::Node<DummyOp, std::tuple<>>;
   static_assert(is_node_v<NodeT>);
 }
 
@@ -31,169 +36,248 @@ TEST(isNode, int)
 
 TEST(canSecondaryConnect, singleOpen)
 {
-  using NodeT = Node<DummyOp, std::tuple<Open>, NoPrimary>;
-  static_assert(canSecondaryConnect<NodeT>);
+  using NodeT = pipes::Node<DummyOp, std::tuple<Open>>;
+  static_assert(pipes::canSecondaryConnect<NodeT>);
 }
 
 TEST(canSecondaryConnect, singleClosed)
 {
-  using NodeT = Node<DummyOp, std::tuple<Closed>, NoPrimary>;
-  static_assert(!canSecondaryConnect<NodeT>);
+  using NodeT = pipes::Node<DummyOp, std::tuple<Closed>>;
+  static_assert(!pipes::canSecondaryConnect<NodeT>);
 }
 
 TEST(canSecondaryConnect, secondOpen)
 {
-  using NodeT = Node<DummyOp, std::tuple<Closed, Open>, NoPrimary>;
-  static_assert(canSecondaryConnect<NodeT>);
+  using NodeT = pipes::Node<DummyOp, std::tuple<Closed, Open>>;
+  static_assert(pipes::canSecondaryConnect<NodeT>);
 }
 
 TEST(canSecondaryConnect, twoClosed)
 {
-  using NodeT = Node<DummyOp, std::tuple<Closed, Closed>, NoPrimary>;
-  static_assert(!canSecondaryConnect<NodeT>);
+  using NodeT = pipes::Node<DummyOp, std::tuple<Closed, Closed>>;
+  static_assert(!pipes::canSecondaryConnect<NodeT>);
 }
 
 TEST(canSecondaryConnect, manyClosed)
 {
-  using NodeT = Node<DummyOp, std::tuple<Closed, Closed, Closed, Closed, Closed, Closed, Closed>, NoPrimary>;
-  static_assert(!canSecondaryConnect<NodeT>);
+  using NodeT = pipes::Node<DummyOp, std::tuple<Closed, Closed, Closed, Closed, Closed, Closed, Closed>>;
+  static_assert(!pipes::canSecondaryConnect<NodeT>);
 }
 
 TEST(canSecondaryConnect, manyOneOpen)
 {
-  using NodeT = Node<DummyOp, std::tuple<Closed, Closed, Closed, Open, Closed, Closed, Closed>, NoPrimary>;
-  static_assert(canSecondaryConnect<NodeT>);
+  using NodeT = pipes::Node<DummyOp, std::tuple<Closed, Closed, Closed, Open, Closed, Closed, Closed>>;
+  static_assert(pipes::canSecondaryConnect<NodeT>);
 }
 
 TEST(canSecondaryConnect, manySeveralOpen)
 {
-  using NodeT = Node<DummyOp, std::tuple<Closed, Closed, Closed, Open, Closed, Closed, Open, Closed>, NoPrimary>;
-  static_assert(canSecondaryConnect<NodeT>);
+  using NodeT = pipes::Node<DummyOp, std::tuple<Closed, Closed, Closed, Open, Closed, Closed, Open, Closed>>;
+  static_assert(pipes::canSecondaryConnect<NodeT>);
 }
 
 TEST(connectSecondaryImpl, singleNodeToOutput)
 {
-  auto node1 = makeNode<false, 1>(DummyOp());
+  auto node1 = node<false, 1>();
   using NodeT = decltype(node1);
-  static_assert(canSecondaryConnect<NodeT>);
-  static_assert(!canPrimaryConnect<NodeT>);
+  static_assert(pipes::canSecondaryConnect<NodeT>);
+  static_assert(!pipes::canPrimaryConnect<NodeT>);
 
   auto node2 = makeOutput();
-  static_assert(is_output_v<decltype(node2)>);
+  static_assert(pipes::is_output_v<decltype(node2)>);
 
-  auto result = connectImpl(secondary_constant(), node1, node2);
-  static_assert(is_output_v<decltype(result)>);
+  auto result = pipes::connectImpl(pipes::secondary_constant(), node1, node2);
+  static_assert(pipes::is_output_v<decltype(result)>);
 }
 
 TEST(connectSecondaryImpl, depthFirst)
 {
-  auto node1 = makeNode<false, 2>(DummyOp());
-  static_assert(canSecondaryConnect<decltype(node1)>);
+  auto node1 = node<false, 2>();
+  static_assert(pipes::canSecondaryConnect<decltype(node1)>);
 
-  auto node2 = makeNode<false, 1>(DummyOp());
-  static_assert(canSecondaryConnect<decltype(node2)>);
+  auto node2 = node<false, 1>();
+  static_assert(pipes::canSecondaryConnect<decltype(node2)>);
 
-  auto node3 = connectSecondaryImpl(node1, node2);
-  static_assert(canSecondaryConnect<decltype(node3)>);
+  auto node3 = pipes::connectSecondaryImpl(node1, node2);
+  static_assert(pipes::canSecondaryConnect<decltype(node3)>);
 
   auto output = makeOutput();
-  auto result = connectImpl(secondary_constant(), node3, output);
-  static_assert(canSecondaryConnect<decltype(result)>);
+  auto result = pipes::connectImpl(pipes::secondary_constant(), node3, output);
+  static_assert(pipes::canSecondaryConnect<decltype(result)>);
 }
 
 TEST(connectSecondaryImpl, openCount)
 {
-  auto node1 = makeNode<false, 2>(DummyOp());
-  static_assert(openCount<decltype(node1)> == 2);
+  auto node1 = node<false, 2>();
+  static_assert(pipes::openCount<decltype(node1)> == 2);
 
-  auto node2 = makeNode<false, 1>(DummyOp());
-  static_assert(openCount<decltype(node2)> == 1);
+  auto node2 = node<false, 1>();
+  static_assert(pipes::openCount<decltype(node2)> == 1);
 
   auto node3 = replace<0>(node1, node2);
-  static_assert(openCount<decltype(node3)> == 2);
+  static_assert(pipes::openCount<decltype(node3)> == 2);
 
   auto output = makeOutput();
   auto result = replace<0>(node1, replace<0>(node2, output));
-  static_assert(openCount<decltype(result)> == 1);
+  static_assert(pipes::openCount<decltype(result)> == 1);
 }
 
 TEST(connectSecondaryImpl, getIndices_x)
 {
-  static_assert(std::is_same_v<decltype(getIndices_x<0, 4, 1>()), std::index_sequence<0>>);
-  static_assert(std::is_same_v<decltype(getIndices_x<1, 4, 3>()), std::index_sequence<1, 2, 3>>);
-  static_assert(std::is_same_v<decltype(getIndices_x<0, 3, 1>()), std::index_sequence<0>>);
-  static_assert(std::is_same_v<decltype(getIndices_x<1, 3, 1>()), std::index_sequence<1>>);
-  static_assert(std::is_same_v<decltype(getIndices_x<2, 3, 1>()), std::index_sequence<2>>);
-  static_assert(std::is_same_v<decltype(getIndices_x<0, 1, 1>()), std::index_sequence<0>>);
-
-  static_assert(std::is_same_v<decltype(getIndices_x<0, 3, 1>()), std::index_sequence<0>>);
-  static_assert(std::is_same_v<decltype(getIndices_x<1, 3, 3>()), std::index_sequence<1, 2>>);
-  static_assert(std::is_same_v<decltype(getIndices_x<0, 2, 1>()), std::index_sequence<0>>);
-  static_assert(std::is_same_v<decltype(getIndices_x<1, 2, 1>()), std::index_sequence<1>>);
-  static_assert(std::is_same_v<decltype(getIndices_x<2, 2, 1>()), std::index_sequence<>>);
-  static_assert(std::is_same_v<decltype(getIndices_x<3, 2, 1>()), std::index_sequence<>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices_x<0, 4, 1>()), std::index_sequence<0>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices_x<1, 4, 3>()), std::index_sequence<1, 2, 3>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices_x<0, 3, 1>()), std::index_sequence<0>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices_x<1, 3, 1>()), std::index_sequence<1>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices_x<2, 3, 1>()), std::index_sequence<2>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices_x<0, 1, 1>()), std::index_sequence<0>>);
+
+  static_assert(std::is_same_v<decltype(pipes::getIndices_x<0, 3, 1>()), std::index_sequence<0>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices_x<1, 3, 3>()), std::index_sequence<1, 2>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices_x<0, 2, 1>()), std::index_sequence<0>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices_x<1, 2, 1>()), std::index_sequence<1>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices_x<2, 2, 1>()), std::index_sequence<>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices_x<3, 2, 1>()), std::index_sequence<>>);
 }
 
 
 TEST(connectSecondaryImpl, getIndices)
 {
-  auto node1 = makeNode<false, 2>(DummyOp());
-  auto node2 = makeNode<false, 3>(DummyOp());
-  auto node3 = makeNode<false, 1>(DummyOp());
+  auto node1 = node<false, 2>();
+  auto node2 = node<false, 3>();
+  auto node3 = node<false, 1>();
 
   auto combined = replace<1>(node1, replace<1>(node2, node3));
 
-  static_assert(std::is_same_v<decltype(getIndices<4, decltype(combined)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1, 2, 3>>>);
-  static_assert(std::is_same_v<decltype(getIndices<3, decltype(combined)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1, 2>>>);
-  static_assert(std::is_same_v<decltype(getIndices<2, decltype(combined)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1>>>);
-  static_assert(std::is_same_v<decltype(getIndices<1, decltype(combined)>()), std::tuple<std::index_sequence<0>, std::index_sequence<>>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices<4, decltype(combined)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1, 2, 3>>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices<3, decltype(combined)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1, 2>>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices<2, decltype(combined)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1>>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices<1, decltype(combined)>()), std::tuple<std::index_sequence<0>, std::index_sequence<>>>);
   
   auto combined2 = replace<1>(node2, node3);
 
-  static_assert(std::is_same_v<decltype(getIndices<3, decltype(combined2)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1>, std::index_sequence<2>>>);
-  static_assert(std::is_same_v<decltype(getIndices<2, decltype(combined2)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1>, std::index_sequence<>>>);
-  static_assert(std::is_same_v<decltype(getIndices<1, decltype(combined2)>()), std::tuple<std::index_sequence<0>, std::index_sequence<>, std::index_sequence<>>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices<3, decltype(combined2)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1>, std::index_sequence<2>>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices<2, decltype(combined2)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1>, std::index_sequence<>>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices<1, decltype(combined2)>()), std::tuple<std::index_sequence<0>, std::index_sequence<>, std::index_sequence<>>>);
 }
 
+TEST(connectSecondaryImpl, getIndicesWithPrimary)
+{
+  auto node1 = node<false, 2>();
+  auto node2 = node<false, 3>();
+  auto node3 = node<false, 1>();
+
+  auto combined = replace<1>(node1, replace<1>(node2, node3));
+
+  static_assert(std::is_same_v<decltype(pipes::getIndices<4, decltype(combined)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1, 2, 3>>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices<3, decltype(combined)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1, 2>>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices<2, decltype(combined)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1>>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices<1, decltype(combined)>()), std::tuple<std::index_sequence<0>, std::index_sequence<>>>);
+
+  auto combined2 = replace<1>(node2, node3);
+
+  static_assert(std::is_same_v<decltype(pipes::getIndices<3, decltype(combined2)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1>, std::index_sequence<2>>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices<2, decltype(combined2)>()), std::tuple<std::index_sequence<0>, std::index_sequence<1>, std::index_sequence<>>>);
+  static_assert(std::is_same_v<decltype(pipes::getIndices<1, decltype(combined2)>()), std::tuple<std::index_sequence<0>, std::index_sequence<>, std::index_sequence<>>>);
+}
 TEST(connectNew, connectSecondaryImpl)
 {
-  const auto node1 = makeNode<false, 1>(DummyOp());
-  const auto node2 = makeNode<false, 2>(DummyOp());
-  const auto node3 = makeNode<false, 3>(DummyOp());
+  const auto node1 = node<false, 1>();
+  const auto node2 = node<false, 2>();
+  const auto node3 = node<false, 3>();
   {
-    auto result = connectSecondaryImpl(node1, node1);
+    auto result = pipes::connectSecondaryImpl(node1, node1);
     auto expected = replace<0>(node1, node1);
     static_assert(std::is_same_v<decltype(result), decltype(expected)>);
   }
   {
-    auto result = connectSecondaryImpl(node2, node1, node2);
+    auto result = pipes::connectSecondaryImpl(node2, node1, node2);
     auto expected = replace<1>(replace<0>(node2, node1), node2);
     static_assert(std::is_same_v<decltype(result), decltype(expected)>);
   }
   {
-    auto result = connectSecondaryImpl(node3, node1, node2);
+    auto result = pipes::connectSecondaryImpl(node3, node1, node2);
     auto expected = replace<1>(replace<0>(node3, node1), node2);
     static_assert(std::is_same_v<decltype(result), decltype(expected)>);
   }
 }
 TEST(connectNew, connect_secondary)
 {
-  const auto node1 = makeNode<false, 1>(DummyOp());
-  const auto node2 = makeNode<false, 2>(DummyOp());
-  const auto node3 = makeNode<false, 3>(DummyOp());
+  const auto node1 = node<false, 1>();
+  const auto node2 = node<false, 2>();
+  const auto node3 = node<false, 3>();
   {
-    auto result = connectImpl(secondary_constant(), node1, node1);
+    auto result = pipes::connectImpl(pipes::secondary_constant(), node1, node1);
     auto expected = replace<0>(node1, node1);
     static_assert(std::is_same_v<decltype(result), decltype(expected)>);
   }
   {
-    auto result = connectImpl(secondary_constant(), node2, node1, node2);
+    auto result = pipes::connectImpl(pipes::secondary_constant(), node2, node1, node2);
     auto expected = replace<1>(replace<0>(node2, node1), node2);
     static_assert(std::is_same_v<decltype(result), decltype(expected)>);
   }
   {
-    auto result = connectImpl(secondary_constant(), node3, node1, node2);
+    auto result = pipes::connectImpl(pipes::secondary_constant(), node3, node1, node2);
     auto expected = replace<1>(replace<0>(node3, node1), node2);
     static_assert(std::is_same_v<decltype(result), decltype(expected)>);
   }
 }
+
+
+template<bool hasPrimary, std::size_t secondaries>
+constexpr auto nodeT()
+{
+  return pipes::Type<decltype(node<hasPrimary, secondaries>())>();
+}
+
+template<bool hasPrimary, std::size_t secondaries, class T>
+constexpr bool isNode(pipes::Type<T>)
+{
+  return pipes::canPrimaryConnect<pipes::remove_cv_ref_t<T>> == hasPrimary && pipes::openCount<pipes::remove_cv_ref_t<T>> == secondaries;
+}
+
+#define T(x) pipes::Type<decltype(x)>()
+
+TEST(connectNew, counts)
+{
+  const auto f1 = node<false, 1>();
+  const auto f2 = node<false, 2>();
+  const auto f3 = node<false, 3>();
+
+  const auto t1 = node<true, 1>();
+  const auto t2 = node<true, 2>();
+  const auto t3 = node<true, 3>();
+
+  static_assert(isNode<false, 1>(T(f1)));
+  static_assert(isNode<false, 2>(T(f2)));
+  static_assert(isNode<false, 3>(T(f3)));
+
+  static_assert(isNode<true, 1>(T(t1)));
+  static_assert(isNode<true, 2>(T(t2)));
+  static_assert(isNode<true, 3>(T(t3)));
+
+  {
+    const auto n = pipes::connectPrimary(node<true, 1>(), node<false, 1>());
+    static_assert(isNode<false, 2>(T(n)));
+  }
+  {
+    const auto n = pipes::connectPrimary(node<true, 2>(), node<false, 3>());
+    static_assert(isNode<false, 5>(T(n)));
+  }
+  {
+    const auto n = pipes::connectPrimary(node<true, 1>(), node<true, 1>());
+    static_assert(isNode<true, 2>(T(n)));
+  }
+  {
+    const auto n = pipes::connectPrimary(node<true, 2>(), node<true, 3>());
+    static_assert(isNode<true, 5>(T(n)));
+  }
+   //secondary
+  {
+    const auto n = pipes::connectSecondary(node<true, 1>(), node<false, 1>());
+    static_assert(isNode<true, 1>(T(n)));
+  }
+  {
+    const auto n = pipes::connectSecondary(node<true, 1>(), node<true, 1>());
+    static_assert(isNode<true, 2>(T(n)));
+  }
+}
diff --git a/test/src/detail/is_node.hpp b/test/src/detail/is_node.hpp
index 0a6dcdf..69d5db2 100644
--- a/test/src/detail/is_node.hpp
+++ b/test/src/detail/is_node.hpp
@@ -3,8 +3,8 @@
 template<class T>
 struct is_node : std::false_type {};
 
-template<class Op, class Connections, class PrimaryConnection>
-struct is_node<tillh::pipes2::Node<Op, Connections, PrimaryConnection>> : std::true_type {};
+template<class Op, class Connections>
+struct is_node<tillh::pipes2::Node<Op, Connections>> : std::true_type {};
 
 template<class T>
 constexpr auto is_node_v = is_node<T>::value;
diff --git a/test/src/pipes.cpp b/test/src/pipes.cpp
index 5d809f7..82a5894 100644
--- a/test/src/pipes.cpp
+++ b/test/src/pipes.cpp
@@ -532,11 +532,84 @@ TEST_F(placeholders, tee)
   auto result2 = std::vector<int>{};
 
   auto halfPipe = tee(_) >>= transform(Transform()) >>= result2;
-  
-  //base >>= halfPipe(result1);
+
+  base >>= halfPipe(result1);
 
   const auto expected1 = base;
   const auto expected2 = Transform().each(base);
   EXPECT_EQ(result1, expected1);
   EXPECT_EQ(result2, expected2);
 }
+
+TEST_F(placeholders, demux)
+{
+  const std::vector<int> base = {1,2,3,4,5};
+  auto result1 = std::vector<int>{};
+  auto result2 = std::vector<int>{};
+  auto result3 = std::vector<int>{};
+
+  auto halfPipe = demux(_, transform(Transform()) >>= result2, _);
+
+  base >>= halfPipe(result1, filter(Filter()) >>= result3);
+
+  const auto expected1 = base;
+  const auto expected2 = Transform().each(base);
+  const auto expected3 = Filter().each(base);
+  EXPECT_EQ(result1, expected1);
+  EXPECT_EQ(result2, expected2);
+  EXPECT_EQ(result3, expected3);
+}
+
+TEST_F(placeholders, primaryOpen)
+{
+  const std::vector<int> base = {1,2,3,4,5};
+  auto result1 = std::vector<int>{};
+  auto result2 = std::vector<int>{};
+
+  auto halfPipe = demux(filter(Filter()), transform(Transform()));
+  auto halfPipe2 = halfPipe(result1);
+  auto fullPipe = halfPipe2(result2);
+
+  base >>= fullPipe;
+
+  const auto expected1 = Filter().each(base);
+  const auto expected2 = Transform().each(base);
+  EXPECT_EQ(result1, expected1);
+  EXPECT_EQ(result2, expected2);
+}
+
+TEST_F(placeholders, primaryConnectWithOpenSecondaries)
+{
+  const std::vector<int> base = {1,2,3,4,5};
+  auto result1 = std::vector<int>{};
+  auto result2 = std::vector<int>{};
+
+  auto halfPipe = tee(_) >>= demux(_);
+  auto halfPipe2 = halfPipe(filter(Filter()) >>= result1);
+  auto fullPipe = halfPipe2(transform(Transform()) >>= result2);
+
+  base >>= fullPipe;
+
+  const auto expected1 = Filter().each(base);
+  const auto expected2 = Transform().each(base);
+  EXPECT_EQ(result1, expected1);
+  EXPECT_EQ(result2, expected2);
+}
+
+TEST_F(placeholders, primaryConnectWithPrimaryOpenInSecondaries)
+{
+  const std::vector<int> base = {1,2,3,4,5};
+  auto result1 = std::vector<int>{};
+  auto result2 = std::vector<int>{};
+
+  auto halfPipe = tee(filter(Filter())) >>= demux(transform(Transform()));
+  auto halfPipe2 = halfPipe( result1);
+  auto fullPipe = halfPipe2( result2);
+
+  base >>= fullPipe;
+
+  const auto expected1 = Filter().each(base);
+  const auto expected2 = Transform().each(base);
+  EXPECT_EQ(result1, expected1);
+  EXPECT_EQ(result2, expected2);
+}