ioDidSucceed: function ( event ) {
   // Parse data
   var data;
   try {
     data = JSON.parse( event.data );
   } catch ( error ) {}

   // Check it's in the correct format
   if ( !( data instanceof Array ) ) {
     NS.RunLoop.didError({
       name: 'O.RPCSource#ioDidSucceed',
       message: 'Data from server is not JSON.',
       details: 'Data:\n' + event.data +
         '\n\nin reponse to request:\n' +
         JSON.stringify( this._inFlightRemoteCalls, null, 2 )
     });
     data = [];
   }

   this.receive(
     data, this._inFlightCallbacks, this._inFlightRemoteCalls );

   this._inFlightRemoteCalls = this._inFlightCallbacks = null;
 }.on( 'io:success' ),

ioDidFail: function (/* event */) {
   if ( !this.get( 'willRetry' ) ) {
     this.receive(
       [], this._inFlightCallbacks, this._inFlightRemoteCalls );
     this._inFlightRemoteCalls = this._inFlightCallbacks = null;
   }
 }.on( 'io:failure', 'io:abort' ),

ioDidEnd: function ( event ) {
   // Send any waiting requests
   this.set( 'inFlightRequest', null )
     .send();
   // Destroy old HttpRequest object.
   event.target.destroy();
 }.on( 'io:end' ),

callMethod: function ( name, args, callback ) {
   var id = this._sendQueue.length + '';
   this._sendQueue.push([ name, args || {}, id ]);
   if ( callback ) {
     this._callbackQueue.push([ id, callback ]);
   }
   this.send();
   return this;
 },

send: function () {
   if ( !this.get( 'inFlightRequest' ) ) {
     var remoteCalls = this._inFlightRemoteCalls,
       request;
     if ( !this._inFlightRemoteCalls ) {
       request = this.makeRequest();
       remoteCalls = request[0];
       if ( !remoteCalls.length ) { return; }
       this._inFlightRemoteCalls = remoteCalls;
       this._inFlightCallbacks = request[1];
     }

     this.set( 'inFlightRequest',
       new NS.HttpRequest({
         nextEventTarget: this,
         timeout: this.get( 'timeout' ),
         method: 'POST',
         url: this.get( 'url' ),
         contentType: 'application/json',
         data: JSON.stringify( remoteCalls )
       }).send()
     );
   }
 }.queue( 'after' ),

receive: function ( data, callbacks, remoteCalls ) {
   var handlers = this.response,
     i, l, response, handler,
     remoteCallsLength,
     tuple, id, callback, request;
   for ( i = 0, l = data.length; i < l; i += 1 ) {
     response = data[i];
     handler = handlers[ response[0] ];
     if ( handler ) {
       id = response[2];
       request = remoteCalls[+id];
       try {
         handler.call( this, response[1], request[0], request[1] );
       } catch ( error ) {
         NS.RunLoop.didError( error );
       }
     }
   }
   // Invoke after bindings to ensure all data has propagated through.
   if ( l = callbacks.length ) {
     remoteCallsLength = remoteCalls.length;
     for ( i = 0; i < l; i += 1 ) {
       tuple = callbacks[i];
       id = tuple[0];
       callback = tuple[1];
       if ( id ) {
         request = remoteCalls[+id];
         /* jshint ignore:start */
         response = data.filter( function ( call ) {
           return call[2] === id;
         });
         /* jshint ignore:end */
         callback = callback.bind( null, response, request );
       }
       NS.RunLoop.queueFn( 'middle', callback );
     }
   }
 },

makeRequest: function () {
   var sendQueue = this._sendQueue,
     callbacks = this._callbackQueue,
     _recordsToFetch = this._recordsToFetch,
     _recordsToRefresh = this._recordsToRefresh,
     _queriesToFetch = this._queriesToFetch,
     type, id, req, handler;

   // Query Fetches
   for ( id in _queriesToFetch ) {
     req = _queriesToFetch[ id ];
     handler = this.queryFetchers[ NS.guid( req.constructor ) ];
     if ( handler ) {
       handler.call( this, req );
     }
   }

   // Record Refreshers
   for ( type in _recordsToRefresh ) {
     this.recordRefreshers[ type ].call(
       this, Object.keys( _recordsToRefresh[ type ] ) );
   }

   // Record fetches
   for ( type in _recordsToFetch ) {
     this.recordFetchers[ type ].call(
       this, Object.keys( _recordsToFetch[ type ] ) );
   }

   // Any future requests will be added to a new queue.
   this._sendQueue = [];
   this._callbackQueue = [];

   this._recordsToFetch = {};
   this._recordsToRefresh = {};
   this._queriesToFetch = {};

   return [ sendQueue, callbacks ];
 },

 // ---

