diff --git a/display-server-tty/Cargo.toml b/display-server-tty/Cargo.toml
index 4d933da..3c5d783 100644
--- a/display-server-tty/Cargo.toml
+++ b/display-server-tty/Cargo.toml
@@ -1,11 +1,12 @@
 [package]
 authors = ["Michael Sippel <micha@fragmental.art>"]
-name = "display_server"
+name = "display-server-tty"
 version = "0.1.0"
 edition = "2018"
 
 [dependencies]
-nested = { path = "../../nested" }
+nested = { path = "../lib-nested-core" }
+nested-tty  = { path = "../lib-nested-tty" }
 termion = "1.5.5"
 cgmath = { version = "0.18.0", features = ["serde"] }
 serde = { version = "1.0", features = ["serde_derive"] }
diff --git a/examples/tty-02-node/Cargo.toml b/examples/tty-02-node/Cargo.toml
index 589ee96..ccfc655 100644
--- a/examples/tty-02-node/Cargo.toml
+++ b/examples/tty-02-node/Cargo.toml
@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+laddertypes = { path = "../../../lib-laddertypes" }
 r3vi = { path = "../../../lib-r3vi" }
 nested = { path = "../../lib-nested-core" }
 nested-tty = { path = "../../lib-nested-tty" }
diff --git a/examples/tty-02-node/src/main.rs b/examples/tty-02-node/src/main.rs
index d041723..1bafa37 100644
--- a/examples/tty-02-node/src/main.rs
+++ b/examples/tty-02-node/src/main.rs
@@ -9,11 +9,12 @@ use {
     nested::{
         editors::ObjCommander,
         repr_tree::{Context, ReprTree},
-        edit_tree::{NestedNode}
+        edit_tree::{EditTree}
     },
     nested_tty::{
         DisplaySegment, TTYApplication,
         TerminalCompositor, TerminalStyle, TerminalView,
+        TerminalAtom
     },
     r3vi::{
         buffer::{singleton::*, vec::*},
@@ -21,112 +22,101 @@ use {
     std::sync::{Arc, RwLock},
 };
 
-/*
-struct ParseDigit { radix: u32 }
-impl Morphism for ParseDigit {
-    fn new(
-        ctx: &Arc<RwLock<Context>>
-    ) -> Self {
-        
-    }
-
-    fn setup_projection(&self, repr_tree: Arc<RwLock<ReprTree>>) {
-        if let Some( char_view ) = repr_tree.get_out(Context::parse(&ctx, "Char~")) {
-            
-        }
-    }
-}
-
-get_morphism( ) -> Morphism {
-    
-}
-*/
 #[async_std::main]
 async fn main() {
     /* setup context & create Editor-Tree
      */
     let ctx = Arc::new(RwLock::new(Context::new()));
 
-    /* Create a Char-Node with editor & view
-     */
+    nested::editors::char::init_ctx( ctx.clone() );
+    nested::editors::integer::editor::init_ctx( ctx.clone() );
+    nested::editors::list::init_ctx( ctx.clone() );
 
-    let mut char_obj = ReprTree::make_leaf(
-        Context::parse(&ctx, "Char"),
-        SingletonBuffer::new('X').get_port().into()
-    );
-/*
-    char_obj.insert_branch(
-        Context::parse(&ctx, "EditTree"),
-        SingletonBuffer::new(
-            NestedNode::new()
+    let char_type = Context::parse(&ctx, "Char");
+    let digit_type = Context::parse(&ctx, "<Digit Radix>");
+    let list_type = Context::parse(&ctx, "<List Item>");
+    let posint_type = Context::parse(&ctx, "<PosInt Radix>");
+    let item_tyid = ctx.read().unwrap().get_var_typeid("Item").unwrap();
+
+    ctx.write().unwrap().meta_chars.push(',');
+    ctx.write().unwrap().meta_chars.push('\"');
+    ctx.write().unwrap().set_edittree_hook(
+        Arc::new(
+            move |et: Arc<RwLock<EditTree>>, t: laddertypes::TypeTerm| {
+                if let Ok(σ) = laddertypes::unify(&t, &char_type.clone()) {
+                    let mut et = et.write().unwrap();
+                    *et = nested_tty::editors::edittree_make_char_view(et.clone());
+                }
+                else if let Ok(σ) = laddertypes::unify(&t, &digit_type) {
+                    let mut et = et.write().unwrap();
+                    *et = nested_tty::editors::edittree_make_digit_view(et.clone());
+                }
+                else if let Ok(σ) = laddertypes::unify(&t, &posint_type) {
+                    let mut et = et.write().unwrap();
+                    nested_tty::editors::list::PTYListStyle::for_node( &mut *et, ("0d", "", ""));
+                    nested_tty::editors::list::PTYListController::for_node( &mut *et, None, None );
+                }
+                else if let Ok(σ) = laddertypes::unify(&t, &list_type) {
+                    let mut et = et.write().unwrap();
+                    let item_type = σ.get( &laddertypes::TypeID::Var(item_tyid) ).unwrap();
+                    if item_type == &char_type {
+                        nested_tty::editors::list::PTYListStyle::for_node( &mut *et, ("\"", "", "\""));
+                        nested_tty::editors::list::PTYListController::for_node( &mut *et, None, Some('\"') );
+                    } else {
+                        nested_tty::editors::list::PTYListStyle::for_node( &mut *et, ("{", ", ", "}"));
+                        nested_tty::editors::list::PTYListController::for_node( &mut *et, Some(','), Some('}') );
+                    }
+                    //*et = nested_tty::editors::edittree_make_list_edit(et.clone());
+                }
+            }
         )
     );
 
-    let mut vec_obj = ReprTree::make_leaf(
-        Context::parse(&ctx, "<Vec Char>"),
-        VecBuffer::new(vec!['a', 'b', 'c']).get_port().into()
-    );
-
-    let mut char_edit = Context::new_edit_tree(
-        &ctx,
-        // node type
-        Context::parse(&ctx, "Char"),
-        // depth
-        SingletonBuffer::new(0).get_port(),
-    )
-    .unwrap();
-*/
-    // add a display view to the node
-    //node1 = nested_tty::editors::node_make_tty_view(node1);
-
-    /* Create a <List Char>-Node with editor & view
+    /* structure of Repr-Tree
+     *
+     *   === Repr-Tree ===
+     *
+     *        <Digit 10>
+     *         /   |     \
+     *        /    |        \
+     *       /     |          \
+     *     u32  [ EditTree ]  Char
+     *           - Editor         \
+     *           - Display      [ EditTree ]
+     *         /     |    \      - Editor
+     *        /      |     \     - Display
+     *      TTY  PixelBuf  SDF  /    |     \
+     *                         /     |      \
+     *                       TTY  PixelBuf  SDF
      */
+   let rt_digit = ReprTree::new_arc( Context::parse(&ctx, "<Digit 16>") );
 
-/*
-    let mut node2 = Context::make_node(
-        &ctx,
-        // node type
-        Context::parse(&ctx, "<List Char>"),
-        // depth
-        SingletonBuffer::new(0).get_port(),
-    )
-    .unwrap();
-*/
-    // add a display view to the node
-    //node2 = nested_tty::editors::node_make_tty_view(node2);
-
-    /* Create a <List Char>-Node with editor & view
+    /* add initial representation
+     *  <Digit 16> ~ Char
      */
-/*
-    let mut node3 = Context::make_node(
-        &ctx,
-        // node type
-        Context::parse(&ctx, "<List <List Char>>"),
-        // depth
-        SingletonBuffer::new(0).get_port(),
-    )
-    .unwrap();
-*/
-    // add a display view to the node
-    //node3 = nested_tty::editors::node_make_tty_view(node3);
- 
+    rt_digit.write().unwrap()
+        .insert_leaf(
+            vec![ Context::parse(&ctx, "Char") ].into_iter(),
+            SingletonBuffer::new('x').get_port().into()
+        );
+
+    /* setup TTY-Display for DigitEditor
+     */
+    let edittree_digit = ctx.read().unwrap().setup_edittree(rt_digit.clone(), r3vi::buffer::singleton::SingletonBuffer::new(0).get_port());
+
+    //---
+    let rt_string = ReprTree::new_arc( Context::parse(&ctx, "<List <List Char>>") );
+    let edittree = ctx.read().unwrap().setup_edittree(rt_string.clone(), r3vi::buffer::singleton::SingletonBuffer::new(0).get_port());
+
     /* setup terminal
      */
     let app = TTYApplication::new({
         /* event handler
          */
-
         let ctx = ctx.clone();
- //       let node1 = node1.clone();
-//        let node2 = node2.clone();
-//        let node3 = node3.clone();
+        let et1 = edittree.clone();
         move |ev| {
-//            let mut node1 = node1.clone();
-//            let mut node2 = node2.clone();
-//            let mut node3 = node3.clone();
-//            node1.send_cmd_obj(ev.to_repr_tree(&ctx));
-//            node2.send_cmd_obj(ev.to_repr_tree(&ctx));
-//            node3.send_cmd_obj(ev.to_repr_tree(&ctx));
+            et1.write().unwrap().send_cmd_obj(ev.to_repr_tree(&ctx));
         }
     });
 
@@ -142,42 +132,22 @@ async fn main() {
             })
             .offset(Vector2::new(5, 0)),
     );
+    compositor.write().unwrap().push( edittree_digit.read().unwrap().display_view().offset(Vector2::new(0,2)) );
 
-/*    let label = ctx.read().unwrap().type_term_to_str(&node1.get_type());
+    let label = ctx.read().unwrap().type_term_to_str(&rt_digit.read().unwrap().get_type());
     compositor
         .write()
         .unwrap()
-        .push(nested_tty::make_label(&label).offset(Vector2::new(0, 2)));
+        .push(nested_tty::make_label(&label).offset(Vector2::new(0, 1)));
 
+    compositor.write().unwrap().push( edittree.read().unwrap().display_view().offset(Vector2::new(0,4)) );
+
+    let label = ctx.read().unwrap().type_term_to_str(&rt_string.read().unwrap().get_type());
     compositor
         .write()
         .unwrap()
-        .push(node1.display_view().offset(Vector2::new(15, 2)));
-*/
-    /*
-    let label2 = ctx.read().unwrap().type_term_to_str(&node2.get_type());
-    compositor
-        .write()
-        .unwrap()
-        .push(nested_tty::make_label(&label2).offset(Vector2::new(0, 3)));
+        .push(nested_tty::make_label(&label).offset(Vector2::new(0, 3)));
 
-    compositor
-        .write()
-        .unwrap()
-        .push(node2.display_view().offset(Vector2::new(15, 3)));
-
-
-    let label3 = ctx.read().unwrap().type_term_to_str(&node3.get_type());
-    compositor
-        .write()
-        .unwrap()
-        .push(nested_tty::make_label(&label3).offset(Vector2::new(0, 4)));
-
-    compositor
-        .write()
-        .unwrap()
-        .push(node3.display_view().offset(Vector2::new(25, 4)));
-*/
     /* write the changes in the view of `term_port` to the terminal
      */
     app.show().await.expect("output error!");
diff --git a/lib-nested-core/src/edit_tree/mod.rs b/lib-nested-core/src/edit_tree/mod.rs
index 81251d0..92e0411 100644
--- a/lib-nested-core/src/edit_tree/mod.rs
+++ b/lib-nested-core/src/edit_tree/mod.rs
@@ -10,6 +10,6 @@ pub use {
     cursor::TreeCursor,
     nav::{TreeNav, TreeNavResult, TreeHeightOp},
     treetype::{TreeType},
-    node::NestedNode
+    node::EditTree
 };
 
diff --git a/lib-nested-core/src/edit_tree/node.rs b/lib-nested-core/src/edit_tree/node.rs
index 7acfa82..0be85f7 100644
--- a/lib-nested-core/src/edit_tree/node.rs
+++ b/lib-nested-core/src/edit_tree/node.rs
@@ -14,7 +14,7 @@ use {
 };
 
 #[derive(Clone)]
-pub struct NestedNodeDisplay {
+pub struct EdittreeDisplay {
     /// display view
     pub view: Arc<RwLock<ReprTree>>,
 
@@ -26,13 +26,13 @@ pub struct NestedNodeDisplay {
 }
 
 #[derive(Clone)]
-pub struct NestedNodeEdit {
+pub struct EdittreeControl {
     /// abstract editor
     pub editor: SingletonBuffer<
                     Option< Arc<dyn Any + Send + Sync> >
                 >,
 
-    pub spillbuf: Arc<RwLock< Vec< Arc<RwLock< NestedNode >> > >>,
+    pub spillbuf: Arc<RwLock< Vec< Arc<RwLock< EditTree >> > >>,
 
     /// commander & navigation
     pub cmd: SingletonBuffer<
@@ -51,48 +51,48 @@ pub struct NestedNodeEdit {
  * TODO: rename to EditNode
  */
 #[derive(Clone)]
-pub struct NestedNode {
+pub struct EditTree {
     /// context
     pub ctx: Arc<RwLock<Context>>,
 
     /// viewports for terminal display
-    pub disp: NestedNodeDisplay,
+    pub disp: EdittreeDisplay,
 
     /// editor & commander objects
-    pub edit: NestedNodeEdit
+    pub ctrl: EdittreeControl
 }
 
-impl NestedNode {
+impl EditTree {
     pub fn new(ctx: Arc<RwLock<Context>>, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> Self {
-        NestedNode {
-            disp: NestedNodeDisplay {
+        EditTree {
+            disp: EdittreeDisplay {
                 view: ReprTree::new_arc(Context::parse(&ctx, "Display")),
                 diag: None,
                 depth,
             },
-            edit: NestedNodeEdit {
+            ctrl: EdittreeControl {
                 editor: SingletonBuffer::new(None),
                 spillbuf: Arc::new(RwLock::new(Vec::new())),
                 cmd: SingletonBuffer::new(None),
-                close_char: SingletonBuffer::new(None),            
+                close_char: SingletonBuffer::new(None),
                 tree_nav: SingletonBuffer::new(None),
             },
             ctx
         }
     }
-   
+
     pub fn set_editor(mut self, editor: Arc<dyn Any + Send + Sync>) -> Self {
-        self.edit.editor.set(Some(editor));
+        self.ctrl.editor.set(Some(editor));
         self
     }
 
     pub fn set_cmd(mut self, cmd: Arc<RwLock<dyn ObjCommander + Send + Sync>>) -> Self {
-        self.edit.cmd.set(Some(cmd));
+        self.ctrl.cmd.set(Some(cmd));
         self
     }
 
     pub fn set_nav(mut self, nav: Arc<RwLock<dyn TreeNav + Send + Sync>>) -> Self {
-        self.edit.tree_nav.set(Some(nav));
+        self.ctrl.tree_nav.set(Some(nav));
         self
     }
 
@@ -108,7 +108,7 @@ impl NestedNode {
     }
 
     pub fn get_edit<T: Send + Sync + 'static>(&self) -> Option<Arc<RwLock<T>>> {
-        if let Some(edit) = self.edit.editor.get() {
+        if let Some(edit) = self.ctrl.editor.get() {
             if let Ok(edit) = edit.downcast::<RwLock<T>>() {
                 Some(edit)
             } else {
@@ -132,9 +132,9 @@ impl TreeType for NestedNode {
 }
 */
 
-impl TreeNav for NestedNode {
+impl TreeNav for EditTree {
     fn get_cursor(&self) -> TreeCursor {
-        if let Some(tn) = self.edit.tree_nav.get() {
+        if let Some(tn) = self.ctrl.tree_nav.get() {
             tn.read().unwrap().get_cursor()
         } else {
             TreeCursor::default()
@@ -142,7 +142,7 @@ impl TreeNav for NestedNode {
     }
 
     fn get_addr_view(&self) -> OuterViewPort<dyn SequenceView<Item = isize>> {
-        if let Some(tn) = self.edit.tree_nav.get() {
+        if let Some(tn) = self.ctrl.tree_nav.get() {
             tn.read().unwrap().get_addr_view()
         } else {
             OuterViewPort::default()
@@ -150,7 +150,7 @@ impl TreeNav for NestedNode {
     }
 
     fn get_mode_view(&self) -> OuterViewPort<dyn SingletonView<Item = ListCursorMode>> {
-        if let Some(tn) = self.edit.tree_nav.get() {
+        if let Some(tn) = self.ctrl.tree_nav.get() {
             tn.read().unwrap().get_mode_view()
         } else {
             OuterViewPort::default()
@@ -158,7 +158,7 @@ impl TreeNav for NestedNode {
     }
 
     fn get_cursor_warp(&self) -> TreeCursor {
-        if let Some(tn) = self.edit.tree_nav.get() {
+        if let Some(tn) = self.ctrl.tree_nav.get() {
             tn.read().unwrap().get_cursor_warp()
         } else {
             TreeCursor::default()
@@ -166,7 +166,7 @@ impl TreeNav for NestedNode {
     }
 
     fn get_height(&self, op: &TreeHeightOp) -> usize {
-        if let Some(tn) = self.edit.tree_nav.get() {
+        if let Some(tn) = self.ctrl.tree_nav.get() {
             tn.read().unwrap().get_height( op )
         } else {
             0
@@ -174,7 +174,7 @@ impl TreeNav for NestedNode {
     }
 
     fn goby(&mut self, direction: Vector2<isize>) -> TreeNavResult {
-        if let Some(tn) = self.edit.tree_nav.get() {
+        if let Some(tn) = self.ctrl.tree_nav.get() {
             tn.write().unwrap().goby(direction)
         } else {
             TreeNavResult::Exit
@@ -182,7 +182,7 @@ impl TreeNav for NestedNode {
     }
 
     fn goto(&mut self, new_cursor: TreeCursor) -> TreeNavResult {
-        if let Some(tn) = self.edit.tree_nav.get() {
+        if let Some(tn) = self.ctrl.tree_nav.get() {
             tn.write().unwrap().goto(new_cursor)
         } else {
             TreeNavResult::Exit
@@ -192,7 +192,7 @@ impl TreeNav for NestedNode {
 
 use crate::edit_tree::nav::TreeNavCmd;
 
-impl ObjCommander for NestedNode {
+impl ObjCommander for EditTree {
     fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult {
 
         if cmd_obj.read().unwrap().get_type() == &Context::parse(&self.ctx, "TreeNavCmd") {
@@ -211,7 +211,7 @@ impl ObjCommander for NestedNode {
             } else {
                 TreeNavResult::Exit
             }
-        } else if let Some(cmd) = self.edit.cmd.get() {
+        } else if let Some(cmd) = self.ctrl.cmd.get() {
             // todo: filter out tree-nav cmds and send them to tree_nav
             cmd.write().unwrap().send_cmd_obj(cmd_obj)
         } else {
@@ -221,7 +221,7 @@ impl ObjCommander for NestedNode {
 }
 
 
-impl Diagnostics for NestedNode {
+impl Diagnostics for EditTree {
     fn get_msg_port(&self) -> OuterViewPort<dyn SequenceView<Item = Message>> {
         self.get_diag()
     }
diff --git a/lib-nested-core/src/editors/char/mod.rs b/lib-nested-core/src/editors/char/mod.rs
index 40ea021..3b3c1ff 100644
--- a/lib-nested-core/src/editors/char/mod.rs
+++ b/lib-nested-core/src/editors/char/mod.rs
@@ -9,21 +9,45 @@ use {
     laddertypes::{TypeTerm},
     crate::{
         repr_tree::{Context, ReprTree},
-        edit_tree::{NestedNode, TreeNavResult},
+        edit_tree::{EditTree, TreeNavResult},
         editors::ObjCommander,
     },
     std::sync::Arc,
     std::sync::RwLock
 };
 
-pub fn init_ctx( ctx: &mut Context ) {
-    /*
-    ctx.add_node_ctor(
-        "Char",
-        Arc::new(|ctx: Arc<RwLock<Context>>, _ty: TypeTerm, depth: OuterViewPort<dyn SingletonView<Item = usize>>| {
-            Some(CharEditor::new_node(ctx, depth))
-        }));
-    */
+pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
+    
+    let morphtype =
+            crate::repr_tree::MorphismType {
+                src_type: Context::parse(&ctx, "Char"),
+                dst_type: Context::parse(&ctx, "Char~EditTree")
+            };
+
+    ctx.write().unwrap()
+        .morphisms
+        .add_morphism(
+            morphtype,
+            {
+                let ctx = ctx.clone();
+                move |rt, σ| {
+                    /* Create EditTree object
+                     */
+                    let mut edittree_char = CharEditor::new_edit_tree(
+                        ctx.clone(),
+                        r3vi::buffer::singleton::SingletonBuffer::<usize>::new(0).get_port()
+                    );
+
+                    /* Insert EditTree into ReprTree
+                     */
+                    let mut rt = rt.write().unwrap();
+                    rt.insert_leaf(
+                        vec![ Context::parse(&ctx, "EditTree") ].into_iter(),
+                        SingletonBuffer::new( Arc::new(RwLock::new( edittree_char )) ).get_port().into()
+                    );
+                }
+            }
+        );
 }
 
 pub struct CharEditor {
@@ -71,19 +95,16 @@ impl CharEditor {
         self.get_port().get_view().unwrap().get()
     }
 
-    pub fn new_node(ctx0: Arc<RwLock<Context>>, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> NestedNode {
+    pub fn new_edit_tree(
+        ctx0: Arc<RwLock<Context>>,
+        depth: OuterViewPort<dyn SingletonView<Item = usize>>
+    ) -> EditTree {
         let data = SingletonBuffer::new('\0');
         let ctx = ctx0.clone();
         let editor = Arc::new(RwLock::new(CharEditor{ ctx, data: data.clone() }));
 
-        NestedNode::new(
+        EditTree::new(
             ctx0.clone(),
-            /*
-            ReprTree::new_leaf(
-                ctx0.read().unwrap().type_term_from_str("Char").unwrap(),
-                data.get_port().into()
-            ),
-            */
             depth
         )
             .set_cmd( editor.clone() )
diff --git a/lib-nested-core/src/editors/integer/editor.rs b/lib-nested-core/src/editors/integer/editor.rs
index 91d068d..0a911c9 100644
--- a/lib-nested-core/src/editors/integer/editor.rs
+++ b/lib-nested-core/src/editors/integer/editor.rs
@@ -14,7 +14,7 @@ use {
     crate::{
         editors::{list::{ListCmd}, ObjCommander},
         repr_tree::{Context, ReprTree},
-        edit_tree::{NestedNode, TreeNav, TreeNavResult, TreeCursor, diagnostics::{Message}},
+        edit_tree::{EditTree, TreeNav, TreeNavResult, TreeCursor, diagnostics::{Message}},
     },
     std::sync::Arc,
     std::sync::RwLock,
@@ -22,6 +22,51 @@ use {
     cgmath::{Point2}
 };
 
+
+pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
+
+    // todo: proper scoping of Radix variable
+    ctx.write().unwrap().add_varname("Radix");
+    let morphtype =
+            crate::repr_tree::MorphismType {
+                src_type: Context::parse(&ctx, "<Digit Radix>"),
+                dst_type: Context::parse(&ctx, "<Digit Radix>~EditTree")
+            };
+
+    ctx.write().unwrap()
+        .morphisms
+        .add_morphism(
+            morphtype,
+            {
+                let ctx = ctx.clone();
+                move |rt, σ| {
+                    let radix =
+                        match σ.get( &laddertypes::TypeID::Var(ctx.read().unwrap().get_var_typeid("Radix").unwrap()) ) {
+                            Some(TypeTerm::Num(n)) => *n as u32,
+                            _ => 0
+                        };
+
+                    /* Create EditTree object
+                     */
+                    let mut edittree_digit = DigitEditor::new(
+                        ctx.clone(),
+                        radix
+                    ).into_node(
+                        r3vi::buffer::singleton::SingletonBuffer::<usize>::new(0).get_port()
+                    );
+
+                    /* Insert EditTree into ReprTree
+                     */
+                    let mut rt = rt.write().unwrap();
+                    rt.insert_leaf(
+                        vec![ Context::parse(&ctx, "EditTree") ].into_iter(),
+                        SingletonBuffer::new( Arc::new(RwLock::new(edittree_digit)) ).get_port().into()
+                    );
+                }
+            }
+        );
+}
+
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct DigitEditor {
@@ -49,9 +94,7 @@ impl ObjCommander for DigitEditor {
                     /* in case the character c is not in the range of digit-chars,
                        add a message to the diagnostics view
                      */
-
 /*
-
                     let message = IndexBuffer::from_iter(vec![
                         (Point2::new(1, 0), make_label("invalid digit '")),
                         (Point2::new(2, 0), make_label(&format!("{}", c))
@@ -61,7 +104,7 @@ impl ObjCommander for DigitEditor {
 
                     self.msg.push(crate::diagnostics::make_error(message.get_port().flatten()));
 */
-                    
+
                     self.data.set(Some(c));
                 } else {
                     self.data.set(Some(c));
@@ -83,40 +126,39 @@ impl DigitEditor {
         }
     }
 
-    pub fn into_node(self, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> NestedNode {
+    pub fn into_node(self, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> EditTree { 
         let data = self.get_data();        
         let editor = Arc::new(RwLock::new(self));
         let ed = editor.write().unwrap();
         let r = ed.radix;
 
-        NestedNode::new(ed.ctx.clone(), /*data,*/ depth)
+        EditTree::new(ed.ctx.clone(), depth)
+            .set_editor(editor.clone())
             .set_cmd(editor.clone())
-            /*
-            .set_view(
-                ed.data
-                    .get_port()
-                    .map(move |c| {
-                        TerminalAtom::new(
-                            c.unwrap_or('?'),
-                            if c.unwrap_or('?').to_digit(r).is_some() {
-                                TerminalStyle::fg_color((90, 160, 90))
-                            } else {
-                                //TerminalStyle::bg_color((90, 10, 10))
-                                TerminalStyle::fg_color((200, 40, 40))
-                            },
-                        )
-                    })
-                    .to_grid()
-            )
             .set_diag(
                 ed.msg.get_port().to_sequence()
             )
+    }
+
+    pub fn attach_to(&mut self, source: OuterViewPort<dyn SingletonView<Item = u32>>) {
+        /*
+        source.add_observer(
+            Arc::new(NotifyFnObserver::new(|_msg| {
+                self.data.set( source.get() )
+            }))
+        );
         */
     }
 
-    pub fn get_data_port(&self) -> OuterViewPort<dyn SingletonView<Item = Option<u32>>> {
+    pub fn get_data_port(&self) -> OuterViewPort<dyn SingletonView<Item = Result<u32, char>>> {
         let radix = self.radix;
-        self.data.get_port().map(move |c| c?.to_digit(radix))
+        self.data.get_port().map(move |c|
+            if let Some(d) = c.unwrap_or('?').to_digit(radix) {
+                Ok(d)
+            } else {
+                Err(c.unwrap_or('?'))
+            }
+        )
     }
 
     pub fn get_type(&self) -> TypeTerm {
@@ -134,10 +176,9 @@ impl DigitEditor {
     }
 }
 
-
 pub struct PosIntEditor {
     radix: u32,
-    digits: NestedNode,
+    digits: EditTree,
 
     // todo: endianness
 }
@@ -179,7 +220,7 @@ impl PosIntEditor {
 */
         PosIntEditor {
             radix,
-            digits: NestedNode::new(
+            digits: EditTree::new(
                 ctx,
                 r3vi::buffer::singleton::SingletonBuffer::new(0).get_port()
             )
@@ -207,7 +248,7 @@ impl PosIntEditor {
         self.digits.goto(TreeCursor::none());
     }
 
-    pub fn into_node(self) -> NestedNode {
+    pub fn into_node(self) -> EditTree {
         self.digits
     }
 
diff --git a/lib-nested-core/src/editors/list/cmd.rs b/lib-nested-core/src/editors/list/cmd.rs
index a8a09c8..82b5023 100644
--- a/lib-nested-core/src/editors/list/cmd.rs
+++ b/lib-nested-core/src/editors/list/cmd.rs
@@ -5,7 +5,7 @@ use {
     crate::{
         editors::{list::{ListEditor, ListCursor, ListCursorMode}, ObjCommander},
         repr_tree::{Context, ReprTree},
-        edit_tree::{NestedNode, TreeNav, TreeNavResult, TreeCursor},
+        edit_tree::{EditTree, TreeNav, TreeNavResult, TreeCursor},
     },
     std::sync::{Arc, RwLock}
 };
@@ -35,7 +35,7 @@ impl ObjCommander for ListEditor {
     fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult {
         let cmd_repr = cmd_obj.read().unwrap();
 
-        if let Some(view) = cmd_repr.get_view::<dyn SingletonView<Item = NestedNode>>() {
+        if let Some(view) = cmd_repr.get_view::<dyn SingletonView<Item = EditTree>>() {
             let node = view.get();
             let cur = self.cursor.get();
 
diff --git a/lib-nested-core/src/editors/list/ctx.rs b/lib-nested-core/src/editors/list/ctx.rs
index 8cb8c37..0ef2180 100644
--- a/lib-nested-core/src/editors/list/ctx.rs
+++ b/lib-nested-core/src/editors/list/ctx.rs
@@ -1,5 +1,5 @@
 use {
-    r3vi::{view::{OuterViewPort, singleton::*}},
+    r3vi::{view::{OuterViewPort, singleton::*}, buffer::singleton::*},
     laddertypes::{TypeTerm},
     crate::{
         repr_tree::{Context},
@@ -10,33 +10,37 @@ use {
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-pub fn init_ctx(ctx: &mut Context) {
-    ctx.add_typename("ListCmd".into());
-    ctx.add_list_typename("List".into());
-/*
-    ctx.add_node_ctor(
-        "List", Arc::new(
-            |ctx: Arc<RwLock<Context>>, ty: TypeTerm, depth: OuterViewPort<dyn SingletonView<Item = usize>>| {
-                match ty {
-                    TypeTerm::App(args) => {
-                        if args.len() > 1 {
-                            let typ = args[1].clone();
+pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
+    ctx.write().unwrap().add_list_typename("List".into());
+    ctx.write().unwrap().add_varname("Item");
+    let mt = crate::repr_tree::MorphismType {
+        src_type: Context::parse(&ctx, "<List Item>"),
+        dst_type: Context::parse(&ctx, "<List Item>~EditTree")
+    };
+    ctx.write().unwrap().morphisms.add_morphism(
+        mt,
+        {
+            let ctx = ctx.clone();
+            move |rt, σ| {
+                let item_id = laddertypes::TypeID::Var( ctx.read().unwrap().get_var_typeid("Item").unwrap() );
+                if let Some( item_type ) = σ.get( &item_id ) {
+                    let mut edittree_list = ListEditor::new(
+                        ctx.clone(),
+                        item_type.clone()
+                    ).into_node(
+                        r3vi::buffer::singleton::SingletonBuffer::<usize>::new(0).get_port()
+                    );
 
-                            let mut node = ListEditor::new(ctx.clone(), typ).into_node(depth);
-
-//                            PTYListController::for_node( &mut node, Some(','), Some('}') );
-//                            PTYListStyle::for_node( &mut node, ("{",", ","}") );
-
-                            Some(node)
-                        } else {
-                            None
-                        }
-                    }
-                    _ => None
+                    let mut rt = rt.write().unwrap();
+                    rt.insert_leaf(
+                        vec![ Context::parse(&ctx, "EditTree") ].into_iter(),
+                        SingletonBuffer::new( Arc::new(RwLock::new( edittree_list )) ).get_port().into()
+                    );
+                } else {
+                    eprintln!("no item type");
                 }
             }
-        )
+        }
     );
-    */
 }
 
diff --git a/lib-nested-core/src/editors/list/editor.rs b/lib-nested-core/src/editors/list/editor.rs
index 5a971b4..f0e7cb7 100644
--- a/lib-nested-core/src/editors/list/editor.rs
+++ b/lib-nested-core/src/editors/list/editor.rs
@@ -6,7 +6,7 @@ use {
     laddertypes::{TypeTerm},
     crate::{
         repr_tree::{Context, ReprTree},
-        edit_tree::{NestedNode, TreeNav, TreeCursor, diagnostics::Diagnostics},
+        edit_tree::{EditTree, TreeNav, TreeCursor, diagnostics::Diagnostics},
         editors::{list::{ListCursor, ListCursorMode, ListCmd}, ObjCommander},
     },
     std::sync::{Arc, RwLock}
@@ -18,9 +18,9 @@ pub struct ListEditor {
     pub cursor: SingletonBuffer<ListCursor>,
 
     // todo: (?) remove RwLock<..> around NestedNode ??
-    pub data: VecBuffer< Arc<RwLock<NestedNode>> >,
+    pub data: VecBuffer< Arc<RwLock<EditTree>> >,
 
-    pub spillbuf: Arc<RwLock<Vec<Arc<RwLock<NestedNode>>>>>,
+    pub spillbuf: Arc<RwLock<Vec<Arc<RwLock<EditTree>>>>>,
 
     pub(super) addr_port: OuterViewPort<dyn SequenceView<Item = isize>>,
     pub(super) mode_port: OuterViewPort<dyn SingletonView<Item = ListCursorMode>>,
@@ -39,7 +39,7 @@ impl ListEditor {
         typ: TypeTerm,
     ) -> Self {
         let cursor = SingletonBuffer::new(ListCursor::default());
-        let data : VecBuffer<Arc<RwLock<NestedNode>>> = VecBuffer::new();
+        let data : VecBuffer<Arc<RwLock<EditTree>>> = VecBuffer::new();
 
         ListEditor {
             mode_port: cursor
@@ -100,7 +100,7 @@ impl ListEditor {
         }
     }
 
-    pub fn into_node(mut self, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> NestedNode {
+    pub fn into_node(mut self, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> EditTree {
         let data = self.get_data();
         let ctx = self.ctx.clone();
 
@@ -109,7 +109,7 @@ impl ListEditor {
 
         let e = editor.read().unwrap();
 
-        let mut node = NestedNode::new(ctx, depth)
+        let mut node = EditTree::new(ctx, depth)
             .set_editor(editor.clone())
             .set_nav(editor.clone())
             .set_cmd(editor.clone())
@@ -131,7 +131,7 @@ impl ListEditor {
                       .flatten()
             );
 
-        node.edit.spillbuf = e.spillbuf.clone();
+        node.ctrl.spillbuf = e.spillbuf.clone();
         node
     }
 
@@ -150,7 +150,7 @@ impl ListEditor {
         self.cursor.get_port()
     }
 
-    pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = NestedNode>> {
+    pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = EditTree>> {
         self.data.get_port().to_sequence().map(
             |x| x.read().unwrap().clone()
         )
@@ -164,7 +164,7 @@ impl ListEditor {
         )
     }
 
-    pub fn get_item(&self) -> Option<NestedNode> {
+    pub fn get_item(&self) -> Option<EditTree> {
         if let Some(idx) = self.cursor.get().idx {
             let idx = crate::utils::modulo(idx as isize, self.data.len() as isize) as usize;
             if idx < self.data.len() {
@@ -175,9 +175,9 @@ impl ListEditor {
         } else {
             None
         }
-    }
+   }
 
-    pub fn get_item_mut(&mut self) -> Option<MutableVecAccess<Arc<RwLock<NestedNode>>>> {
+    pub fn get_item_mut(&mut self) -> Option<MutableVecAccess<Arc<RwLock<EditTree>>>> {
         if let Some(idx) = self.cursor.get().idx {
             let idx = crate::utils::modulo(idx as isize, self.data.len() as isize) as usize;
             if idx < self.data.len() {
@@ -228,7 +228,7 @@ impl ListEditor {
     }
 
     /// insert a new element
-    pub fn insert(&mut self, item: Arc<RwLock<NestedNode>>) {
+    pub fn insert(&mut self, item: Arc<RwLock<EditTree>>) {
         item.read().unwrap().disp.depth.0.set_view(
             self.depth.map(|d| d+1).get_view()
         );
@@ -306,9 +306,15 @@ impl ListEditor {
                 self.set_leaf_mode(ListCursorMode::Insert);
                 self.nexd();
 
-                let mut b = item.edit.spillbuf.write().unwrap();
-/* TODO
-                let mut tail_node = Context::make_node(&self.ctx, self.typ.clone(), self.depth.map(|d| d+1)).unwrap();
+                let mut b = item.ctrl.spillbuf.write().unwrap();
+
+                let rt = ReprTree::new_arc(self.typ.clone());
+                let new_edittree = self.ctx.read().unwrap()
+                    .setup_edittree(
+                        rt,
+                        self.depth.map(|d| d+1)
+                    );
+                let mut tail_node = new_edittree.write().unwrap();
                 tail_node.goto(TreeCursor::home());
 
                 for node in b.iter() {
@@ -316,7 +322,7 @@ impl ListEditor {
                         .send_cmd_obj(
                             ReprTree::new_leaf(
                                 Context::parse(&self.ctx, "NestedNode"),
-                                SingletonBuffer::<NestedNode>::new(
+                                SingletonBuffer::<EditTree>::new(
                                     node.read().unwrap().clone()
                                 ).get_port().into()
                             )
@@ -331,11 +337,12 @@ impl ListEditor {
                 if cur.tree_addr.len() > 1 {
                     tail_node.dn();
                 }
+                drop(tail_node);
 
                 self.insert(
-                    Arc::new(RwLock::new(tail_node))
+                    new_edittree
                 );
-*/
+
             } else {
                 self.up();
                 self.listlist_split();
@@ -366,12 +373,12 @@ impl ListEditor {
 
             let old_cur = pxv_editor.get_cursor();
 
-            let data = cur_editor.edit.spillbuf.read().unwrap();
+            let data = cur_editor.ctrl.spillbuf.read().unwrap();
             for x in data.iter() {
                 pxv_editor.send_cmd_obj(
                     ReprTree::new_leaf(
                         Context::parse(&self.ctx, "NestedNode"),
-                        SingletonBuffer::<NestedNode>::new(
+                        SingletonBuffer::<EditTree>::new(
                             x.read().unwrap().clone()
                         ).get_port().into()
                     )
@@ -424,13 +431,13 @@ impl ListEditor {
                 leaf_mode: ListCursorMode::Insert
             });
  
-            let data = nxd_editor.edit.spillbuf.read().unwrap();
+            let data = nxd_editor.ctrl.spillbuf.read().unwrap();
 
             for x in data.iter() {
                 cur_editor.send_cmd_obj(
                     ReprTree::new_leaf(
                         Context::parse(&self.ctx, "NestedNode"),
-                        SingletonBuffer::<NestedNode>::new(
+                        SingletonBuffer::<EditTree>::new(
                             x.read().unwrap().clone()
                         ).get_port().into()
                     )
diff --git a/lib-nested-core/src/editors/list/segment.rs b/lib-nested-core/src/editors/list/segment.rs
index 9e23550..f8dbdc7 100644
--- a/lib-nested-core/src/editors/list/segment.rs
+++ b/lib-nested-core/src/editors/list/segment.rs
@@ -9,7 +9,7 @@ use {
     },
     crate::{
         editors::list::{ListCursor, ListCursorMode},
-        edit_tree::{NestedNode}
+        edit_tree::{EditTree}
     },
     std::sync::Arc,
     std::sync::RwLock,
@@ -18,13 +18,13 @@ use {
 pub enum ListSegment {
     InsertCursor,
     Item {
-        editor: NestedNode,
+        editor: EditTree,
         cur_dist: isize,
     }
 }
 
 pub struct ListSegmentSequence {
-    data: Arc<dyn SequenceView<Item = NestedNode>>,
+    data: Arc<dyn SequenceView<Item = EditTree>>,
     cursor: Arc<dyn SingletonView<Item = ListCursor>>,
 
     cur_cursor: ListCursor,
@@ -88,7 +88,7 @@ impl SequenceView for ListSegmentSequence {
 impl ListSegmentSequence {
     pub fn new(
         cursor_port: OuterViewPort<dyn SingletonView<Item = ListCursor>>,
-        data_port: OuterViewPort<dyn SequenceView<Item = NestedNode>>,
+        data_port: OuterViewPort<dyn SequenceView<Item = EditTree>>,
     ) -> Arc<RwLock<Self>> {
         let out_port = ViewPort::new();
         let mut proj_helper = ProjectionHelper::new(out_port.update_hooks.clone());
diff --git a/lib-nested-core/src/editors/mod.rs b/lib-nested-core/src/editors/mod.rs
index eebac4e..3a720c3 100644
--- a/lib-nested-core/src/editors/mod.rs
+++ b/lib-nested-core/src/editors/mod.rs
@@ -4,7 +4,7 @@ pub mod list;
 //pub mod sum;
 
 pub mod char;
-//pub mod integer;
+pub mod integer;
 //pub mod typeterm;
 
 
@@ -24,3 +24,4 @@ pub trait ObjCommander {
     fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult;
 }
 
+
diff --git a/lib-nested-core/src/repr_tree/context.rs b/lib-nested-core/src/repr_tree/context.rs
index dbdd92a..ef07efe 100644
--- a/lib-nested-core/src/repr_tree/context.rs
+++ b/lib-nested-core/src/repr_tree/context.rs
@@ -3,7 +3,7 @@ use {
     laddertypes::{TypeDict, TypeTerm, TypeID},
     crate::{
         repr_tree::{ReprTree, MorphismType, GenericReprTreeMorphism, MorphismBase},
-        edit_tree::NestedNode
+        edit_tree::EditTree
     },
     std::{
         collections::HashMap,
@@ -29,12 +29,16 @@ pub struct Context {
     pub list_types: Vec< TypeID >,
     pub meta_chars: Vec< char >,
 
+    edittree_hook: Arc< dyn Fn(Arc<RwLock<EditTree>>, TypeTerm) + Send +Sync +'static >,
+
     /// recursion
     parent: Option<Arc<RwLock<Context>>>,
 }
 
 impl Context {
-    pub fn with_parent(parent: Option<Arc<RwLock<Context>>>) -> Self {
+    pub fn with_parent(
+        parent: Option<Arc<RwLock<Context>>>
+    ) -> Self {
         Context {
             type_dict: match parent.as_ref() {
                 Some(p) => p.read().unwrap().type_dict.clone(),
@@ -51,6 +55,8 @@ impl Context {
                 None => Vec::new()
             },
             parent,
+
+            edittree_hook: Arc::new(|_et, _t| {})
         }
     }
 
@@ -58,6 +64,10 @@ impl Context {
         Context::with_parent(None)
     }
 
+    pub fn set_edittree_hook(&mut self, hook: Arc< dyn Fn(Arc<RwLock<EditTree>>, TypeTerm) + Send +Sync +'static >) {
+        self.edittree_hook = hook;
+    }
+
     pub fn depth(&self) -> usize {
         if let Some(parent) = self.parent.as_ref() {
             parent.read().unwrap().depth() + 1
@@ -165,6 +175,36 @@ impl Context {
             None
         }
     }
+
+    pub fn setup_edittree(
+        &self,
+        rt: Arc<RwLock<ReprTree>>,
+        depth: OuterViewPort<dyn SingletonView<Item = usize>>
+    ) -> Arc<RwLock<EditTree>> {
+        let ladder = TypeTerm::Ladder(vec![
+                rt.read().unwrap().get_type().clone(),
+                self.type_term_from_str("EditTree").expect("")
+            ]);
+        
+        self.morphisms.morph(
+            rt.clone(),
+            &ladder
+        );
+
+        let new_edittree = rt
+            .read().unwrap()
+            .descend(
+            self.type_term_from_str("EditTree").expect("")
+        ).unwrap()
+            .read().unwrap()
+            .get_view::<dyn SingletonView<Item = Arc<RwLock<EditTree>> >>()
+            .unwrap()
+            .get();
+
+        (*self.edittree_hook)( new_edittree.clone(), rt.read().unwrap().get_type().clone() );
+
+        new_edittree
+    }
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
diff --git a/lib-nested-core/src/repr_tree/mod.rs b/lib-nested-core/src/repr_tree/mod.rs
index dc6e7d9..1f5ce63 100644
--- a/lib-nested-core/src/repr_tree/mod.rs
+++ b/lib-nested-core/src/repr_tree/mod.rs
@@ -7,7 +7,7 @@ pub use {
 };
 
 use {
-    r3vi::view::{AnyOuterViewPort, OuterViewPort, View},
+    r3vi::view::{AnyOuterViewPort, OuterViewPort, View, singleton::*},
     laddertypes::{TypeTerm},
     std::{
         collections::HashMap,
@@ -26,10 +26,10 @@ pub struct ReprTree {
 
 impl std::fmt::Debug for ReprTree {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "type: {:?}", self.type_tag)?;
+        writeln!(f, "| type: {:?}", self.type_tag)?;
 
         for (_k,x) in self.branches.iter() {
-            write!(f, "child: {:?}", x)?;
+            writeln!(f, "|--> child: {:?}", x)?;
         }
 
         Ok(())
@@ -99,7 +99,14 @@ impl ReprTree {
 
     //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-    
+
+    pub fn view_char(&self) -> OuterViewPort<dyn SingletonView<Item = char>> {
+        self.get_port::<dyn SingletonView<Item = char>>().expect("no char-view available")
+    }
+
+    pub fn view_u64(&self) -> OuterViewPort<dyn SingletonView<Item = u64>> {
+        self.get_port::<dyn SingletonView<Item = u64>>().expect("no u64-view available")
+    }
 
     pub fn get_port<V: View + ?Sized + 'static>(&self) -> Option<OuterViewPort<V>>
     where
diff --git a/lib-nested-core/src/repr_tree/morphism.rs b/lib-nested-core/src/repr_tree/morphism.rs
index 2cb58cc..689cffc 100644
--- a/lib-nested-core/src/repr_tree/morphism.rs
+++ b/lib-nested-core/src/repr_tree/morphism.rs
@@ -68,7 +68,6 @@ impl MorphismBase {
             );
 
             if let Ok(σ) = unification_problem.solve() {
-                eprintln!("found matching morphism");
                 return Some((m, σ));
             }
         }
@@ -81,7 +80,8 @@ impl MorphismBase {
         repr_tree: Arc<RwLock<ReprTree>>,
         target_type: &TypeTerm
     ) {
-        if let Some((m, σ)) = self.find_morphism( repr_tree.read().unwrap().get_type(), target_type ) {
+        let t = repr_tree.read().unwrap().get_type().clone();
+        if let Some((m, σ)) = self.find_morphism( &t, target_type ) {
             (m.repr_tree_op)( repr_tree.clone(), &σ );
         } else {
             eprintln!("could not find morphism");
diff --git a/lib-nested-tty/src/edit_tree/keymap.rs b/lib-nested-tty/src/edit_tree/keymap.rs
index 54e4679..1afc123 100644
--- a/lib-nested-tty/src/edit_tree/keymap.rs
+++ b/lib-nested-tty/src/edit_tree/keymap.rs
@@ -99,11 +99,12 @@ impl TerminalEvent {
                 }
             }
             _ => {
-                                ReprTree::new_leaf(
-                                    Context::parse(&ctx, "TerminalEvent"),
-                                    SingletonBuffer::new(self.clone()).get_port().into()
-                                )
+                ReprTree::new_leaf(
+                    Context::parse(&ctx, "TerminalEvent"),
+                    SingletonBuffer::new(self.clone()).get_port().into()
+                )
             }
         }
     }
 }
+
diff --git a/lib-nested-tty/src/editors/list.rs b/lib-nested-tty/src/editors/list.rs
index 9b0cdd9..83ec4ec 100644
--- a/lib-nested-tty/src/editors/list.rs
+++ b/lib-nested-tty/src/editors/list.rs
@@ -6,7 +6,7 @@ use {
     nested::{
         repr_tree::{Context, ReprTree},
         editors::list::*,
-        edit_tree::{TreeCursor, TreeNav, TreeNavResult, NestedNode},
+        edit_tree::{TreeCursor, TreeNav, TreeNavResult, EditTree},
     },
     crate::{
         DisplaySegment,
@@ -91,7 +91,7 @@ impl PTYListStyle {
             .flatten()
     }
 
-    pub fn for_node(node: &mut NestedNode, style: (&str, &str, &str)) {
+    pub fn for_node(node: &mut EditTree, style: (&str, &str, &str)) {
         node.disp.view
             .write().unwrap()
             .insert_branch(ReprTree::new_leaf(
@@ -135,10 +135,11 @@ impl PTYListController {
     }
 
     pub fn for_node(
-        node: &mut NestedNode,
+        node: &mut EditTree,
         split_char: Option<char>,
         close_char: Option<char>
     ) {
+/*
         {
             let ctx = node.ctx.as_ref();
             let mut ctx = ctx.write().unwrap();
@@ -150,15 +151,15 @@ impl PTYListController {
                 ctx.meta_chars.push(*c);
             }
         }
-        
+*/
         let editor = node.get_edit::<ListEditor>().unwrap();
         let controller = Arc::new(RwLock::new(PTYListController::from_editor( editor, split_char, close_char, node.disp.depth.clone() )));
 
-        node.edit.cmd.set(Some(controller.clone()));
-        node.edit.close_char.set(close_char);
+        node.ctrl.cmd.set(Some(controller.clone()));
+        node.ctrl.close_char.set(close_char);
     }
 
-    pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = NestedNode>> {
+    pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = EditTree>> {
         self.editor.read().unwrap().get_data_port()
     }
 
@@ -166,7 +167,7 @@ impl PTYListController {
         self.editor.write().unwrap().clear();
     }
 
-    pub fn get_item(&self) -> Option<NestedNode> {
+    pub fn get_item(&self) -> Option<EditTree> {
         self.editor.read().unwrap().get_item()
     }
 
@@ -219,26 +220,27 @@ impl PTYListController {
 
         match cur.mode {
             ListCursorMode::Insert => {
-                /* TODO
-                let mut new_edit = Context::make_node(&e.ctx, e.typ.clone(), self.depth.map(|d| d+1)).unwrap();
-                new_edit.goto(TreeCursor::home());
-
-                match new_edit.send_cmd_obj(cmd_obj.clone()) {
+                let rt = ReprTree::new_arc(e.typ.clone());
+                let new_edittree = ctx.setup_edittree(
+                    rt,
+                    self.depth.map(|d| d+1)
+                );
+                let mut ne = new_edittree.write().unwrap();
+                match ne.send_cmd_obj(cmd_obj.clone()) {
                     TreeNavResult::Continue => {
-                        e.insert(Arc::new(RwLock::new(new_edit.clone())));
+                        drop(ne);
+                        e.insert(new_edittree.clone());
                         TreeNavResult::Continue
                     }
                     TreeNavResult::Exit => {
                         TreeNavResult::Exit
                     }
                 }
-                */
-                TreeNavResult::Continue
             },
             ListCursorMode::Select => {
                 if let Some(item) = e.get_item_mut() {
                     let res = item.write().unwrap().send_cmd_obj(cmd_obj.clone());
-                    let child_close_char = item.read().unwrap().edit.close_char.get();
+                    let child_close_char = item.read().unwrap().ctrl.close_char.get();
 
                    match res {
                         TreeNavResult::Continue => TreeNavResult::Continue,
diff --git a/lib-nested-tty/src/editors/mod.rs b/lib-nested-tty/src/editors/mod.rs
index 3d2a7b4..3133edd 100644
--- a/lib-nested-tty/src/editors/mod.rs
+++ b/lib-nested-tty/src/editors/mod.rs
@@ -3,7 +3,7 @@ pub mod list;
 
 use {
     nested::{
-        edit_tree::{NestedNode},
+        edit_tree::{EditTree},
         repr_tree::{ReprTree, Context}
     },
     r3vi::{
@@ -13,22 +13,22 @@ use {
     crate::{
         make_label,
         DisplaySegment,
-        atom::TerminalAtom
+        atom::{TerminalAtom, TerminalStyle}
     }
 };
-/*
-pub fn node_make_char_view(
-    node: NestedNode
-) -> NestedNode {
+
+pub fn edittree_make_char_view(
+    node: EditTree
+) -> EditTree {
     node.disp.view
         .write().unwrap()
         .insert_branch(ReprTree::new_leaf(
             Context::parse(&node.ctx, "TerminalView"),
-            node.data
+            node.get_edit::< nested::editors::char::CharEditor >()
+                .unwrap()
                 .read()
                 .unwrap()
-                .get_port::<dyn SingletonView<Item = char>>()
-                .expect("unable to get Char-view")
+                .get_port()
                 .map(move |c| TerminalAtom::from(if c == '\0' { ' ' } else { c }))
                 .to_grid()
                 .into(),
@@ -37,19 +37,46 @@ pub fn node_make_char_view(
     node
 }
 
-pub fn node_make_seq_view(
-    mut node: NestedNode
-) -> NestedNode {
+pub fn edittree_make_digit_view(
+    node: EditTree
+) -> EditTree {
     node.disp.view
         .write().unwrap()
         .insert_branch(ReprTree::new_leaf(
             Context::parse(&node.ctx, "TerminalView"),
-            node.data
+            node.get_edit::< nested::editors::integer::DigitEditor >()
+                .unwrap()
                 .read()
                 .unwrap()
-                .get_port::<dyn SequenceView<Item = NestedNode>>()
-                .expect("unable to get Seq-view")
-                .map(move |char_node| node_make_tty_view(char_node.clone()).display_view() )
+                .get_data_port()
+                .map(move |digit|
+                    match digit {
+                        Ok(digit) => TerminalAtom::new( char::from_digit(digit, 16).unwrap_or('?'), TerminalStyle::fg_color((220, 220, 0)) ),
+                        Err(c) => TerminalAtom::new( c, TerminalStyle::fg_color((220, 0, 0)) )
+                    }
+                )
+                .to_grid()
+                .into(),
+        ));
+
+    node
+}
+
+/*
+pub fn edittree_make_seq_view(
+    mut node: EditTree
+) -> EditTree {
+    node.disp.view
+        .write().unwrap()
+        .insert_branch(ReprTree::new_leaf(
+            Context::parse(&node.ctx, "TerminalView"),
+            node.get_edit::< nested::editors::list::ListEditor >()
+                .unwrap()
+                .read().unwrap()
+                .get_data_port()
+                .map(move |item_edittree|
+                    edittree_make_tty_view( item_edittree ).display_view()
+                )
                 .wrap(make_label("("), make_label(")"))
                 .to_grid_horizontal()
                 .flatten()
@@ -57,28 +84,4 @@ pub fn node_make_seq_view(
         ));
     node
 }
-
-pub fn node_make_list_edit(
-    mut node: NestedNode
-) -> NestedNode {
-    list::PTYListStyle::for_node( &mut node, ("(", "", ")") );
-    list::PTYListController::for_node( &mut node, None, None );
-
-    node
-}
-
-pub fn node_make_tty_view(
-    node: NestedNode
-) -> NestedNode {
-    if node.data.read().unwrap().get_type() == &Context::parse(&node.ctx, "Char") {
-        node_make_char_view( node )
-    } else if node.data.read().unwrap().get_type() == &Context::parse(&node.ctx, "<Seq Char>") {
-        node_make_seq_view( node )
-    } else if node.data.read().unwrap().get_type() == &Context::parse(&node.ctx, "<List Char>") {
-        node_make_list_edit( node )
-    } else {
-        eprintln!("couldnt add view");
-        node
-    }
-}
 */
diff --git a/lib-nested-tty/src/lib.rs b/lib-nested-tty/src/lib.rs
index e7c03a3..f5631af 100644
--- a/lib-nested-tty/src/lib.rs
+++ b/lib-nested-tty/src/lib.rs
@@ -42,7 +42,7 @@ pub trait DisplaySegment {
 use nested::repr_tree::Context;
 use std::sync::{Arc, RwLock};
 
-impl DisplaySegment for nested::edit_tree::NestedNode {
+impl DisplaySegment for nested::edit_tree::EditTree {
     fn display_view(&self) -> OuterViewPort<dyn TerminalView> {
         if let Some( tv_repr ) = self.disp.view
             .read().unwrap()
@@ -56,10 +56,10 @@ impl DisplaySegment for nested::edit_tree::NestedNode {
                 }
                 
                 else {
-                make_label("?")
+                make_label("# could not get ViewPort #")
             }
         } else {
-            make_label("?")
+            make_label("# No TTY View available #")
             .map_item(|_p,a| a.add_style_back(TerminalStyle::fg_color((220, 30, 30))))
         }
     }
diff --git a/lib-nested-tty/src/tty_application.rs b/lib-nested-tty/src/tty_application.rs
index abcbf0b..aade2bb 100644
--- a/lib-nested-tty/src/tty_application.rs
+++ b/lib-nested-tty/src/tty_application.rs
@@ -1,7 +1,7 @@
 use {
     cgmath::Vector2,
     nested::{
-        edit_tree::NestedNode,
+        edit_tree::EditTree,
         repr_tree::{Context, ReprTree},
     },
     crate::{
diff --git a/pty-server/Cargo.toml b/pty-server/Cargo.toml
index 2b1ca1d..86e08e0 100644
--- a/pty-server/Cargo.toml
+++ b/pty-server/Cargo.toml
@@ -1,11 +1,12 @@
 [package]
 authors = ["Michael Sippel <micha@fragmental.art>"]
-name = "ansi_parser"
+name = "pty-server"
 version = "0.1.0"
 edition = "2018"
 
 [dependencies]
-nested = { path = "../../nested" }
+nested = { path = "../lib-nested-core" }
+nested-tty = { path = "../lib-nested-tty" }
 cgmath = { version = "0.18.0", features = ["serde"] }
 serde = { version = "1.0", features = ["serde_derive"] }
 bincode = "1.3.3"