docs: function({_t0, arg, keys, inv}) {
  		const key = keys && makeKey(opts, keys);
  		const lay = layers.map(l => l.instantiate({key, ttl, ttr, inv}));
  		const fix = lay.slice();
  		const ret = Q.defer();
  		const bld = () => {
  			const _t1 = new Date;
  			return Q()
  				.then(() => func.apply(this, arg))
  				.then(val => {
  					time('build', new Date - _t1);
  					return val;
  				});
  		}
  
  		const set = (layer, val) => {
  			if (shouldCache(val)) {
  				layer.set(val);
  			}
  		}
  
  		const pump = () => {
  
  			// Get the next layer.
  			const cur = lay.shift();
  			const _t1 = new Date;
  
  			// If we couldn't make a key, then we force a miss.
  			// If we're out of layers, then we'll just have to
  			// build.  It's a full miss.
  			// We can _force_ a miss with the `_bust` parameter.
  			if (!key || !cur || force()) {
  				bld().then(val => {
  
  					// Hand it off.
  					ret.resolve(val)
  
  					// Sob about it.
  					time('miss', new Date - _t0);
  
  				// Patch rejection through to return promise.
  				}).catch(err => ret.reject(err));
  				return;
  			}
  
  			Q().then(() => cur.get()).then(() => {
  
  				// If we found a value and it's not expired.
  				if (cur.val && !cur.exp) {
  
  					// Hand it off.
  					ret.resolve(cur.val);
  
  					// Brag about it.
  					time('hit', new Date - _t0);
  					time(`layer.${cur.name()}.hit.fromStart`,  new Date - _t0);
  					time(`layer.${cur.name()}.hit.individual`, new Date - _t1);
  
  					// If our time-to-rebuild has elapsed,
  					// we'll rebuild in the background and
  					// populate the new value into all
  					// layers.
  					if (cur.red) {
  						bld().then((val) => {
  							fix.forEach(layer => set(layer, val));
  						}).catch(() => {
  							time('error.background', new Date - _t0);
  						});
  
  					}
  				} else {
  
  					// Miss.  Populate this layer later
  					// when we get a value.
  					ret.promise.then(val => set(cur, val));
  
  					time(`layer.${cur.name()}.miss.fromStart`,  new Date - _t0);
  					time(`layer.${cur.name()}.miss.individual`, new Date - _t1);
  
  					// Try the next layer.
  					pump();
  				}
  			});
  		}
  
  		if (inv) {
  			// Invalidate.
  			Q.all(fix.map(l => l.set())).then(ret.resolve);
  		} else {
  			// Start looking!
  			pump();
  		}
  
  		// Log if we reject.
  		ret.promise.catch(() => time('error.returned', new Date - _t0));
  
  		// We'll find it, we promise!
  		return ret.promise
  
  			// Post-processing on the way out of the cache.
  			.then(after)
  
  			// Down and to the right!
  			.then(v => (time('overall', new Date - _t0), v))
  	}