             new target_class(options)
 
     # returns a collection for the given association.
-    collectionFor: (name) ->
+    collectionFor: (name, model, options = {}) ->
+        options = _.extend({}, this.getOptions(name, model), options)
         @collections[name] ||= (
-            klass = @getClassFor(name)
-            klass = klass.Collection if true == klass::isModel
-            new klass
+            Klass = @getClassFor(name)
+            if true == Klass::isModel
+                new Lanes.Models.AssociationCollection(options.models || [],
+                    _.extend({}, options, model: Klass)
+                )
+            else
+                new Klass(options.models || [], options)
         )
-
-    # set from collection
-    getModelFromCollection: (model, name, collection) ->
-        throw("#{name} isn't an association") unless _.has(@definitions, name)
-        if not model[name].isNew()
-            return model[name]
-        else
-            id = model[@pk(name)]
-            model = collection.get(id)
-            collection.fetchId(id) if id and not model
-            model
 
     # will be called in the scope of the parent model
     createCollection: (association, name, definition, fk, pk, target_class) ->
         target_class ||= association.getClassFor(name)
-        options = association.getOptions(name, definition, this)
+        options = association.getOptions(name, this)
         options.filter ||= {}
         options.filter[fk] = this.get(pk)
 

        object = definition.model || definition.collection
        Lanes.u.findObject(object, 'Models', @klass::FILE)

    getOptions: (name, definition, model) ->
        options = { parent: model }
        if definition.options
            _.extend(options, Lanes.u.resultsFor(model, definition.options))

            new target_class(options.models || [], options)
        else
            options.model = target_class
            new Lanes.Models.AssociationCollection(options.models || [], options)

    # returns the definition for the derived property
    derivedDefinition: (name, definition) ->
        defaultCreator = if definition.model then this.createModel else this.createCollection
