anchor.diff:      {Node, Schema} = proplists:get_value(Id, Nodes),
       NestedNodes = [begin
                          Name = binary_to_atom(schema(get, name, N), latin1),
  -                       %%{Name, 
  -                        link_node(schema(get, id, N), Name, Nodes)
  -                       %%}
  +                       link_node(schema(get, id, N), Name, Nodes)
                      end || N <- schema(get, nestedNodes, Node)],
       Groups = case schema(get, Node) of
                    {struct, S} ->
  
positive.code:                        fun(F, G) ->
                                 case schema(get, F) of
                                     {group, GroupId} ->
                                         [%%{GroupId,
                                           link_node(GroupId, 
                                                     binary_to_atom(schema(get, name, F), latin1), 
                                                     Nodes)
                                                  %}
                                          |G];
                                     _ -> G
                                 end
                         end,
  
negative.code:     Type = schema(get, type, Field),
      compile_field(schema(get, Type), schema(get, offset, Field));
  compile_struct_field_type({group, Id}) ->
      #group{ type=Id }.
  
  compile_field({list, Type}, Offset) -> ptr_field(list_field_type(Type), Offset);
  compile_field({enum, Id}, Offset) -> data_field({{enum, Id}, 16}, Offset);
  compile_field({struct, Id}, Offset) -> ptr_field({struct, Id}, Offset);
  compile_field({interface, Id}, Offset) -> ptr_field({interface, Id}, Offset);
  compile_field(object, Offset) -> ptr_field(object, Offset);
  compile_field(text, Offset) -> ptr_field(text, Offset);
  compile_field(Type, Offset)
    when is_atom(Type) ->
      data_field(capnp_type_info(Type), Offset).
  
  list_field_type(Type) ->
      {list, 
  