fetchRecord: function ( Type, id, callback ) {
   return this.fetchRecords( Type, [ id ], callback );
 },

fetchAllRecords: function ( Type, state, callback ) {
   return state ?
     this.refreshRecords( Type, null, state, callback ) :
     this.fetchRecords( Type, null, callback );
 },

fetchRecords: function ( Type, ids, callback ) {
   var typeId = NS.guid( Type ),
     handler = this.recordFetchers[ typeId ];
   if ( !handler ) {
     return false;
   }
   if ( typeof handler === 'string' ) {
     this.callMethod( handler );
   } else if ( ids instanceof Array ) {
     var reqs = this._recordsToFetch,
       set = reqs[ typeId ] || ( reqs[ typeId ] = {} ),
       l = ids.length;
     while ( l-- ) {
       set[ ids[l] ] = true;
     }
   } else {
     // Pass through object requests straight through to the
     // handler.
     handler.call( this, ids );
   }
   if ( callback ) {
     this._callbackQueue.push([ '', callback ]);
   }
   this.send();
   return true;
 },

refreshRecord: function ( Type, id, callback ) {
   return this.refreshRecords( Type, [ id ], null, callback );
 },

refreshRecords: function ( Type, ids, state, callback ) {
   var typeId = NS.guid( Type ),
     handler = this.recordRefreshers[ typeId ];
   if ( handler ) {
     if ( typeof handler === 'string' ) {
       this.callMethod( handler, { state: state });
     }
     else if ( ids instanceof Array ) {
       var reqs = this._recordsToRefresh,
         set = reqs[ typeId ] || ( reqs[ typeId ] = {} ),
         l = ids.length;
       while ( l-- ) {
         set[ ids[l] ] = true;
       }
     } else {
       // Pass through object requests straight through to the
       // handler.
       handler.call( this, ids, state );
     }
     if ( callback ) {
       this._callbackQueue.push([ '', callback ]);
     }
     this.send();
   } else {
     // If we don't have a way to refresh just the mutable bits,
     // just re-fetch the whole thing.
     return this.fetchRecords( Type, ids, callback );
   }
   return true;
 },

commitChanges: function ( changes, callback ) {
   var types = Object.keys( changes ),
     l = types.length,
     precedence = this.commitPrecedence,
     handledAny = false,
     type, handler, handledType,
     change, create, update, destroy;

   if ( precedence ) {
     types.sort( function ( a, b ) {
       return ( precedence[b] || -1 ) - ( precedence[a] || -1 );
     });
   }

   while ( l-- ) {
     type = types[l];
     change = changes[ type ];
     handler = this.recordCommitters[ type ];
     handledType = false;
     create = change.create;
     update = change.update;
     destroy = change.destroy;
     if ( handler ) {
       if ( typeof handler === 'string' ) {
         this.callMethod( handler, {
           state: change.state,
           create: Object.zip( create.storeKeys, create.records ),
           update: Object.zip(
             update.storeKeys, delta( update, change.primaryKey )
           ),
           destroy: Object.zip( destroy.storeKeys, destroy.ids )
         });
       } else {
         handler.call( this, change );
       }
       handledType = true;
     } else {
       handler = this.recordCreators[ type ];
       if ( handler ) {
         handler.call( this, create.storeKeys, create.records );
         handledType = true;
       }
       handler = this.recordUpdaters[ type ];
       if ( handler ) {
         handler.call( this,
           update.storeKeys, update.records, update.changes );
         handledType = true;
       }
       handler = this.recordDestroyers[ type ];
       if ( handler ) {
         handler.call( this, destroy.storeKeys, destroy.ids );
         handledType = true;
       }
     }
     if ( handledType ) {
       delete changes[ type ];
     }
     handledAny = handledAny || handledType;
   }
   if ( handledAny && callback ) {
     this._callbackQueue.push([ '', callback ]);
   }
   return handledAny;
 },

fetchQuery: function ( query, callback ) {
   if ( !this.queryFetchers[ NS.guid( query.constructor ) ] ) {
     return false;
   }
   var id = query.get( 'id' );

   this._queriesToFetch[ id ] = query;

   if ( callback ) {
     this._callbackQueue.push([ '', callback ]);
   }
   this.send();
   return true;
 },

handle: function ( Type, handlers ) {
   var typeId = NS.guid( Type ),
     action, propName, isResponse, actionHandlers;
   for ( action in handlers ) {
     propName = handleProps[ action ];
     isResponse = !propName;
     if ( isResponse ) {
       propName = 'response';
     }
     actionHandlers = this[ propName ];
     if ( !this.hasOwnProperty( propName ) ) {
       this[ propName ] = actionHandlers =
         Object.create( actionHandlers );
     }
     actionHandlers[ isResponse ? action : typeId ] = handlers[ action ];
   }
   return this;
 },