anchor.diff:             (if (getenv "CL_SOURCE_REGISTRY")
                  (strcat (inter-directory-separator) (getenv "CL_SOURCE_REGISTRY"))
                  ;; End with an empty string to tell ASDF to inherit configuration.
  -               (uiop:inter-directory-separator)))))
  -  (asdf:clear-configuration)
  -  (format t "; CL_SOURCE_REGISTRY: ~s~%" (uiop:getenv "CL_SOURCE_REGISTRY")))
  +               (inter-directory-separator)))))
  +  (clear-configuration)
  +  (format t "; CL_SOURCE_REGISTRY: ~s~%" (getenv "CL_SOURCE_REGISTRY")))
   
   (defsystem "nyxt/submodules"
     :perform (compile-op (o c)
  -                       (uiop:run-program `("git"
  -                                           "-C" ,(namestring (system-relative-pathname c ""))
  -                                           "submodule" "update" "--init" "--force"
  -                                           "--jobs" ,(write-to-string *submodules-jobs*))
  -                                         :ignore-error-status t
  -                                         :output t)
  +                       (run-program `("git"
  +                                      "-C" ,(namestring (system-relative-pathname c ""))
  +                                      "submodule" "update" "--init" "--force"
  +                                      "--jobs" ,(write-to-string *submodules-jobs*))
  +                                    :ignore-error-status t
  +                                    :output t)
                          (register-submodules c)))
   
   (defun nyxt-run-test (c path &key network-needed-p)
     (and (or (not network-needed-p)
  -           (not (uiop:getenv "NYXT_TESTS_NO_NETWORK")))
  +           (not (getenv "NYXT_TESTS_NO_NETWORK")))
          (not (funcall (read-from-string "prove:run")
                        (system-relative-pathname c path)))
  -       (uiop:getenv "NYXT_TESTS_ERROR_ON_FAIL")
  -       (uiop:quit 18)))
  +       (getenv "NYXT_TESTS_ERROR_ON_FAIL")
  +       (quit 18)))
   
   ;; TODO: Test that Nyxt starts and that --help, --version work.
   (defsystem "nyxt/tests"
  
positive.code:   :perform (compile-op
              (o c)
              (flet ((ensure-parent-exists (file)
                       (uiop:ensure-all-directories-exist
                        (list (directory-namestring file)))))
                (let ((desktop-file (uiop:merge-pathnames* "applications/nyxt.desktop" *datadir*)))
                  (ensure-parent-exists desktop-file)
                  (uiop:copy-file (system-relative-pathname c "assets/nyxt.desktop")
                                  desktop-file))
                (mapc (lambda (icon-size)
                        (let ((icon-file (format nil "~a/icons/hicolor/~ax~a/apps/nyxt.png"
                                                 *datadir* icon-size icon-size)))
                          (ensure-parent-exists icon-file)
                          (uiop:copy-file (system-relative-pathname
                                           c
                                           (format nil "assets/nyxt_~ax~a.png"
                                                   icon-size icon-size))
                                          icon-file)))
                      '(16 32 128 256 512))
                (let ((binary-file (uiop:merge-pathnames* "nyxt" *bindir*)))
                  (ensure-parent-exists binary-file)
                  (uiop:copy-file (system-relative-pathname c "nyxt") binary-file)
                  ;; TODO: Use iolib/os:file-permissions instead of chmod?  Too verbose?
                  (uiop:run-program (list "chmod" "+x" (uiop:native-namestring binary-file))))
                (let ((source-dir (uiop:merge-pathnames* "nyxt/" *datadir*)))
                  (flet ((copy-directory (source destination)
                           "Copy the content (the file tree) of SOURCE to DESTINATION."
                           (uiop:collect-sub*directories
                            (uiop:ensure-directory-pathname source)
                            (constantly t)
                            t
                            (lambda (subdirectory)
                              (mapc (lambda (file)
                                      (unless (member (pathname-type file) '("o" "fasl") :test 'equalp)
                                        (let ((destination-file
                                                (uiop:merge-pathnames*
                                                 (uiop:subpathp file (uiop:ensure-directory-pathname source))
                                                 (uiop:ensure-pathname destination :truenamize t :ensure-directory t))))
                                          (ensure-parent-exists destination-file)
                                          (uiop:copy-file file destination-file))))
                                    (uiop:directory-files subdirectory))))))
                    (handler-case
                        (progn
                          (dolist (file (cons
                                         ;; Find `libnyxt' file regardless of its extension:
                                         (uiop:subpathp (first (delete-if
                                                                (complement (lambda (file)
                                                                              (uiop:string-prefix-p "libnyxt" (pathname-name file))))
                                                                (uiop:directory-files (asdf:system-relative-pathname
                                                                                       :nyxt "libraries/web-extensions"))))
                                                        (asdf:system-source-directory :nyxt))
                                         (mapcan (lambda (dir)
                                                   (uiop:split-string
                                                    (uiop:run-program `("git" "-C" ,(uiop:native-namestring
                                                                                     (asdf:system-source-directory :nyxt))
                                                                              "ls-files" ,dir)
                                                                      :output '(:string :stripped t))
                                                    :separator '(#\newline #\return #\linefeed)))
                                                 '("source" "libraries"))))
                            (let ((dest (uiop:merge-pathnames* file source-dir)))
                              (ensure-parent-exists dest)
                              (uiop:copy-file (asdf:system-relative-pathname :nyxt file)
                                              dest))))
                      (t ()
                        (dolist (dir '("source" "libraries"))
                          (copy-directory (asdf:system-relative-pathname :nyxt dir)
                                          (uiop:merge-pathnames* dir source-dir)))))
                    (uiop:copy-file (asdf:system-source-file :nyxt) (uiop:merge-pathnames* "nyxt.asd" source-dir)))))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;; Library subsystems:
  
negative.code:   ;; We must set this globally because the information would be lost within a
    ;; Lisp compiler subprocess (e.g. as used by linux-packaging).
    (flet ((ensure-absolute-path (path component)
             (if (absolute-pathname-p path)
                 path
                 (system-relative-pathname component path))))
      (setf (getenv "CL_SOURCE_REGISTRY")
  