diff --git a/src/common/configrules.hpp b/src/common/configrules.hpp
index 894d7b517..1b23b1875 100644
--- a/src/common/configrules.hpp
+++ b/src/common/configrules.hpp
@@ -58,21 +58,23 @@
 #include "proc/asset/procpatt.hpp"
 #include "proc/asset/pipe.hpp"
 #include "proc/asset/track.hpp"
+#include "proc/asset/timeline.hpp"
+#include "proc/asset/sequence.hpp"
 
 #include <string>
 
 
 
-namespace lumiera
-  {
+namespace lumiera {
+  
   using std::string;
   using lumiera::P;
 
   
   
     
-  namespace query
-    {
+  namespace query {
+    
     // The intention is to support the following style of Prolog code
     //
     //  resolve(O, Cap) :- find(O), capabilities(Cap).
@@ -216,6 +218,8 @@ namespace lumiera
                                    , asset::Track
                                    , asset::Pipe
                                    , const asset::ProcPatt
+                                   , asset::Timeline
+                                   , asset::Sequence
                                    > ::List
                                      InterfaceTypes;
   
diff --git a/src/proc/asset/sequence.cpp b/src/proc/asset/sequence.cpp
index 9b6cd8d9f..77fc8e793 100644
--- a/src/proc/asset/sequence.cpp
+++ b/src/proc/asset/sequence.cpp
@@ -21,7 +21,7 @@
 * *****************************************************/
 
 
-#include "asset/sequence.hpp"
+#include "proc/asset/sequence.hpp"
 //#include "proc/mobject/session/track.hpp"
 //#include "proc/mobject/placement.hpp"
 //#include "proc/mobject/session/mobjectfactory.hpp"
diff --git a/src/proc/asset/struct.cpp b/src/proc/asset/struct.cpp
index 6e4153d65..32c70313b 100644
--- a/src/proc/asset/struct.cpp
+++ b/src/proc/asset/struct.cpp
@@ -144,6 +144,8 @@ namespace asset {
 #include "proc/asset/procpatt.hpp"
 #include "proc/asset/track.hpp"
 #include "proc/asset/pipe.hpp"
+#include "proc/asset/timeline.hpp"
+#include "proc/asset/sequence.hpp"
 
 
 namespace asset {
@@ -151,6 +153,8 @@ namespace asset {
   template P<Pipe>     StructFactory::operator() (const Query<Pipe>& query);
   template P<Track>    StructFactory::operator() (const Query<Track>& query);
   template PProcPatt   StructFactory::operator() (const Query<const ProcPatt>& query);
+  template PTimeline   StructFactory::operator() (const Query<Timeline>& query);
+  template PSequence   StructFactory::operator() (const Query<Sequence>& query);
   
   
 } // namespace asset
diff --git a/src/proc/assetmanager.cpp b/src/proc/assetmanager.cpp
index 625c189c1..90489674d 100644
--- a/src/proc/assetmanager.cpp
+++ b/src/proc/assetmanager.cpp
@@ -238,10 +238,11 @@ namespace asset {
 #include "proc/asset/pipe.hpp"  
 #include "proc/asset/meta.hpp"  
 #include "proc/asset/procpatt.hpp"  
+#include "proc/asset/timeline.hpp"  
+#include "proc/asset/sequence.hpp"  
 
 
-namespace asset
-  {
+namespace asset {
   
   template ID<Asset> AssetManager::reg (Asset* obj, const Asset::Ident& idi);
   
@@ -258,6 +259,8 @@ namespace asset
   template P<Track>    AssetManager::wrap (const Track& asset);
   template P<Pipe>     AssetManager::wrap (const Pipe&  asset);
   template P<ProcPatt> AssetManager::wrap (const ProcPatt& asset);
-
+  template P<Timeline> AssetManager::wrap (const Timeline& asset);
+  template P<Sequence> AssetManager::wrap (const Sequence& asset);
+  
   
 } // namespace asset
diff --git a/src/proc/mobject/session/defsmanager.cpp b/src/proc/mobject/session/defsmanager.cpp
index 38509c981..a5bfe1dfc 100644
--- a/src/proc/mobject/session/defsmanager.cpp
+++ b/src/proc/mobject/session/defsmanager.cpp
@@ -36,100 +36,101 @@ using lumiera::query::LUMIERA_ERROR_CAPABILITY_QUERY;
 
 
 namespace mobject {
-  namespace session {
+namespace session {
   
-    using lumiera::P;
-    
-    
-    
-    /** initialise the most basic internal defaults. */
-    DefsManager::DefsManager ()  throw()
-      : defsRegistry(new DefsRegistry)
-    {
-      TODO ("setup basic defaults of the session");
-    }
-    
-    
-    
-    /** @internal causes boost::checked_delete from \c scoped_ptr<DefsRegistry>
-     *  to be placed here, where the declaration of DefsRegistry is available.*/
-    DefsManager::~DefsManager() {}
-    
-    
-    
-    template<class TAR>
-    P<TAR>
-    DefsManager::search  (const Query<TAR>& capabilities)
-    {
-      P<TAR> res;
-      QueryHandler<TAR>& typeHandler = ConfigRules::instance();  
-      for (DefsRegistry::Iter<TAR> i = defsRegistry->candidates(capabilities); 
-           res = *i ; ++i )
-        {
-          typeHandler.resolve (res, capabilities);
-          if (res)
-            return res;
-        }
-      return res; // "no solution found"
-    }
-    
-    
-    template<class TAR>
-    P<TAR> 
-    DefsManager::create  (const Query<TAR>& capabilities)
-    {
-      P<TAR> res;
-      QueryHandler<TAR>& typeHandler = ConfigRules::instance();  
-      typeHandler.resolve (res, capabilities);
-      if (res)
-        defsRegistry->put (res, capabilities);
+  using lumiera::P;
+  
+  
+  
+  /** initialise the most basic internal defaults. */
+  DefsManager::DefsManager ()  throw()
+    : defsRegistry(new DefsRegistry)
+  {
+    TODO ("setup basic defaults of the session");
+  }
+  
+  
+  
+  /** @internal causes boost::checked_delete from \c scoped_ptr<DefsRegistry>
+   *  to be placed here, where the declaration of DefsRegistry is available.*/
+  DefsManager::~DefsManager() {}
+  
+  
+  
+  template<class TAR>
+  P<TAR>
+  DefsManager::search  (const Query<TAR>& capabilities)
+  {
+    P<TAR> res;
+    QueryHandler<TAR>& typeHandler = ConfigRules::instance();
+    for (DefsRegistry::Iter<TAR> i = defsRegistry->candidates(capabilities);
+         res = *i ; ++i )
+      {
+        typeHandler.resolve (res, capabilities);
+        if (res)
+          return res;
+      }
+    return res; // "no solution found"
+  }
+  
+  
+  template<class TAR>
+  P<TAR> 
+  DefsManager::create  (const Query<TAR>& capabilities)
+  {
+    P<TAR> res;
+    QueryHandler<TAR>& typeHandler = ConfigRules::instance();
+    typeHandler.resolve (res, capabilities);
+    if (res)
+      defsRegistry->put (res, capabilities);
+    return res;
+  }
+  
+  
+  template<class TAR>
+  bool 
+  DefsManager::define  (const P<TAR>& defaultObj, const Query<TAR>& capabilities)
+  {
+    P<TAR> candidate (defaultObj);
+    QueryHandler<TAR>& typeHandler = ConfigRules::instance();  
+    typeHandler.resolve (candidate, capabilities);
+    if (!candidate)
+      return false;
+    else
+      return defsRegistry->put (candidate, capabilities);
+  }
+  
+  
+  template<class TAR>
+  bool 
+  DefsManager::forget  (const P<TAR>& defaultObj)
+  {
+    return defsRegistry->forget (defaultObj);
+  }
+  
+  
+  template<class TAR>
+  P<TAR>
+  DefsManager::operator() (const Query<TAR>& capabilities)
+  {
+    P<TAR> res (search (capabilities));
+    if (res) 
       return res;
-    }
+    else
+      res = create (capabilities); // not yet known as default, create new
     
-    
-    template<class TAR>
-    bool 
-    DefsManager::define  (const P<TAR>& defaultObj, const Query<TAR>& capabilities)
-    {
-      P<TAR> candidate (defaultObj);
-      QueryHandler<TAR>& typeHandler = ConfigRules::instance();  
-      typeHandler.resolve (candidate, capabilities);
-      if (!candidate)
-        return false;
-      else
-        return defsRegistry->put (candidate, capabilities);
-    }
-    
-    
-    template<class TAR>
-    bool 
-    DefsManager::forget  (const P<TAR>& defaultObj)
-    {
-      return defsRegistry->forget (defaultObj);
-    }
+    if (!res)
+      throw lumiera::error::Config ( str(format("The following Query could not be resolved: %s.")
+                                               % capabilities.asKey())
+                                   , LUMIERA_ERROR_CAPABILITY_QUERY );
+    else
+      return res;
+  }
+  
+}} // namespace mobject::session
 
-    
-    template<class TAR>
-    P<TAR> 
-    DefsManager::operator() (const Query<TAR>& capabilities)
-    {
-      P<TAR> res (search (capabilities));
-      if (res) 
-        return res;
-      else
-        res = create (capabilities); // not yet known as default, create new
-      
-      if (!res)
-        throw lumiera::error::Config ( str(format("The following Query could not be resolved: %s.") 
-                                                 % capabilities.asKey())
-                                     , LUMIERA_ERROR_CAPABILITY_QUERY );
-      else
-        return res;
-    }
 
-  } // namespace mobject::session
 
-} // namespace mobject
 
 
 
@@ -140,32 +141,37 @@ namespace mobject {
 #include "proc/asset/procpatt.hpp"
 #include "proc/asset/pipe.hpp"
 #include "proc/asset/track.hpp"
+#include "proc/asset/timeline.hpp"
+#include "proc/asset/sequence.hpp"
 #include "proc/mobject/session/track.hpp"
 
 namespace mobject {
-  namespace session {
-    
-    
-    using asset::Pipe;
-    using asset::PPipe;
-    using asset::ProcPatt;
-    using asset::PProcPatt;
-    
-    using mobject::session::Track;
-    using mobject::session::TrackAsset;
-    using mobject::session::PTrack;
-    using mobject::session::PTrackAsset;
-    
-    template PPipe       DefsManager::operator() (const Query<Pipe>&); 
-    template PProcPatt   DefsManager::operator() (const Query<const ProcPatt>&); 
-    template PTrack      DefsManager::operator() (const Query<Track>&); 
-    template PTrackAsset DefsManager::operator() (const Query<TrackAsset>&); 
-    
-    template bool DefsManager::define (const PPipe&, const Query<Pipe>&);
-    template bool DefsManager::forget (const PPipe&);
-    
-    
-  } // namespace mobject::session
-
-} // namespace mobject
-
+namespace session {
+  
+  
+  using asset::Pipe;
+  using asset::PPipe;
+  using asset::ProcPatt;
+  using asset::PProcPatt;
+  using asset::Timeline;
+  using asset::PTimeline;
+  using asset::Sequence;
+  using asset::PSequence;
+  
+  using mobject::session::Track;
+  using mobject::session::TrackAsset;
+  using mobject::session::PTrack;
+  using mobject::session::PTrackAsset;
+  
+  template PPipe       DefsManager::operator() (const Query<Pipe>&);
+  template PProcPatt   DefsManager::operator() (const Query<const ProcPatt>&);
+  template PTrack      DefsManager::operator() (const Query<Track>&);
+  template PTrackAsset DefsManager::operator() (const Query<TrackAsset>&);
+  template PTimeline   DefsManager::operator() (const Query<Timeline>&);
+  template PSequence   DefsManager::operator() (const Query<Sequence>&);
+  
+  template bool DefsManager::define (const PPipe&, const Query<Pipe>&);
+  template bool DefsManager::forget (const PPipe&);
+  
+  
+}} // namespace mobject::session