docs: function standard(options, callback) {
  	total('Start'); // Total is a time debug()
  
  	var options   = _.extend({}, defaults, options)
  	  , callback  = (callback || function() {})
  	  , tree
  	  , packets
  	  , incBundles = []
  	;
  
  	// BUILD FLOW
  
  /**
   * Step 1
   *
   * Prepare builder information using nway.prepare() :
   * modules object, root module, sources, tree and packet list
   *
   * @api private
   */
  	function initialize(done) {
  		debug('prepare');
  
  		parser(options.index, options, function(err,  modules) {
  			if(err) return done(err)
  
  			debug('Parser return, now build the tree...');
  			tree          = buildTree(options, modules, true);
  
  			debug('Tree builded');
  
  			// Extract from tree as a flatten list of packets to compile
  			packets       = tree.getAllBundles(options);
  
  			done(null);
  		})
  
  	}
  
  /**
   * Step 2
   *
   * Create the required directories :
   *
   *   - output directory
   *
   * @api private
   */
  	function createDirectories(done) {
  		debug('createDirectories()');
  		var paths = [ options.output ];
  		function iterator(dirpath, next) { mkdirp(dirpath, '0755', next); };
  		async.forEach(paths, iterator, done);
  	}
  
  
  /**
   * Step 3
   *
   * Apply packet the packet exclusion process : if a packet is allready generated
   * (with the same hash key) then the packet is removed from the generator
   * stack.
   *
   * If the generator stack is empty, then the NoErrorEnd() object returned to the
   * callback stop the generation process.
   *
   * @api private
   */
  	function excludeBundles(done) {
  		debug('excludeBundles()');
  
  		// With force options to true : do not exclude any packet
  		if(options.force) {
  			incBundles = packets;
  			return done();
  		}
  
  		// Check the existence of all the packets output files :
  		async.forEach(packets, function(packet, next) {
  			fs.stat(packet.makePath(options), function(err) {
  				// Packet doesn't exits : add it to packets to compile :
  				if(err) incBundles.push(packet);
  				next();
  			});
  		}, function() {
  			if(!incBundles.length) {
  				// Stop generation process if all the packets are allready
  				// generated
  
  				//return done(new NoErrorEnd()); // !! Bug : we nee to rewrite the
  				//bootstrap anyway !!
  			}
  			done();
  		});
  	}
  
  
  
  /**
   * Step 5
   *
   * Call write() on all packets
   *
   * @api private
   */
  	function writeBundles(done) {
  		debug('writeBundles()');
  		async.forEachSeries(incBundles, function(packet, next) {
  			packet.write(options, next);
  		}, done);
  	}
  
  /**
   * Step 8
   *
   * Wite the boostrap file
   *
   * @api private
   */
  	function writeBootstrap(done) {
  		var bootstrap = new Bootstrap();
  		bootstrap.write(tree, options, done);
  	}
  
  	// Run asynchronous flow :
  	async.series([
  		  initialize               // Step 1
  		, createDirectories        // Step 2
  		, excludeBundles           // Step 3
  		, writeBundles             // Step 5
  		, writeBootstrap           // Step 8
  	],function(err) {
  		total('End');
  
  		// Prepare the result object returned to the
  		// builder() callback
  		var result = {
  			  packets      : packets
  			, incBundles   : incBundles
  			, tree         : tree
  		}
  
  		if(!err || (err instanceof NoErrorEnd)) {
  			return callback(null, result);
  		} else {
  			return callback(err, result);
  		}
  	});
  
  
  }