diff --git a/README.md b/README.md
index 57d2bfa..8ddc90e 100644
--- a/README.md
+++ b/README.md
@@ -50,7 +50,7 @@ To get started include Firebase and BackboneFire after the usual Backbone depend
 <script src="https://cdn.firebase.com/js/client/2.0.3/firebase.js"></script>
 
 <!-- BackboneFire -->
-<script src="https://cdn.firebase.com/libs/backbonefire/0.5.0/backbonefire.js"></script>
+<script src="https://cdn.firebase.com/libs/backbonefire/0.5.1/backbonefire.js"></script>
 ```
 
 Use the URL above to download both the minified and non-minified versions of BackboneFire from the
diff --git a/bower.json b/bower.json
index 275ef98..9d977a5 100644
--- a/bower.json
+++ b/bower.json
@@ -1,7 +1,7 @@
 {
   "name": "backbonefire",
   "description": "The officially supported Backbone binding for Firebase",
-  "version": "0.0.0",
+  "version": "0.5.1",
   "authors": [
     "Firebase <support@firebase.com> (https://www.firebase.com/)"
   ],
diff --git a/dist/backbonefire.js b/dist/backbonefire.js
new file mode 100644
index 0000000..2f9f697
--- /dev/null
+++ b/dist/backbonefire.js
@@ -0,0 +1,857 @@
+/*!
+ * BackboneFire is the officially supported Backbone binding for Firebase. The
+ * bindings let you use special model and collection types that allow for
+ * synchronizing data with Firebase.
+ *
+ * BackboneFire 0.5.1
+ * https://github.com/firebase/backbonefire/
+ * License: MIT
+ */
+
+(function(_, Backbone) {
+  'use strict';
+
+  Backbone.Firebase = {};
+
+  /**
+   * A utility for retrieving the key name of a Firebase ref or
+   * DataSnapshot. This is backwards-compatible with `name()`
+   * from Firebase 1.x.x and `key()` from Firebase 2.0.0+. Once
+   * support for Firebase 1.x.x is dropped in BackboneFire, this
+   * helper can be removed.
+   */
+  Backbone.Firebase._getKey = function(refOrSnapshot) {
+    return (typeof refOrSnapshot.key === 'function') ? refOrSnapshot.key() : refOrSnapshot.name();
+  };
+
+  /**
+   * A utility for resolving whether an item will have the autoSync
+   * property. Models can have this property on the prototype.
+   */
+  Backbone.Firebase._determineAutoSync = function(model, options) {
+    var proto = Object.getPrototypeOf(model);
+    return _.extend({
+        autoSync: proto.hasOwnProperty('autoSync') ? proto.autoSync : true
+      },
+      this,
+      options
+    ).autoSync;
+  };
+
+  /**
+   * Overriding of Backbone.sync.
+   * All Backbone crud calls (destroy, add, create, save...) will pipe into
+   * this method. This way Backbone can handle the prepping of the models
+   * and the trigering of the appropiate methods. While sync can be overwritten
+   * to handle updates to Firebase.
+   */
+  Backbone.Firebase.sync = function(method, model, options) {
+    var modelJSON = model.toJSON();
+
+    if (method === 'read') {
+
+      Backbone.Firebase._readOnce(model.firebase, function onComplete(snap) {
+        var resp = snap.val();
+        if(options.success) {
+          options.success(resp);
+        }
+      }, function _readOnceError(err) {
+        if(options.error) {
+          options.error(err);
+        }
+      });
+
+    } else if (method === 'create') {
+
+      Backbone.Firebase._setWithCheck(model.firebase, modelJSON, options);
+
+    } else if (method === 'update') {
+
+      Backbone.Firebase._updateWithCheck(model.firebase, modelJSON, options);
+
+    } else if(method === 'delete') {
+
+      Backbone.Firebase._setWithCheck(model.firebase, null, options);
+
+    }
+
+  };
+
+  /**
+   * A utility for a one-time read from Firebase.
+   */
+  Backbone.Firebase._readOnce = function(ref, onComplete) {
+    ref.once('value', onComplete);
+  };
+
+  /**
+   * A utility for a destructive save to Firebase.
+   */
+  Backbone.Firebase._setToFirebase = function(ref, item, onComplete) {
+    ref.set(item, onComplete);
+  };
+
+
+  /**
+   * A utility for a non-destructive save to Firebase.
+   */
+  Backbone.Firebase._updateToFirebase = function(ref, item, onComplete) {
+    ref.update(item, onComplete);
+  };
+
+  /**
+   * A utility for success and error events that are called after updates
+   * from Firebase.
+   */
+  Backbone.Firebase._onCompleteCheck = function(err, item, options) {
+    if(!options) { return; }
+
+    if(err && options.error) {
+      options.error(item, err, options);
+    } else if(options.success) {
+      options.success(item, null, options);
+    }
+  };
+
+  /**
+   * A utility for a destructive save to Firebase that handles success and
+   * error events from the server.
+   */
+  Backbone.Firebase._setWithCheck = function(ref, item, options) {
+    Backbone.Firebase._setToFirebase(ref, item, function(err) {
+      Backbone.Firebase._onCompleteCheck(err, item, options);
+    });
+  };
+
+  /**
+   * A utility for a non-destructive save to Firebase that handles success and
+   * error events from the server.
+   */
+  Backbone.Firebase._updateWithCheck = function(ref, item, options) {
+    Backbone.Firebase._updateToFirebase(ref, item, function(err) {
+      Backbone.Firebase._onCompleteCheck(err, item, options);
+    });
+  };
+
+  /**
+   * A utility for throwing errors.
+   */
+  Backbone.Firebase._throwError = function(message) {
+    throw new Error(message);
+  };
+
+
+  /**
+   * A utility for a determining whether a string or a Firebase
+   * reference should be returned.
+   *    string - return new Firebase('')
+   *    object - assume object is ref and return
+   */
+  Backbone.Firebase._determineRef = function(objOrString) {
+    switch (typeof(objOrString)) {
+    case 'string':
+      return new Firebase(objOrString);
+    case 'object':
+      return objOrString;
+    default:
+      Backbone.Firebase._throwError('Invalid type passed to url property');
+    }
+  };
+
+  /**
+   * A utility for assigning an id from a snapshot.
+   *    object    - Assign id from snapshot key
+   *    primitive - Throw error, primitives cannot be synced
+   *    null      - Create blank object and assign id
+   */
+  Backbone.Firebase._checkId = function(snap) {
+    var model = snap.val();
+
+    // if the model is a primitive throw an error
+    if (Backbone.Firebase._isPrimitive(model)) {
+      Backbone.Firebase._throwError('InvalidIdException: Models must have an Id. Note: You may ' +
+      'be trying to sync a primitive value (int, string, bool).');
+    }
+
+    // if the model is null set it to an empty object and assign its id
+    // this way listeners can still be attached to populate the object in the future
+    if(model === null) {
+      model = {};
+    }
+
+    // set the id to the snapshot's key
+    model.id = Backbone.Firebase._getKey(snap);
+
+    return model;
+  };
+
+  /**
+   * A utility for checking if a value is a primitive
+   */
+  Backbone.Firebase._isPrimitive = function(value) {
+    // is the value not an object and not null (basically, is it a primitive?)
+    return !_.isObject(value) && value !== null;
+  };
+
+  /**
+   * A naive promise-like implementation. Requires a syncPromise object.
+   *
+   * syncPromise is an object that has three properties.
+   *  - resolve (bool) - Has the data been retreived from the server?
+   *  - success (bool) - Was the data retrieved successfully?
+   *  - error (Error)  - If there was an error, return the error object.
+   *
+   * This function relies on the syncPromise object being resolved from an
+   * outside source. When the "resolve" property has been set to true,
+   * the "success" and "error" functions will be evaluated.
+   */
+  Backbone.Firebase._promiseEvent = function(params) {
+    // setup default values
+    var syncPromise = params.syncPromise;
+    var success = params.success;
+    var error = params.error;
+    var context = params.context || this;
+    var complete = params.complete;
+
+    // set up an interval that checks to see if data has been synced from the server
+    var promiseInterval = setInterval(_.bind(function() {
+      // if the result has been retrieved from the server
+      if(syncPromise.resolve) {
+
+        // on success fire off the event
+        if(syncPromise.success) {
+          success.call(context);
+        }
+        // on error fire off the returned error
+        else if(syncPromise.err) {
+          error.call(context, syncPromise.err);
+        }
+
+        // fire off the provided completed event
+        if(complete) {
+          complete.call(context);
+        }
+
+        // the "promise" has been resolved, clear the interval
+        clearInterval(promiseInterval);
+      }
+    }, context));
+
+  };
+
+  /**
+   * Model responsible for autoSynced objects
+   * This model is never directly used. The Backbone.Firebase.Model will
+   * inherit from this if it is an autoSynced model
+   */
+  var SyncModel = (function() {
+
+    function SyncModel() {
+      // Set up sync events
+      this._initialSync = {};
+      // apply remote changes locally
+      this.firebase.on('value', function(snap) {
+        this._setLocal(snap);
+        this._initialSync.resolve = true;
+        this._initialSync.success = true;
+        this.trigger('sync', this, null, null);
+      }, function(err) {
+        // indicate that the call has been received from the server
+        // and that an error has occurred
+        this._initialSync.resolve = true;
+        this._initialSync.err = err;
+        this.trigger('error', this, err, null);
+      }, this);
+
+      // apply local changes remotely
+      this._listenLocalChange(function(model) {
+        this.firebase.update(model);
+      });
+
+    }
+
+    SyncModel.protoype = {
+      fetch: function(options) {
+        Backbone.Firebase._promiseEvent({
+          syncPromise: this._initialSync,
+          context: this,
+          success: function() {
+            this.trigger('sync', this, null, options);
+          },
+          error: function(err) {
+            this.trigger('err', this, err, options);
+          },
+          complete: function() {
+            Backbone.Firebase._onCompleteCheck(this._initialSync.err, this, options);
+          }
+        });
+      }
+    };
+
+    return SyncModel;
+  }());
+
+  /**
+   * Model responsible for one-time requests
+   * This model is never directly used. The Backbone.Firebase.Model will
+   * inherit from this if it is an autoSynced model
+   */
+  var OnceModel = (function() {
+
+    function OnceModel() {
+
+      // when an unset occurs set the key to null
+      // so Firebase knows to delete it on the server
+      this._listenLocalChange(function(model) {
+        this.set(model, { silent: true });
+      });
+
+    }
+
+    return OnceModel;
+  }());
+
+  Backbone.Firebase.Model = Backbone.Model.extend({
+
+    // Determine whether the realtime or once methods apply
+    constructor: function(model, options) {
+      Backbone.Model.apply(this, arguments);
+      var defaults = _.result(this, 'defaults');
+
+      // Apply defaults only after first sync.
+      this.once('sync', function() {
+        this.set(_.defaults(this.toJSON(), defaults));
+      });
+
+      this.autoSync = Backbone.Firebase._determineAutoSync(this, options);
+
+      switch (typeof this.url) {
+      case 'string':
+        this.firebase = Backbone.Firebase._determineRef(this.url);
+        break;
+      case 'function':
+        this.firebase = Backbone.Firebase._determineRef(this.url());
+        break;
+      case 'object':
+        this.firebase = Backbone.Firebase._determineRef(this.url);
+        break;
+      default:
+        Backbone.Firebase._throwError('url parameter required');
+      }
+
+      if(!this.autoSync) {
+        OnceModel.apply(this, arguments);
+        _.extend(this, OnceModel.protoype);
+      } else {
+        _.extend(this, SyncModel.protoype);
+        SyncModel.apply(this, arguments);
+      }
+
+    },
+    
+    sync: function(method, model, options) {
+      Backbone.Firebase.sync(method, model, options);
+    },
+
+    /**
+     * Siliently set the id of the model to the snapshot key
+     */
+    _setId: function(snap) {
+      // if the item new set the name to the id
+      if(this.isNew()) {
+        this.set('id', Backbone.Firebase._getKey(snap), { silent: true });
+      }
+    },
+
+    /**
+     * Proccess changes from a snapshot and apply locally
+     */
+    _setLocal: function(snap) {
+      var newModel = this._unsetAttributes(snap);
+      this.set(newModel);
+    },
+
+    /**
+     * Unset attributes that have been deleted from the server
+     * by comparing the keys that have been removed.
+     */
+    _unsetAttributes: function(snap) {
+      var newModel = Backbone.Firebase._checkId(snap);
+
+      if (typeof newModel === 'object' && newModel !== null) {
+        var diff = _.difference(_.keys(this.attributes), _.keys(newModel));
+        _.each(diff, _.bind(function(key) {
+          this.unset(key);
+        }, this));
+      }
+
+      // check to see if it needs an id
+      this._setId(snap);
+
+      return newModel;
+    },
+
+    /**
+     * Find the deleted keys and set their values to null
+     * so Firebase properly deletes them.
+     */
+    _updateModel: function(model) {
+      var modelObj = model.changedAttributes();
+      _.each(model.changed, function(value, key) {
+        if (typeof value === 'undefined' || value === null) {
+          if (key == 'id') {
+            delete modelObj[key];
+          } else {
+            modelObj[key] = null;
+          }
+        }
+      });
+
+      return modelObj;
+    },
+
+
+    /**
+     * Determine if the model will update for every local change.
+     * Provide a callback function to call events after the update.
+     */
+    _listenLocalChange: function(cb) {
+      var method = cb ? 'on' : 'off';
+      this[method]('change', function(model) {
+        var newModel = this._updateModel(model);
+        if(_.isFunction(cb)){
+          cb.call(this, newModel);
+        }
+      }, this);
+    }
+
+  });
+
+  var OnceCollection = (function() {
+    function OnceCollection() {
+
+    }
+    OnceCollection.protoype = {
+      /**
+       * Create an id from a Firebase push-id and call Backbone.create, which
+       * will do prepare the models and trigger the proper events and then call
+       * Backbone.Firebase.sync with the correct method.
+       */
+      create: function(model, options) {
+        model.id = Backbone.Firebase._getKey(this.firebase.push());
+        options = _.extend({ autoSync: false }, options);
+        return Backbone.Collection.prototype.create.call(this, model, options);
+      },
+      /**
+       * Create an id from a Firebase push-id and call Backbone.add, which
+       * will do prepare the models and trigger the proper events and then call
+       * Backbone.Firebase.sync with the correct method.
+       */
+      add: function(model, options) {
+        model.id = Backbone.Firebase._getKey(this.firebase.push());
+        options = _.extend({ autoSync: false }, options);
+        return Backbone.Collection.prototype.add.call(this, model, options);
+      },
+      /**
+       * Proxy to Backbone.Firebase.sync
+       */
+      sync: function(method, model, options) {
+        Backbone.Firebase.sync(method, model, options);
+      },
+      /**
+       * Firebase returns lists as an object with keys, where Backbone
+       * collections require an array. This function modifies the existing
+       * Backbone.Collection.fetch method by mapping the returned object from
+       * Firebase to an array that Backbone can use.
+       */
+      fetch: function(options) {
+        options = options ? _.clone(options) : {};
+        if (options.parse === void 0) { options.parse = true; }
+        var success = options.success;
+        var collection = this;
+        options.success = function(resp) {
+          var arr = [];
+          var keys = _.keys(resp);
+          _.each(keys, function(key) {
+            arr.push(resp[key]);
+          });
+          var method = options.reset ? 'reset' : 'set';
+          collection[method](arr, options);
+          if (success) { success(collection, arr, options); }
+          options.autoSync = false;
+          options.url = this.url;
+          collection.trigger('sync', collection, arr, options);
+        };
+        return this.sync('read', this, options);
+      }
+    };
+
+    return OnceCollection;
+  }());
+
+  var SyncCollection = (function() {
+
+    function SyncCollection() {
+      this._initialSync = {};
+      // Add handlers for remote events
+      this.firebase.on('child_added', _.bind(this._childAdded, this));
+      this.firebase.on('child_moved', _.bind(this._childMoved, this));
+      this.firebase.on('child_changed', _.bind(this._childChanged, this));
+      this.firebase.on('child_removed', _.bind(this._childRemoved, this));
+
+      // Once handler to emit 'sync' event whenever data changes
+      // Defer the listener incase the data is cached, because
+      // then the once call would be synchronous
+      _.defer(_.bind(function() {
+
+        this.firebase.once('value', function() {
+          // indicate that the call has been received from the server
+          // and the data has successfully loaded
+          this._initialSync.resolve = true;
+          this._initialSync.success = true;
+          this.trigger('sync', this, null, null);
+        }, function(err) {
+          // indicate that the call has been received from the server
+          // and that an error has occurred
+          this._initialSync.resolve = true;
+          this._initialSync.err = err;
+          this.trigger('error', this, err, null);
+        }, this);
+
+      }, this));
+
+      // Handle changes in any local models.
+      this.listenTo(this, 'change', this._updateModel, this);
+      // Listen for destroy event to remove models.
+      this.listenTo(this, 'destroy', this._removeModel, this);
+    }
+
+    SyncCollection.protoype = {
+      add: function(models, options) {
+        // prepare models
+        var parsed = this._parseModels(models);
+        options = options ? _.clone(options) : {};
+        options.success =
+          _.isFunction(options.success) ? options.success : function() {};
+
+        for (var i = 0; i < parsed.length; i++) {
+          var model = parsed[i];
+
+          if (options.silent === true) {
+            this._suppressEvent = true;
+          }
+
+          var childRef = this.firebase.ref().child(model.id);
+          childRef.set(model, _.bind(options.success, model));
+        }
+
+        return parsed;
+      },
+
+      create: function(model, options) {
+        options = options ? _.clone(options) : {};
+        if (options.wait) {
+          this._log('Wait option provided to create, ignoring.');
+        }
+        if (!model) {
+          return false;
+        }
+        var set = this.add([model], options);
+        return set[0];
+      },
+
+      remove: function(models, options) {
+        var parsed = this._parseModels(models);
+        options = options ? _.clone(options) : {};
+        options.success =
+          _.isFunction(options.success) ? options.success : function() {};
+
+        for (var i = 0; i < parsed.length; i++) {
+          var model = parsed[i];
+          var childRef = this.firebase.child(model.id);
+          if (options.silent === true) {
+            this._suppressEvent = true;
+          }
+          Backbone.Firebase._setWithCheck(childRef, null, options);
+        }
+
+        return parsed;
+      },
+
+      reset: function(models, options) {
+        options = options ? _.clone(options) : {};
+        // Remove all models remotely.
+        this.remove(this.models, {silent: true});
+        // Add new models.
+        var ret = this.add(models, {silent: true});
+        // Trigger 'reset' event.
+        if (!options.silent) {
+          this.trigger('reset', this, options);
+        }
+        return ret;
+      },
+
+      // This function does not actually fetch data from the server.
+      // Rather, the "sync" event is fired when data has been loaded
+      // from the server. Since the _initialSync property will indicate
+      // whether the initial load has occurred, the "sync" event can
+      // be fired once _initialSync has been resolved.
+      fetch: function(options) {
+        Backbone.Firebase._promiseEvent({
+          syncPromise: this._initialSync,
+          context: this,
+          success: function() {
+            this.trigger('sync', this, null, options);
+          },
+          error: function(err) {
+            this.trigger('err', this, err, options);
+          },
+          complete: function() {
+            Backbone.Firebase._onCompleteCheck(this._initialSync.err, this, options);
+          }
+        });
+      },
+
+      _log: function(msg) {
+        if (console && console.log) {
+          console.log(msg);
+        }
+      },
+
+      _parseModels: function(models, options) {
+        var pushArray = [];
+        // check if the models paramter is an array or a single object
+        var singular = !_.isArray(models);
+        // if the models parameter is a single object then wrap it into an array
+        models = singular ? (models ? [models] : []) : models.slice();
+
+        for (var i = 0; i < models.length; i++) {
+          var model = models[i];
+
+          if (!model.id) {
+            model.id = Backbone.Firebase._getKey(this.firebase.push());
+          }
+
+          // call Backbone's prepareModel to apply options
+          model = Backbone.Collection.prototype._prepareModel.call(
+            this, model, options
+          );
+
+          if (model.toJSON && typeof model.toJSON == 'function') {
+            model = model.toJSON();
+          }
+
+          pushArray.push(model);
+
+        }
+
+        return pushArray;
+      },
+
+      _childAdded: function(snap) {
+        var model = Backbone.Firebase._checkId(snap);
+
+        if (this._suppressEvent === true) {
+          this._suppressEvent = false;
+          Backbone.Collection.prototype.add.call(this, [model], {silent: true});
+        } else {
+          Backbone.Collection.prototype.add.call(this, [model]);
+        }
+        this.get(model.id)._remoteAttributes = model;
+      },
+
+      // TODO: child_moved is emitted when the priority for a child is changed, so it
+      // should update the priority of the model and maybe trigger a sort
+      _childMoved: function() {
+
+      },
+
+      // when a model has changed remotely find differences between the
+      // local and remote data and apply them to the local model
+      _childChanged: function(snap) {
+        var model = Backbone.Firebase._checkId(snap);
+
+        var item = _.find(this.models, function(child) {
+          return child.id == model.id;
+        });
+
+        if (!item) {
+          // TODO: Investigate: what is the right way to handle this case?
+          //throw new Error('Could not find model with ID ' + model.id);
+          this._childAdded(snap);
+          return;
+        }
+
+        this._preventSync(item, true);
+        item._remoteAttributes = model;
+
+        // find the attributes that have been deleted remotely and
+        // unset them locally
+        var diff = _.difference(_.keys(item.attributes), _.keys(model));
+        _.each(diff, function(key) {
+          item.unset(key);
+        });
+
+        item.set(model);
+        // fire sync since this is a response from the server
+        this.trigger('sync', this);
+        this._preventSync(item, false);
+      },
+
+      // remove an item from the collection when removed remotely
+      // provides the ability to remove siliently
+      _childRemoved: function(snap) {
+        var model = Backbone.Firebase._checkId(snap);
+
+        if (this._suppressEvent === true) {
+          this._suppressEvent = false;
+          Backbone.Collection.prototype.remove.call(
+            this, [model], {silent: true}
+          );
+        } else {
+          // trigger sync because data has been received from the server
+          this.trigger('sync', this);
+          Backbone.Collection.prototype.remove.call(this, [model]);
+        }
+      },
+
+      // Add handlers for all models in this collection, and any future ones
+      // that may be added.
+      _updateModel: function(model) {
+        var remoteAttributes;
+        var localAttributes;
+        var updateAttributes;
+        var ref;
+
+        // if the model is already being handled by listeners then return
+        if (model._remoteChanging) {
+          return;
+        }
+
+        remoteAttributes = model._remoteAttributes || {};
+        localAttributes = model.toJSON();
+
+        // consolidate the updates to Firebase
+        updateAttributes = this._compareAttributes(remoteAttributes, localAttributes);
+
+        ref = this.firebase.ref().child(model.id);
+
+        // if '.priority' is present setWithPriority
+        // else do a regular update
+        if (_.has(updateAttributes, '.priority')) {
+          this._setWithPriority(ref, localAttributes);
+        } else {
+          this._updateToFirebase(ref, localAttributes);
+        }
+
+      },
+
+      // set the attributes to be updated to Firebase
+      // set any removed attributes to null so that Firebase removes them
+      _compareAttributes: function(remoteAttributes, localAttributes) {
+        var updateAttributes = {};
+
+        var union = _.union(_.keys(remoteAttributes), _.keys(localAttributes));
+
+        _.each(union, function(key) {
+          if (!_.has(localAttributes, key)) {
+            updateAttributes[key] = null;
+          } else if (localAttributes[key] != remoteAttributes[key]) {
+            updateAttributes[key] = localAttributes[key];
+          }
+        });
+
+        return updateAttributes;
+      },
+
+      // Special case if '.priority' was updated - a merge is not
+      // allowed so we'll have to do a full setWithPriority.
+      _setWithPriority: function(ref, item) {
+        var priority = item['.priority'];
+        delete item['.priority'];
+        ref.setWithPriority(item, priority);
+        return item;
+      },
+
+      // TODO: possibly pass in options for onComplete callback
+      _updateToFirebase: function(ref, item) {
+        ref.update(item);
+      },
+
+      // Triggered when model.destroy() is called on one of the children.
+      _removeModel: function(model, collection, options) {
+        options = options ? _.clone(options) : {};
+        options.success =
+          _.isFunction(options.success) ? options.success : function() {};
+        var childRef = this.firebase.child(model.id);
+        Backbone.Firebase._setWithCheck(childRef, null, _.bind(options.success, model));
+      },
+
+      _preventSync: function(model, state) {
+        model._remoteChanging = state;
+      }
+    };
+
+    return SyncCollection;
+  }());
+
+  Backbone.Firebase.Collection = Backbone.Collection.extend({
+
+    constructor: function (model, options) {
+      Backbone.Collection.apply(this, arguments);
+      var self = this;
+      var BaseModel = self.model;
+      this.autoSync = Backbone.Firebase._determineAutoSync(this, options);
+
+      switch (typeof this.url) {
+      case 'string':
+        this.firebase = Backbone.Firebase._determineRef(this.url);
+        break;
+      case 'function':
+        this.firebase = Backbone.Firebase._determineRef(this.url());
+        break;
+      case 'object':
+        this.firebase = Backbone.Firebase._determineRef(this.url);
+        break;
+      default:
+        throw new Error('url parameter required');
+      }
+
+      // if we are not autoSyncing, the model needs
+      // to be a non-autoSynced model
+      if(!this.autoSync) {
+        _.extend(this, OnceCollection.protoype);
+        OnceCollection.apply(this, arguments);
+      } else {
+        _.extend(this, SyncCollection.protoype);
+        SyncCollection.apply(this, arguments);
+      }
+
+      // Intercept the given model and give it a firebase ref.
+      // Have it listen to local changes silently. When attributes
+      // are unset, the callback will set them to null so that they
+      // are removed on the Firebase server.
+      this.model = function(attrs, opts) {
+
+        var newItem = new BaseModel(attrs, opts);
+        newItem.autoSync = false;
+        newItem.firebase = self.firebase.ref().child(newItem.id);
+        newItem.sync = Backbone.Firebase.sync;
+        newItem.on('change', function(model) {
+          var updated = Backbone.Firebase.Model.prototype._updateModel(model);
+          model.set(updated, { silent: true });
+        });
+
+        return newItem;
+
+      };
+
+    },
+
+    comparator: function(model) {
+      return model.id;
+    }
+
+  });
+
+})(window._, window.Backbone);
diff --git a/dist/backbonefire.min.js b/dist/backbonefire.min.js
new file mode 100644
index 0000000..311952a
--- /dev/null
+++ b/dist/backbonefire.min.js
@@ -0,0 +1,10 @@
+/*!
+ * BackboneFire is the officially supported Backbone binding for Firebase. The
+ * bindings let you use special model and collection types that allow for
+ * synchronizing data with Firebase.
+ *
+ * BackboneFire 0.5.1
+ * https://github.com/firebase/backbonefire/
+ * License: MIT
+ */
+!function(a,b){"use strict";b.Firebase={},b.Firebase._getKey=function(a){return"function"==typeof a.key?a.key():a.name()},b.Firebase._determineAutoSync=function(b,c){var d=Object.getPrototypeOf(b);return a.extend({autoSync:d.hasOwnProperty("autoSync")?d.autoSync:!0},this,c).autoSync},b.Firebase.sync=function(a,c,d){var e=c.toJSON();"read"===a?b.Firebase._readOnce(c.firebase,function(a){var b=a.val();d.success&&d.success(b)},function(a){d.error&&d.error(a)}):"create"===a?b.Firebase._setWithCheck(c.firebase,e,d):"update"===a?b.Firebase._updateWithCheck(c.firebase,e,d):"delete"===a&&b.Firebase._setWithCheck(c.firebase,null,d)},b.Firebase._readOnce=function(a,b){a.once("value",b)},b.Firebase._setToFirebase=function(a,b,c){a.set(b,c)},b.Firebase._updateToFirebase=function(a,b,c){a.update(b,c)},b.Firebase._onCompleteCheck=function(a,b,c){c&&(a&&c.error?c.error(b,a,c):c.success&&c.success(b,null,c))},b.Firebase._setWithCheck=function(a,c,d){b.Firebase._setToFirebase(a,c,function(a){b.Firebase._onCompleteCheck(a,c,d)})},b.Firebase._updateWithCheck=function(a,c,d){b.Firebase._updateToFirebase(a,c,function(a){b.Firebase._onCompleteCheck(a,c,d)})},b.Firebase._throwError=function(a){throw new Error(a)},b.Firebase._determineRef=function(a){switch(typeof a){case"string":return new Firebase(a);case"object":return a;default:b.Firebase._throwError("Invalid type passed to url property")}},b.Firebase._checkId=function(a){var c=a.val();return b.Firebase._isPrimitive(c)&&b.Firebase._throwError("InvalidIdException: Models must have an Id. Note: You may be trying to sync a primitive value (int, string, bool)."),null===c&&(c={}),c.id=b.Firebase._getKey(a),c},b.Firebase._isPrimitive=function(b){return!a.isObject(b)&&null!==b},b.Firebase._promiseEvent=function(b){var c=b.syncPromise,d=b.success,e=b.error,f=b.context||this,g=b.complete,h=setInterval(a.bind(function(){c.resolve&&(c.success?d.call(f):c.err&&e.call(f,c.err),g&&g.call(f),clearInterval(h))},f))};var c=function(){function a(){this._initialSync={},this.firebase.on("value",function(a){this._setLocal(a),this._initialSync.resolve=!0,this._initialSync.success=!0,this.trigger("sync",this,null,null)},function(a){this._initialSync.resolve=!0,this._initialSync.err=a,this.trigger("error",this,a,null)},this),this._listenLocalChange(function(a){this.firebase.update(a)})}return a.protoype={fetch:function(a){b.Firebase._promiseEvent({syncPromise:this._initialSync,context:this,success:function(){this.trigger("sync",this,null,a)},error:function(b){this.trigger("err",this,b,a)},complete:function(){b.Firebase._onCompleteCheck(this._initialSync.err,this,a)}})}},a}(),d=function(){function a(){this._listenLocalChange(function(a){this.set(a,{silent:!0})})}return a}();b.Firebase.Model=b.Model.extend({constructor:function(e,f){b.Model.apply(this,arguments);var g=a.result(this,"defaults");switch(this.once("sync",function(){this.set(a.defaults(this.toJSON(),g))}),this.autoSync=b.Firebase._determineAutoSync(this,f),typeof this.url){case"string":this.firebase=b.Firebase._determineRef(this.url);break;case"function":this.firebase=b.Firebase._determineRef(this.url());break;case"object":this.firebase=b.Firebase._determineRef(this.url);break;default:b.Firebase._throwError("url parameter required")}this.autoSync?(a.extend(this,c.protoype),c.apply(this,arguments)):(d.apply(this,arguments),a.extend(this,d.protoype))},sync:function(a,c,d){b.Firebase.sync(a,c,d)},_setId:function(a){this.isNew()&&this.set("id",b.Firebase._getKey(a),{silent:!0})},_setLocal:function(a){var b=this._unsetAttributes(a);this.set(b)},_unsetAttributes:function(c){var d=b.Firebase._checkId(c);if("object"==typeof d&&null!==d){var e=a.difference(a.keys(this.attributes),a.keys(d));a.each(e,a.bind(function(a){this.unset(a)},this))}return this._setId(c),d},_updateModel:function(b){var c=b.changedAttributes();return a.each(b.changed,function(a,b){("undefined"==typeof a||null===a)&&("id"==b?delete c[b]:c[b]=null)}),c},_listenLocalChange:function(b){var c=b?"on":"off";this[c]("change",function(c){var d=this._updateModel(c);a.isFunction(b)&&b.call(this,d)},this)}});var e=function(){function c(){}return c.protoype={create:function(c,d){return c.id=b.Firebase._getKey(this.firebase.push()),d=a.extend({autoSync:!1},d),b.Collection.prototype.create.call(this,c,d)},add:function(c,d){return c.id=b.Firebase._getKey(this.firebase.push()),d=a.extend({autoSync:!1},d),b.Collection.prototype.add.call(this,c,d)},sync:function(a,c,d){b.Firebase.sync(a,c,d)},fetch:function(b){b=b?a.clone(b):{},void 0===b.parse&&(b.parse=!0);var c=b.success,d=this;return b.success=function(e){var f=[],g=a.keys(e);a.each(g,function(a){f.push(e[a])});var h=b.reset?"reset":"set";d[h](f,b),c&&c(d,f,b),b.autoSync=!1,b.url=this.url,d.trigger("sync",d,f,b)},this.sync("read",this,b)}},c}(),f=function(){function c(){this._initialSync={},this.firebase.on("child_added",a.bind(this._childAdded,this)),this.firebase.on("child_moved",a.bind(this._childMoved,this)),this.firebase.on("child_changed",a.bind(this._childChanged,this)),this.firebase.on("child_removed",a.bind(this._childRemoved,this)),a.defer(a.bind(function(){this.firebase.once("value",function(){this._initialSync.resolve=!0,this._initialSync.success=!0,this.trigger("sync",this,null,null)},function(a){this._initialSync.resolve=!0,this._initialSync.err=a,this.trigger("error",this,a,null)},this)},this)),this.listenTo(this,"change",this._updateModel,this),this.listenTo(this,"destroy",this._removeModel,this)}return c.protoype={add:function(b,c){var d=this._parseModels(b);c=c?a.clone(c):{},c.success=a.isFunction(c.success)?c.success:function(){};for(var e=0;e<d.length;e++){var f=d[e];c.silent===!0&&(this._suppressEvent=!0);var g=this.firebase.ref().child(f.id);g.set(f,a.bind(c.success,f))}return d},create:function(b,c){if(c=c?a.clone(c):{},c.wait&&this._log("Wait option provided to create, ignoring."),!b)return!1;var d=this.add([b],c);return d[0]},remove:function(c,d){var e=this._parseModels(c);d=d?a.clone(d):{},d.success=a.isFunction(d.success)?d.success:function(){};for(var f=0;f<e.length;f++){var g=e[f],h=this.firebase.child(g.id);d.silent===!0&&(this._suppressEvent=!0),b.Firebase._setWithCheck(h,null,d)}return e},reset:function(b,c){c=c?a.clone(c):{},this.remove(this.models,{silent:!0});var d=this.add(b,{silent:!0});return c.silent||this.trigger("reset",this,c),d},fetch:function(a){b.Firebase._promiseEvent({syncPromise:this._initialSync,context:this,success:function(){this.trigger("sync",this,null,a)},error:function(b){this.trigger("err",this,b,a)},complete:function(){b.Firebase._onCompleteCheck(this._initialSync.err,this,a)}})},_log:function(a){console&&console.log&&console.log(a)},_parseModels:function(c,d){var e=[],f=!a.isArray(c);c=f?c?[c]:[]:c.slice();for(var g=0;g<c.length;g++){var h=c[g];h.id||(h.id=b.Firebase._getKey(this.firebase.push())),h=b.Collection.prototype._prepareModel.call(this,h,d),h.toJSON&&"function"==typeof h.toJSON&&(h=h.toJSON()),e.push(h)}return e},_childAdded:function(a){var c=b.Firebase._checkId(a);this._suppressEvent===!0?(this._suppressEvent=!1,b.Collection.prototype.add.call(this,[c],{silent:!0})):b.Collection.prototype.add.call(this,[c]),this.get(c.id)._remoteAttributes=c},_childMoved:function(){},_childChanged:function(c){var d=b.Firebase._checkId(c),e=a.find(this.models,function(a){return a.id==d.id});if(!e)return void this._childAdded(c);this._preventSync(e,!0),e._remoteAttributes=d;var f=a.difference(a.keys(e.attributes),a.keys(d));a.each(f,function(a){e.unset(a)}),e.set(d),this.trigger("sync",this),this._preventSync(e,!1)},_childRemoved:function(a){var c=b.Firebase._checkId(a);this._suppressEvent===!0?(this._suppressEvent=!1,b.Collection.prototype.remove.call(this,[c],{silent:!0})):(this.trigger("sync",this),b.Collection.prototype.remove.call(this,[c]))},_updateModel:function(b){var c,d,e,f;b._remoteChanging||(c=b._remoteAttributes||{},d=b.toJSON(),e=this._compareAttributes(c,d),f=this.firebase.ref().child(b.id),a.has(e,".priority")?this._setWithPriority(f,d):this._updateToFirebase(f,d))},_compareAttributes:function(b,c){var d={},e=a.union(a.keys(b),a.keys(c));return a.each(e,function(e){a.has(c,e)?c[e]!=b[e]&&(d[e]=c[e]):d[e]=null}),d},_setWithPriority:function(a,b){var c=b[".priority"];return delete b[".priority"],a.setWithPriority(b,c),b},_updateToFirebase:function(a,b){a.update(b)},_removeModel:function(c,d,e){e=e?a.clone(e):{},e.success=a.isFunction(e.success)?e.success:function(){};var f=this.firebase.child(c.id);b.Firebase._setWithCheck(f,null,a.bind(e.success,c))},_preventSync:function(a,b){a._remoteChanging=b}},c}();b.Firebase.Collection=b.Collection.extend({constructor:function(c,d){b.Collection.apply(this,arguments);var g=this,h=g.model;switch(this.autoSync=b.Firebase._determineAutoSync(this,d),typeof this.url){case"string":this.firebase=b.Firebase._determineRef(this.url);break;case"function":this.firebase=b.Firebase._determineRef(this.url());break;case"object":this.firebase=b.Firebase._determineRef(this.url);break;default:throw new Error("url parameter required")}this.autoSync?(a.extend(this,f.protoype),f.apply(this,arguments)):(a.extend(this,e.protoype),e.apply(this,arguments)),this.model=function(a,c){var d=new h(a,c);return d.autoSync=!1,d.firebase=g.firebase.ref().child(d.id),d.sync=b.Firebase.sync,d.on("change",function(a){var c=b.Firebase.Model.prototype._updateModel(a);a.set(c,{silent:!0})}),d}},comparator:function(a){return a.id}})}(window._,window.Backbone);
\ No newline at end of file
diff --git a/package.json b/package.json
index 2da174d..cb9f5d9 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "backbonefire",
   "description": "The officially supported Backbone binding for Firebase",
-  "version": "0.0.0",
+  "version": "0.5.1",
   "author": "Firebase <support@firebase.com> (https://www.firebase.com/)",
   "homepage": "https://github.com/firebase/backbonefire/",
   "repository": {