docs: function recursivePartitioner(graph, node, call_stack){
  	
  	var curr_level = call_stack.length -1;
  	var next_level = curr_level +1;
  
  	ll("recur on " + node.id() + " at level " + curr_level);
  
  	// Get children and see where there are.
  	//var child_nodes = graph.get_child_nodes(node.id(), relation);
  	var child_nodes = graph.get_child_nodes(node.id());
  	ll(node.id() + " has " + (child_nodes.length || 'no' ) + ' child(ren)');
  	for( var i = 0; i < child_nodes.length; i++ ){
  	    var cnode = child_nodes[i];
  
  	    ll("looking at " + cnode.id());
  
  	    if( _cycle_p(cnode, call_stack) ){
  		ll('no update to ' + cnode.id() + ': cycle');
  	    }else{
  
  		// Add edges--safe since they're definition-based and will
  		// clobber if they're already in.
  		var new_edge =
  		    new bbop.layout.sugiyama.simple_edge(cnode.id(), node.id());
  		edge_set[ new_edge.id() ] = new_edge;
  
  		// Nodes we have to be a little more careful with since
  		// they're what we're using for traversal.
  		if( ! vertex_set[ cnode.id() ] ){
  		
  		    // Create new vertex and add to set.
  		    _new_node_at(cnode, next_level);
  		    
  		    // Since it is a new node, we traverse it.
  		    ll('cs (a): ' + call_stack);
  		    var new_cs = bbop.core.clone(call_stack);
  		    ll('cs (b): ' + new_cs);
  		    new_cs.push(cnode.id());
  		    ll('cs (c): ' + new_cs);
  		    recursivePartitioner(graph, cnode, new_cs);
  		    
  		}else{
  		    
  		    ll('to update ' + cnode.id() + ' level to ' + next_level +
  		       '; fsr: '+ first_seen_reference[ cnode.id() ] +
  		       '; lsr: '+ last_seen_reference[ cnode.id() ]);
  		    
  		    // Otherwise, just update the levels that we've seen
  		    // the child at--do not descend.
  		    if( first_seen_reference[ cnode.id() ] > next_level ){
  			first_seen_reference[ cnode.id() ] = next_level;
  		    }
  		    if( last_seen_reference[ cnode.id() ] < next_level ){
  			last_seen_reference[ cnode.id() ] = next_level;
  			// LSR is also the level that things will
  			// appear at, so update.
  			// I believe node and simple node IDs are the same?
  			vertex_set[ cnode.id() ].level = next_level;
  
  			// Recur if the LSR has change--we need to
  			// update all of the nodes below.
  			ll('cs (a): ' + call_stack);
  			var new_cs = bbop.core.clone(call_stack);
  			ll('cs (b): ' + new_cs);
  			new_cs.push(cnode.id());
  			ll('cs (c): ' + new_cs);
  			recursivePartitioner(graph, cnode, new_cs);
  		    }
  
  		    // ll('updated ' + cnode.id() + ' level to ' + next_level +
  		    //    '; fsr: '+ first_seen_reference[ cnode.id() ] +
  		    //    '; lsr: '+ last_seen_reference[ cnode.id() ]);
  		}
  	    }
  	}
      }