anchor.diff:    "Load the specified asset from disk using whatever valid loader exist.
   If the optional argument TYPE is provided then NAME is used as the filename to load from.
   Otherwise an asset declaration for the provided NAME is searched. If such a declaration
  -exists then the corresponding asset is loaded, otherwise an error occurs."
  -  (format t "Loading asset ~S~%" name)
  -  (with-resource-manager *content-manager*
  -    (when (existing-resource-p identifier)
  -      (warn "Asset already loaded or identifier conflict for ~A." identifier))
  -    (let* ((pathname (merge-pathnames (if type
  -                                          name
  -                                          (asset-filename (find-asset-declaration name)))
  -                                      *content-directory*))
  -           (loader (%asset-loader (if type type
  -                                      (asset-type (find-asset-declaration name)))
  -                                      pathname)))
  -      (if loader
  -          (use-resource identifier (funcall (asset-loader-load loader) pathname)
  -                        (asset-loader-unload loader))
  -          (error "No asset loader defined for ~S~%" type)))))
  +exists then the corresponding asset is loaded, otherwise an error occurs.
  +If load is called directly with a filename, a new ASSET is created and stored in *ASSETS*."
  +  (let ((asset (if type
  +                   (make-asset :type type :name identifier
  +                               :filename name)
  +                   (find-asset name))))
  +    (unless asset
  +      (error "Invalid asset, can't load."))
  +    ;; FIXME: we need a better way to handle aliases, maybe have support for this
  +    ;; directly at the resource level
  +    (when (asset-alias asset)
  +      (let ((alias (find-asset (asset-alias asset))))
  +        (when alias
  +          (return-from load-asset (load-asset (asset-filename alias)
  +                                              (asset-type alias)
  +                                              (asset-name asset))))))
  +    (format t "Loading ~S asset from ~S as ~S~%" (asset-type asset) (asset-filename asset)
  +            (asset-name asset))
  +    (with-resource-manager *content-manager*
  +      (when (existing-resource-p identifier)
  +        (warn "Asset already loaded or identifier conflict for ~A." identifier))
  +      (let* ((pathname (merge-pathnames (asset-filename asset) *content-directory*))
  +             (loader (%asset-loader (asset-type asset) pathname)))
  +        (if loader
  +            (use-resource identifier (funcall (asset-loader-load loader) pathname)
  +                          (asset-loader-unload loader))
  +            (error "No asset loader defined for ~S~%" type))))))
   
   (defun dispose-asset (identifier)
     "Dispose designated asset regardless of its current users."
  
positive.code: (defvar *assets* nil)
  
  (defstruct asset
    type
    name
    filename
    properties)
  
  (defun find-asset-declaration (name)
    (find-if (lambda (it)
               (equal (asset-name it) name))
             *assets*))
  
negative.code:       (error "No asset loader defined for loading ~S as a ~S~%" filename type))
      loader))
  
  (defun defasset (asset-type extensions load &optional unload)
    "Defines an asset loader for ASSET-TYPE. Extension check will be done upon loading
  against unless EXTENSIONS is :ANY."
    (push (make-asset-loader :load load :unload unload
                             :extensions extensions)
          (gethash asset-type *asset-loaders*)))
  