steal('can/util', 'can/model', 'can/observe/backup', function(can){

	var cleanAttrs = function(changedAttrs, attrs){
			var newAttrs = can.extend(true, {}, attrs),
				attr, current, path;
			if(changedAttrs){
				for(var i = 0; i < changedAttrs.length; i++){
					current = newAttrs;
					path    = changedAttrs[i].split('.');
					while(path.length > 1){
						current = current && current[path.shift()];
					}
					current && delete current[path.shift()];
				}
			}
			return newAttrs;
		},
		queueRequests = function( success, error, method, callback) {
			this._requestQueue = this._requestQueue || [];
			this._changedAttrs = this._changedAttrs || [];

			var def          = new can.Deferred,
				self         = this,
				attrs        = this.attr(),
				queue        = this._requestQueue,
				changedAttrs = this._changedAttrs,
				reqFn, index;

			reqFn = (function(self, type, success, error){
				// Function that performs actual request
				return function(){
					return self.constructor._makeRequest([self, attrs], type, success, error, callback)
				}
				// we shouldn't pass this, instead we need to pass something like
				// [this, this.serialize()]
			})(this, method || (this.isNew() ? 'create' : 'update'), function(){
				// resolve deferred with results from the request
				def.resolveWith(self, arguments);
				// remove current deferred from the queue 
				queue.splice(0, 1);
				if(queue.length > 0){
					// replace queued wrapper function with deferred
					// returned from the makeRequest function so we 
					// can access it's `abort` function
					queue[0] = queue[0]();
				} else {
					changedAttrs.splice(0);
				}
				
			}, function(){
				// reject deferred with results from the request
				def.rejectWith(self, arguments);
				// since we failed remove all pending requests from the queue
				queue.splice(0);
				changedAttrs.splice(0);
			})

			// Add our fn to the queue
			index = queue.push(reqFn) - 1;

			// If there is only one request in the queue, run
			// it immediately.
			if(queue.length === 1){
				// replace queued wrapper function with deferred
				// returned from the makeRequest function so we 
				// can access it's `abort` function
				queue[0] = queue[0]();
			}

			def.abort = function(){
				var abort;
				// check if this request is running, if it's not
				// just remove it from the queue
				// 
				// also all subsequent requests should be removed too
				abort = queue[index].abort && queue[index].abort();
				// remove aborted request and any requests after it
				queue.splice(index);
				changedAttrs.splice(0);
				return abort;
			}
			// deferred will be resolved with original success and
			// error functions
			def.then(success, error);

			return def;
		},
		_changes  = can.Model.prototype._changes,
		destroyFn = can.Model.prototype.destroy;

	can.each(["created", "updated", "destroyed"], function(fn){
		var prototypeFn = can.Model.prototype[fn];

		can.Model.prototype[fn] = function(attrs){
			if(attrs && typeof attrs == 'object'){
				attrs = attrs.attr ? attrs.attr() : attrs;
				this._backupStore = attrs;
				attrs = cleanAttrs(this._changedAttrs || [], attrs);
			}
			prototypeFn.call(this, attrs);
		}
	})

	can.extend(can.Model.prototype, {
		_changes: function(ev, attr, how,newVal, oldVal){
			// record changes if there is a request running
			this._changedAttrs && this._changedAttrs.push(attr);
			_changes.apply(this, arguments);
		},
		hasQueuedRequests : function(){
			return this._requestQueue && this._requestQueue.length > 1;
		},
		save : function(){
			return queueRequests.apply(this, arguments);
		},
		destroy : function(success, error){
			if(this.isNew()){
				return destroyFn.call(this, success, error);
			}
			return queueRequests.call(this, success, error, 'destroy', 'destroyed');
		}
	})
})
@@ -558,58 +558,8 @@
 ) %7B%0A
-%09%09%09this._requestQueue = this._requestQueue %7C%7C %5B%5D;%0A
 %09%09%09t
@@ -2782,18 +2782,59 @@
 .destroy
+,%0A%09%09setupFn   = can.Model.prototype.setup
 ;%0A
-
 %0A%09can.ea
@@ -3238,16 +3238,123 @@
 type, %7B%0A
+%09%09setup: function()%7B%0A%09%09%09setupFn.apply(this, arguments);%0A%09%09%09this._requestQueue = new can.Observe.List;%0A%09%09%7D,%0A
 %09%09_chang
@@ -3611,37 +3611,23 @@
 ueue
- && this._requestQueue.
+.attr('
 length
+')
  %3E 1

Make requestQueue list an observe so it's live-bindable