Add support for ghcjs 8.8 and making ghcjs bundles (#828)

Fixes ghcjs 8.6.5 and 8.8.4. Uses emscripten for ghcjs 8.8 and adds scripts for building ghcjs 8.8. Many fixes for ghcjs test failures. Includes relocatableConfigFiles for making relocatable ghcjs bundles.
2024-09-11 06:55:40 +03:00 · 2020-11-17 22:22:53 +13:00 · 2020-11-17 22:22:53 +13:00 · 7078b145e9
commit 7078b145e9
parent 028eeb1a25
92 changed files with 12836 additions and 136 deletions
--- a/builder/comp-builder.nix
+++ b/builder/comp-builder.nix
@ -163,7 +163,7 @@ let
        ]
    );

-  setupGhcOptions = lib.optional (package.ghcOptions != null) '' --ghc-options="${package.ghcOptions}"'';
+  setupGhcOptions = lib.optional (package.ghcOptions != null) '' --ghc${lib.optionalString (stdenv.hostPlatform.isGhcjs) "js"}-options="${package.ghcOptions}"'';

  executableToolDepends =
    (lib.concatMap (c: if c.isHaskell or false
@ -184,7 +184,7 @@ let
                     else abort "shellHook should be a string or a function";

  exeExt = if stdenv.hostPlatform.isGhcjs then ".jsexe/all.js" else
-    if stdenv.hostPlatform.isWindows then ".exe" else "";
+    stdenv.hostPlatform.extensions.executable;
  exeName = componentId.cname + exeExt;
  testExecutable = "dist/build/${componentId.cname}/${exeName}";

@ -246,6 +246,7 @@ let
      inherit (package) identifier;
      config = component;
      inherit configFiles executableToolDepends cleanSrc exeName;
+      exePath = drv + "/bin/${exeName}";
      env = shellWrappers;
      profiled = self (drvArgs // { enableLibraryProfiling = true; });
    } // lib.optionalAttrs (haskellLib.isLibrary componentId) ({
--- a/builder/default.nix
+++ b/builder/default.nix
@ -78,7 +78,7 @@ in {
    inherit haskellLib ghc comp-builder setup-builder;
  };

-  inherit shellFor;
+  inherit shellFor makeConfigFiles;

  ghcWithPackages = withPackages { withHoogle = false; };
  ghcWithHoogle = withPackages { withHoogle = true; };
--- a/builder/make-config-files.nix
+++ b/builder/make-config-files.nix
@ -56,13 +56,21 @@ let
      (p: "${p.configFiles}")
      libDeps;
    in lib.concatStringsSep "\" \"" xs;
-  libs     = lib.concatMapStringsSep "\" \"" (p: "${p}") libDeps;
-in
-  runCommand "${ghc.targetPrefix}${fullName}-config" {
+  libs = lib.concatMapStringsSep "\" \"" (p: "${p}") libDeps;
+  drv = runCommand "${ghc.targetPrefix}${fullName}-config" {
      nativeBuildInputs = [ghc];
      passthru = {
        inherit (ghc) targetPrefix;
-        inherit ghcCommand ghcCommandCaps libDir packageCfgDir;
+        inherit ghcCommand ghcCommandCaps libDir packageCfgDir component;
+        # Use ''${pkgroot} relative paths so that we can relocate the package database
+        # along with referenced packages and still have it work on systems with
+        # or without nix installed.
+        relocatableConfigFiles = runCommand "${ghc.targetPrefix}${fullName}-relocatable-config" ''
+          cp -r ${drv} $out
+          chmod -R +w $out
+          sed -i 's|/nix/store/|''${pkgroot}/../../../|' $out/${packageCfgDir}/*.conf
+          ${target-pkg} -v0 --package-db $out/${packageCfgDir} recache
+        '';
      };
    } (''
    mkdir -p $out
@ -186,4 +194,5 @@ in
    done
  '' + ''
    ${target-pkg} -v0 --package-db $out/${packageCfgDir} recache
-  '')
+  '');
+in drv
--- a/ci.nix
+++ b/ci.nix
@ -43,7 +43,9 @@
    # We need to use the actual nixpkgs version we're working with here, since the values
    # of 'lib.systems.examples' are not understood between all versions
    let lib = nixpkgs.lib;
-    in lib.optionalAttrs (system == "x86_64-linux" && (nixpkgsName == "R2009" || (compiler-nix-name != "ghc8101" && compiler-nix-name != "ghc8102" && compiler-nix-name != "ghc8102-experimental"))) {
+    in lib.optionalAttrs (nixpkgsName == "R2003" && (__elem compiler-nix-name ["ghc865" "ghc884"])) {
+    inherit (lib.systems.examples) ghcjs;
+  } // lib.optionalAttrs (system == "x86_64-linux" && (nixpkgsName == "R2009" || (!(__elem compiler-nix-name ["ghc8101" "ghc8102" "ghc8102-experimental"])))) {
    # Windows cross compilation is currently broken on macOS
    inherit (lib.systems.examples) mingwW64;
  } // lib.optionalAttrs (system == "x86_64-linux") {
@ -90,7 +92,8 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:
          } // pkgs.lib.optionalAttrs (runTests && crossSystemName != "aarch64-multiplatform") {
            # Tests are broken on aarch64 cross https://github.com/input-output-hk/haskell.nix/issues/513
            inherit (build) tests;
-        }) // pkgs.lib.optionalAttrs (ifdLevel >= 2) {
+        }) // pkgs.lib.optionalAttrs (ifdLevel >= 2 && crossSystemName != "ghcjs") {
+          # GHCJS builds its own template haskell runner.
          remote-iserv = pkgs.ghc-extra-packages."${compiler-nix-name}".remote-iserv.components.exes.remote-iserv;
          iserv-proxy = pkgs.ghc-extra-packages."${compiler-nix-name}".iserv-proxy.components.exes.iserv-proxy;
        } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {
--- a/compiler/ghcjs/ghcjs-src.json
+++ b/compiler/ghcjs/ghcjs-src.json
@ -1,6 +1,6 @@
 {
  "url": "https://github.com/ghcjs/ghcjs",
-  "rev": "e87195eaa2bc7e320e18cf10386802bc90b7c874",
-  "sha256": "02mwkf7aagxqi142gcmq048244apslrr72p568akcab9s0fn2gvy",
+  "rev": "31a54f7320b1f9700eb6389c2eb2d50c712e8371",
+  "sha256": "1cj1gfqcj0ygc23xj5gbm0ym9wmh8ini57zlgd6s25avgjbrwga6",
  "fetchSubmodules": true
 }
--- a/compiler/ghcjs/ghcjs.nix
+++ b/compiler/ghcjs/ghcjs.nix
@ -3,16 +3,18 @@
 , ghcjsSrc ? pkgs.buildPackages.fetchgit (builtins.fromJSON (builtins.readFile ghcjsSrcJson))
 , ghcjsVersion ? "8.6.0.1"
 , ghcVersion ? "8.6.5"
+, compiler-nix-name ? if builtins.compareVersions ghcjsVersion "8.8.0.0" > 0
+  then "ghc884"
+  else "ghc865"
 , ghc ? pkgs.buildPackages.ghc
-, happy ? pkgs.buildPackages.haskellPackages.happy
-, alex ? pkgs.buildPackages.haskellPackages.alex
-, cabal-install ? pkgs.buildPackages.cabal-install
 }:
 let
+    isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" > 0;
+
    project = pkgs.buildPackages.haskell-nix.ghcjsProject {
        src = ghcjsSrc;
-        inherit ghc ghcjsVersion ghcVersion happy alex cabal-install;
-        index-state = "2019-12-10T00:00:00Z";
+        inherit ghcjsVersion compiler-nix-name;
+        index-state = "2020-04-25T00:00:00Z";
 #        plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";
 #        materialized = ../../materialized/ghcjs;
    };
@ -24,21 +26,30 @@ let
        paths = [
            ghcjs.components.exes.ghcjs
            ghcjs.components.exes.ghcjs-pkg
+            ghcjs.components.exes.ghcjs-boot
+            ghcjs.components.exes.ghcjs-dumparchive
+        ] ++ (if isGhcjs88
+          then [
+            ghcjs.components.exes.haddock
+            ghcjs.components.exes.private-ghcjs-run
+            ghcjs.components.exes.private-ghcjs-unlit
+            ghcjs.components.exes.private-ghcjs-hsc2hs
+          ]
+          else [
            ghcjs.components.exes.haddock-ghcjs
            ghcjs.components.exes.hsc2hs-ghcjs
-            ghcjs.components.exes.ghcjs-boot
            ghcjs.components.exes.ghcjs-run
-            ghcjs.components.exes.ghcjs-dumparchive
-        ];
+          ]);
    };
    libexec = "libexec/${builtins.replaceStrings ["darwin" "i686"] ["osx" "i386"] pkgs.stdenv.buildPlatform.system}-${ghc.name}/ghcjs-${ghcVersion}";
    booted-ghcjs = pkgs.stdenv.mkDerivation {
      name = "ghcjs-${ghcVersion}";
      src = project.configured-src;

-      nativeBuildInputs = project.bootInputs;
+      nativeBuildInputs = project.bootInputs
+       ++ pkgs.lib.optional isGhcjs88 pkgs.buildPackages.procps;
      passthru = {
-        inherit all-ghcjs;
+        inherit all-ghcjs bundled-ghcjs project;
        inherit (project) configured-src;
        # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)
        isHaskellNixCompiler = true;
@ -46,23 +57,224 @@ let
      dontConfigure = true;
      dontInstall = true;
      buildPhase = ''
-          export HOME=$TMP
-          mkdir $HOME/.cabal
-          touch $HOME/.cabal/config
-          cd lib/boot
+        export HOME=$TMP
+        mkdir $HOME/.cabal
+        touch $HOME/.cabal/config
+        cd lib/boot
+        ${if isGhcjs88
+          then ''
+            mkdir -p $out/bin
+            mkdir -p $out/lib
+            lndir ${all-ghcjs}/bin $out/bin
+            chmod -R +w $out/bin
+            rm $out/bin/ghcjs-boot
+            cp ${ghcjs.components.exes.ghcjs-boot}/bin/ghcjs-boot $out/bin
+            rm $out/bin/haddock
+            cp ${ghcjs.components.exes.haddock}/bin/haddock $out/bin

-          mkdir -p $out/bin
-          mkdir -p $out/lib/ghcjs-${ghcVersion}
-          lndir ${all-ghcjs}/${libexec} $out/bin
+            wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib"
+            wrapProgram $out/bin/haddock --add-flags "-B$out/lib"
+            wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/package.conf.d"
+          ''
+          else ''
+            mkdir -p $out/bin
+            mkdir -p $out/lib/ghcjs-${ghcVersion}
+            lndir ${all-ghcjs}/${libexec} $out/bin

-          wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib/ghcjs-${ghcVersion}"
-          wrapProgram $out/bin/haddock-ghcjs --add-flags "-B$out/lib/ghcjs-${ghcVersion}"
-          wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/ghcjs-${ghcVersion}/package.conf.d"
-
-          env PATH=$out/bin:$PATH $out/bin/ghcjs-boot -j1 --with-ghcjs-bin $out/bin
+            wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib/ghcjs-${ghcVersion}"
+            wrapProgram $out/bin/haddock-ghcjs --add-flags "-B$out/lib/ghcjs-${ghcVersion}"
+            wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/ghcjs-${ghcVersion}/package.conf.d"
+          ''
+        }
+        # Avoid timeouts while unix package runs hsc2hs (it does not print anything
+        # for more than 900 seconds).
+        {
+        for n in {1..50}; do
+          if [ ! -f $TMP/done ]; then
+            sleep 300
+            echo Keep alive $n
+          fi
+        done
+        } &
+        ${ if isGhcjs88
+          then
+            # Unsets NIX_CFLAGS_COMPILE so the osx version of iconv.h is not used by mistake
+            ''
+            env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \
+              PYTHON=${pkgs.buildPackages.python3}/bin/python3 \
+              $out/bin/ghcjs-boot -j1 --with-emsdk=${project.emsdk} --no-prof --no-haddock \
+              || (echo failed > $TMP/done; false)
+            ''
+          else ''
+            env PATH=$out/bin:$PATH $out/bin/ghcjs-boot -j1 --with-ghcjs-bin $out/bin \
+              || (echo failed > $TMP/done; false)
+          ''
+        }
+        echo ok > $TMP/done
      '';
      # We hard code -j1 as a temporary workaround for
      # https://github.com/ghcjs/ghcjs/issues/654
      # enableParallelBuilding = true;
    };
+    ghcjs-relocatable-bin = pkgs.stdenv.mkDerivation {
+        name = "ghcjs-relocatable-bin-${ghcVersion}";
+        src = all-ghcjs;
+        dontConfigure = true;
+        dontInstall = true;
+        dontPatchShebangs = true;
+        dontPatchELF = true;
+        buildPhase = ''
+            # Copy the ghcjs exectuables
+            mkdir -p $out/bin
+            cp $src/${libexec}/* $out/bin
+
+            # Add readlink (needed by bundleRootDir)
+            cp ${pkgs.coreutils}/bin/readlink $out/bin
+
+          '' + (pkgs.lib.optionalString pkgs.stdenv.isDarwin ''
+            # Make the executables location independent using install_name_tool and @executable_path
+
+            # Copy the libraries needed into place
+            cp ${pkgs.gmp}/lib/libgmp.10.dylib $out/bin
+            cp ${pkgs.ncurses}/lib/libncursesw.6.dylib $out/bin
+            cp ${pkgs.libffi}/lib/libffi.6.dylib $out/bin
+
+            # Set the ID of the libraries
+            chmod -R +w $out/bin
+            install_name_tool -id "@executable_path/libgmp.10.dylib" "$out/bin/libgmp.10.dylib"
+            install_name_tool -id "@executable_path/libncursesw.6.dylib" "$out/bin/libncursesw.6.dylib"
+            install_name_tool -id "@executable_path/libffi.6.dylib" "$out/bin/libffi.6.dylib"
+
+            # Modify all the references so we look for the libraries in the system location or
+            # @executable_path (the directory containin the exetubable itself).
+            for fn in $out/bin/*; do
+              install_name_tool -change "${pkgs.libiconv}/lib/libiconv.dylib" /usr/lib/libiconv.dylib "$fn"
+              install_name_tool -change "${pkgs.stdenv.libc}/lib/libSystem.B.dylib" /usr/lib/libSystem.B.dylib "$fn"
+              install_name_tool -change "${pkgs.gmp}/lib/libgmp.10.dylib" "@executable_path/libgmp.10.dylib" "$fn"
+              install_name_tool -change "${pkgs.ncurses}/lib/libncursesw.6.dylib" "@executable_path/libncursesw.6.dylib" "$fn"
+              install_name_tool -change "${pkgs.libffi}/lib/libffi.6.dylib" "@executable_path/libffi.6.dylib" "$fn"
+            done
+          '')
+
+          + (pkgs.lib.optionalString pkgs.stdenv.isLinux ''
+            # Make the executables location independent using patchelf and $ORIGIN.
+            chmod -R +w $out/bin
+            # This interpreter setting will not work on nixOS, but this bundle is
+            # not really needed on nixOS systems.
+            patchelf --set-interpreter /lib64/ld-linux-x86-64.so.2 $out/bin/*
+            patchelf --set-rpath '$ORIGIN' $out/bin/*
+            # Link the libraries needed into place
+            ln -s ${pkgs.gmp}/lib/libgmp.so.* $out/bin
+            ln -s ${pkgs.ncurses}/lib/libncursesw.so.* $out/bin
+            ln -s ${pkgs.libffi}/lib/libffi.so.* $out/bin
+          '');
+    };
+    # This is a way to find the location of the root directory of this bundle
+    # when one of the wrapper scripts runs.  By using readlink (to avoid
+    # issues with symlinks that might be made to the script) and dirname
+    # we can find the directory even when it may have been moved.
+    bundleRootDir = ''"$(dirname "$(dirname "$(readlink -f "$0")")")"'';
+    bundled-ghcjs = {
+        compilerName ? "ghcjs", # Name for the compiler wrapper
+        db ? null,    # A ghcjs package database this argument should can
+                      # be `project.(shellFor { ... }).configFiles` or
+                      # the result of a `makeConfigFiles` call.
+        hostDb ? null # Like db, but this will be passed as the `-host-package-db`.
+      }:
+      let
+        libDeps = pkgs.lib.concatMapStrings (lib: "${lib} ") (pkgs.lib.unique (
+                 [booted-ghcjs ghc db hostDb pkgs.ncurses pkgs.gmp pkgs.libffi]
+              ++ (pkgs.haskell-nix.haskellLib.flatLibDepends db.component)
+              ++ (pkgs.haskell-nix.haskellLib.flatLibDepends hostDb.component)
+              ));    
+      in pkgs.stdenv.mkDerivation {
+        name = "${compilerName}-${ghcVersion}-bundle";
+        src = booted-ghcjs;
+        nativeBuildInputs = [ pkgs.makeWrapper pkgs.xorg.lndir ];
+        dontConfigure = true;
+        dontInstall = true;
+        dontPatchShebangs = true;
+        dontPatchELF = true;
+        buildPhase = ''
+            # Copy the ghcjs exectuables
+            mkdir -p $out/bin
+            lndir ${ghcjs-relocatable-bin}/bin $out/bin
+
+            # Make the executables writeable for patchelf and install_name_tool
+            chmod -R +w $out/bin
+
+            # And links for the /lib directory of all the dependencies
+            # including the booted ghcjs
+            for lib in ${ libDeps }; do
+              if [ -d $lib/lib ]; then
+                mkdir -p $out/$(basename $lib)
+                lndir -silent $lib $out/$(basename $lib)
+              fi
+            done
+
+          '' + (pkgs.lib.optionalString pkgs.stdenv.isDarwin ''
+            rm -rf $out/$(basename ${hostDb})/lib/links
+            cp -rL ${hostDb}/lib/links $out/$(basename ${hostDb})/lib
+            chmod -R +w $out/$(basename ${hostDb})/lib/links
+
+            # Modify all the references so we look for the libraries in the system location or
+            # @executable_path (the directory containin the exetubable itself).
+            for fn in $out/$(basename ${hostDb})/lib/links/*; do
+              install_name_tool -change "${pkgs.libiconv}/lib/libiconv.dylib" /usr/lib/libiconv.dylib "$fn"
+              install_name_tool -change "${pkgs.stdenv.libc}/lib/libSystem.B.dylib" /usr/lib/libSystem.B.dylib "$fn"
+              install_name_tool -change "${pkgs.gmp}/lib/libgmp.10.dylib" "@executable_path/libgmp.10.dylib" "$fn"
+              install_name_tool -change "${pkgs.ncurses}/lib/libncursesw.6.dylib" "@executable_path/libncursesw.6.dylib" "$fn"
+              install_name_tool -change "${pkgs.libffi}/lib/libffi.6.dylib" "@executable_path/libffi.6.dylib" "$fn"
+            done
+          '') + ''
+
+            # Wrap the programs to add the ghcjs library dir and package DB directories
+            wrapProgram $out/bin/ghcjs \
+              --add-flags '"-B${bundleRootDir}/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}"' \
+              --add-flags '"-package-db ${db}/${db.packageCfgDir}"' ${
+                pkgs.lib.optionalString (hostDb != null)
+                  " --add-flags '-host-package-db=${hostDb}/${hostDb.packageCfgDir}'"
+              }
+            wrapProgram $out/bin/ghcjs-pkg --add-flags '"--global-package-db=${db}/${db.packageCfgDir}"'
+            wrapProgram $out/bin/haddock-ghcjs --add-flags '"-B${bundleRootDir}/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}"'
+
+            # Fix the bang pattern to use the systems bash.
+            # Replace the absolute output path ($out) with bundleRootDir
+            # (this will fix the references to the unwarpped executables).
+            # Replace the `/nix/store` refs (in the package DB paths) with
+            # bundleRootDir.
+            sed -i \
+              -e 's|${pkgs.stdenv.shell}|/usr/bin/env -S bash|' \
+              -e "s|$out/|"'${bundleRootDir}/|g' \
+              -e 's|/nix/store/|${bundleRootDir}/|g' \
+              $out/bin/ghcjs $out/bin/haddock-ghcjs $out/bin/ghcjs-pkg
+
+            # Update the ghcjs and ghc settings files so that `cc` looked up in the PATH.
+            rm $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/settings
+            sed -e 's|/nix/store/.*/bin/cc|cc|' \
+             < ${booted-ghcjs}/lib/ghcjs-${ghcVersion}/settings \
+             > $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/settings
+            rm $out/$(basename ${ghc})/lib/ghc-${ghcVersion}/settings
+            sed -e 's|/nix/store/.*/bin/cc|cc|' \
+             < ${ghc}/lib/ghc-${ghcVersion}/settings \
+             > $out/$(basename ${ghc})/lib/ghc-${ghcVersion}/settings
+
+            # Update the ghcjs settings files so that `node` looked up in the PATH.
+            rm $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/nodeSettings.json
+            sed -e 's|/nix/store/.*/bin/node|node|' \
+             < ${booted-ghcjs}/lib/ghcjs-${ghcVersion}/nodeSettings.json \
+             > $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/nodeSettings.json
+
+            # Update the ghcjs settings files so that `node` looked up in the PATH.
+            rm $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/ghc_libdir
+            sed -e 's|/nix/store/|../../../|' \
+             < ${booted-ghcjs}/lib/ghcjs-${ghcVersion}/ghc_libdir \
+             > $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/ghc_libdir
+          '' + (pkgs.lib.optionalString (compilerName != "ghcjs") ''
+            # Rename the wrappers based on the `compilerName` arg
+            mv $out/bin/ghcjs         $out/bin/${compilerName}
+            mv $out/bin/ghcjs-pkg     $out/bin/${compilerName}-pkg
+            mv $out/bin/haddock-ghcjs $out/bin/haddock-${compilerName}
+          '');
+      };
 in booted-ghcjs
--- a/compiler/ghcjs/ghcjs88-src.json
+++ b/compiler/ghcjs/ghcjs88-src.json
@ -0,0 +1,6 @@
+{
+  "url": "https://github.com/ghcjs/ghcjs",
+  "rev": "1193ead2c760bab1e2ab461458ec771237ccf9b5",
+  "sha256": "1h7gaq1lhf61b5x693phgpm2z0w393b1sbkxrd9mxzz9xxlyrhkl",
+  "fetchSubmodules": true
+}
--- a/lib/call-cabal-project-to-nix.nix
+++ b/lib/call-cabal-project-to-nix.nix
@ -267,6 +267,11 @@ let
    ${ghc.targetPrefix}ghc --info | grep -v /nix/store > $out/ghc/info
    ${ghc.targetPrefix}ghc --supported-languages > $out/ghc/supported-languages
    ${ghc.targetPrefix}ghc-pkg --version > $out/ghc-pkg/version
+    ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-") ''
+      ${ghc.targetPrefix}ghc --numeric-ghc-version > $out/ghc/numeric-ghc-version
+      ${ghc.targetPrefix}ghc --numeric-ghcjs-version > $out/ghc/numeric-ghcjs-version
+      ${ghc.targetPrefix}ghc-pkg --numeric-ghcjs-version > $out/ghc-pkg/numeric-ghcjs-version
+    ''}
    # The order of the `ghc-pkg dump` output seems to be non
    # deterministic so we need to sort it so that it is always
    # the same.
@ -301,6 +306,14 @@ let
        --numeric-version*)
          cat ${dummy-ghc-data}/ghc/numeric-version
          ;;
+      ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-") ''
+        --numeric-ghc-version*)
+          cat ${dummy-ghc-data}/ghc/numeric-ghc-version
+          ;;
+        --numeric-ghcjs-version*)
+          cat ${dummy-ghc-data}/ghc/numeric-ghcjs-version
+          ;;
+      ''}
        --supported-languages*)
          cat ${dummy-ghc-data}/ghc/supported-languages
          ;;
@ -333,6 +346,11 @@ let
        --version)
          cat ${dummy-ghc-data}/ghc-pkg/version
          ;;
+      ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-") ''
+        --numeric-ghcjs-version)
+          cat ${dummy-ghc-data}/ghc-pkg/numeric-ghcjs-version
+          ;;
+      ''}
        'dump --global -v0')
          cat ${dummy-ghc-data}/ghc-pkg/dump-global
          ;;
@ -427,6 +445,8 @@ let
        --with-ghc-pkg=${ghc.targetPrefix}ghc-pkg \
        --enable-tests \
        --enable-benchmarks \
+        ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-")
+            "--ghcjs --with-ghcjs=js-unknown-ghcjs-ghc --with-ghcjs-pkg=js-unknown-ghcjs-ghc-pkg"} \
        ${configureArgs}

    mkdir -p $out
--- a/lib/ghcjs-project.nix
+++ b/lib/ghcjs-project.nix
@ -1,3 +1,7 @@
+# IMPORTANT: This is for building ghcjs, not for building with
+# ghcjs. To build with ghcjs then just replace `haskell-nix`
+# with `pkgsCross.ghcjs.haskell-nix`.
+#
 # For the time being we can't really treat ghcjs like a
 # regular ghc (with different target). We need this as a
 # stop-gap measure until ghcjs can be treated like a regular
@ -17,15 +21,26 @@
 # of the project.
 { pkgs }:
 { src
-, ghc ? pkgs.ghc
-, ghcjsVersion ? "8.6.0.1" # TODO get this from the source?
-, ghcVersion ? "8.6.5"     # TODO get this from the ghc arg?
-, happy ? pkgs.haskellPackages.happy
-, alex ? pkgs.haskellPackages.alex
-, cabal-install ? pkgs.cabal-install
+, compiler-nix-name
+, ghc ? pkgs.buildPackages.haskell-nix.compiler.${compiler-nix-name}
+, ghcjsVersion
+, ghcVersion ? ghc.version
+, happy ? pkgs.haskell-nix.tool compiler-nix-name "happy" {
+    index-state = pkgs.haskell-nix.internalHackageIndexState;
+    version = "1.19.12";
+    materialized = ../materialized/ghcjs/happy + "/${compiler-nix-name}";
+  }
+, alex ? pkgs.haskell-nix.tool compiler-nix-name "alex" {
+    index-state = pkgs.haskell-nix.internalHackageIndexState;
+    version = "3.2.5";
+    materialized = ../materialized/ghcjs/alex + "/${compiler-nix-name}";
+  }
+, cabal-install ? pkgs.haskell-nix.cabal-install.${compiler-nix-name}
 , ...
 }@args:
 let
+    isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" > 0;
+
    # Inputs needed to configure the GHCJS source tree
    configureInputs = with pkgs; [
            perl
@ -38,8 +53,19 @@ let
            alex
            cabal-install
        ];
+    # nixpkgs does not have an emsdk, this derivation uses symlinks to make something
+    # that matches enought for `ghcjs-boot` to work
+    emscriptenupstream = pkgs.buildPackages.emscriptenupstream;
+    emscripten = pkgs.buildPackages.emscripten.override {
+      emscriptenBackend = emscriptenupstream;
+    };
+    emsdk = pkgs.linkFarm "emsdk" [
+      { name = "upstream/bin"; path = emscriptenupstream + "/bin"; }
+      { name = "upstream/emscripten"; path = emscripten + "/bin"; }
+      { name = "share"; path = emscripten + "/share"; }
+    ];
    # Inputs needed to boot the GHCJS compiler
-    bootInputs = with pkgs; [
+    bootInputs = with pkgs.buildPackages; [
            nodejs
            makeWrapper
            xorg.lndir
@ -49,7 +75,8 @@ let
        ++ [ ghc cabal-install ]
        ++ lib.optionals stdenv.isDarwin [
          pkgs.buildPackages.gcc # https://github.com/ghcjs/ghcjs/issues/663
-        ];
+        ]
+        ++ lib.optional isGhcjs88 [ emsdk ];
    # Configured the GHCJS source
    configured-src = pkgs.runCommand "configured-ghcjs-src" {
        buildInputs = configureInputs;
@ -66,31 +93,45 @@ let
        sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac
        sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

-        # TODO: How to actually fix this?
-        # Seems to work fine and produce the right files.
-        touch ghc/includes/ghcautoconf.h
-        mkdir -p ghc/compiler/vectorise
-        mkdir -p ghc/utils/haddock/haddock-library/vendor
+        ${
+          # TODO: How to actually fix this?
+          # Seems to work fine and produce the right files.
+          pkgs.lib.optionalString (!isGhcjs88) ''
+            touch ghc/includes/ghcautoconf.h
+            mkdir -p ghc/compiler/vectorise
+            mkdir -p ghc/utils/haddock/haddock-library/vendor
+          ''
+        }
+
+        rm -rf utils/pkg-cache/ghc
+        cp -r ${ghc.generated} utils/pkg-cache/ghc
+
+        cp ${../overlays/patches/config.sub} ghc/libraries/integer-gmp/config.sub
+        cp ${../overlays/patches/config.sub} ghc/libraries/base/config.sub
+        cp ${../overlays/patches/config.sub} ghc/libraries/unix/config.sub

        patchShebangs .
        sed -i 's/gcc /cc /g' utils/makePackages.sh
-        cat utils/makePackages.sh
        ./utils/makePackages.sh copy

-        echo "    build-tool-depends: alex:alex, happy:happy <= 1.19.9" >> lib/ghc-api-ghcjs/ghc-api-ghcjs.cabal
-
-        # nuke the HsBaseConfig.h from base.buildinfo.in; this will
-        # prevent it from being installed and provide incorrect values.
-        sed -i 's/HsBaseConfig.h//g' lib/boot/pkg/base/base.buildinfo.in
-        cat lib/boot/pkg/base/base.buildinfo.in
-        '';
+        ${
+          # nuke the HsBaseConfig.h from base.buildinfo.in; this will
+          # prevent it from being installed and provide incorrect values.
+          pkgs.lib.optionalString (!isGhcjs88) ''
+            echo "    build-tool-depends: alex:alex, happy:happy <= 1.19.9" >> lib/ghc-api-ghcjs/ghc-api-ghcjs.cabal
+            sed -i 's/HsBaseConfig.h//g' lib/boot/pkg/base/base.buildinfo.in
+          ''
+        }'';
        # see https://github.com/ghcjs/ghcjs/issues/751 for the happy upper bound.

    ghcjsProject = pkgs.haskell-nix.cabalProject' (
        (pkgs.lib.filterAttrs 
-            (n: _: builtins.any (x: x == n)
-                ["src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"]) args) // {
+            (n: _: !(builtins.any (x: x == n)
+                ["src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"])) args) // {
        src = configured-src;
+        compiler-nix-name = if isGhcjs88 then "ghc884" else "ghc865";
+        configureArgs = pkgs.lib.optionalString isGhcjs88 "--constraint='Cabal >=3.0.2.0 && <3.1'";
+        materialized = ../materialized + (if isGhcjs88 then "/ghcjs884" else "/ghcjs865");
        modules = [
            {
                # we need ghc-boot in here for ghcjs.
@ -99,8 +140,10 @@ let
                                         "ghc-boot" "binary" "bytestring" "filepath" "directory" "containers"
                                         "time" "unix" "Win32" ];
            }
-            {
+            (pkgs.lib.optionalAttrs (!isGhcjs88) {
                packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];
+            })
+            {
                packages.ghcjs.doHaddock = false;
                packages.haddock-ghcjs.doHaddock = false;
                packages.haddock-api-ghcjs.doHaddock = false;
@ -114,6 +157,7 @@ let
                packages.ghc.flags.ghci = true;
                packages.ghci.flags.ghci = true;
                # packages.ghcjs.components.library.configureFlags = [ "-fno-wrapper-install" ];
+                packages.ghcjs.components.library.build-tools = [ alex ];
            }
        ];
    });
@ -124,8 +168,9 @@ in ghcjsProject // {
        shellFor = args: (ghcjsProject.hsPkgs.shellFor args).overrideAttrs (drv: {
            buildInputs = (drv.buildInputs or []) ++ configureInputs;
            nativeBuildInputs = (drv.nativeBuildInputs or []) ++ bootInputs;
+            EMSDK = emsdk;
        });
    };
-    inherit configureInputs bootInputs configured-src;
+    inherit configureInputs bootInputs configured-src emscriptenupstream emscripten emsdk;
 }

--- a/lib/system-nixpkgs-map.nix
+++ b/lib/system-nixpkgs-map.nix
@ -2,10 +2,10 @@
 # cabal file to nixpkgs pkgs.
 # See ../docs/dev/pkg-map.md
 pkgs:
-# fetchgit should always come from the buildPackages
+# fetchgit should always come from the evalPackages
 # if it comes from the targetPackages we won't even
 # be able to execute it.
-   { fetchgit = pkgs.buildPackages.fetchgit; }
+   { fetchgit = pkgs.evalPackages.fetchgit; }
 # haskell lib -> nix lib mapping
 # -- linux
 // { crypto = pkgs.openssl;
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc-pkg/dump-global
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc-pkg/dump-global
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc-pkg/numeric-ghcjs-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc-pkg/numeric-ghcjs-version
@ -0,0 +1 @@
+8.6.5
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc-pkg/version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc-pkg/version
@ -0,0 +1 @@
+GHCJS package manager version 8.6.5
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/info
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/info
@ -0,0 +1,58 @@
+ [("Project name","The Glorious Glasgow Haskell Compilation System for JavaScript")
+ ,("Project version","8.6.5")
+ ,("Native Too","NO")
+ ,("GCC extra via C opts"," -fwrapv -fno-builtin")
+ ,("C compiler flags"," -fno-stack-protector")
+ ,("C compiler link flags"," ")
+ ,("C compiler supports -no-pie","NO")
+ ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")
+ ,("ld flags","")
+ ,("ld supports compact unwind","YES")
+ ,("ld supports build-id","NO")
+ ,("ld supports filelist","YES")
+ ,("ld is GNU ld","NO")
+ ,("ar flags","qcls")
+ ,("ar supports at file","NO")
+ ,("touch command","touch")
+ ,("dllwrap command","/bin/false")
+ ,("windres command","/bin/false")
+ ,("libtool command","libtool")
+ ,("cross compiling","NO")
+ ,("target os","OSDarwin")
+ ,("target arch","ArchX86_64")
+ ,("target word size","8")
+ ,("target has GNU nonexec stack","False")
+ ,("target has .ident directive","True")
+ ,("target has subsections via symbols","True")
+ ,("target has RTS linker","YES")
+ ,("Unregisterised","NO")
+ ,("LLVM llc command","llc")
+ ,("LLVM opt command","opt")
+ ,("LLVM clang command","clang")
+ ,("Project Git commit id","9dd298d09697d625bc648c7ff5f5f4241fb56ade")
+ ,("Booter version","8.6.1")
+ ,("Stage","2")
+ ,("Build platform","x86_64-unknown-linux")
+ ,("Host platform","x86_64-unknown-linux")
+ ,("Target platform","x86_64-unknown-linux")
+ ,("Have interpreter","YES")
+ ,("Object splitting supported","YES")
+ ,("Have native code generator","YES")
+ ,("Support SMP","YES")
+ ,("Tables next to code","YES")
+ ,("RTS ways","l debug thr thr_debug thr_l thr_p dyn debug_dyn thr_dyn thr_debug_dyn l_dyn thr_l_dyn")
+ ,("RTS expects libdw","NO")
+ ,("Support dynamic-too","YES")
+ ,("Support parallel --make","YES")
+ ,("Support reexported-modules","YES")
+ ,("Support thinning and renaming package flags","YES")
+ ,("Support Backpack","YES")
+ ,("Requires unified installed package IDs","YES")
+ ,("Uses package keys","YES")
+ ,("Uses unit IDs","YES")
+ ,("Dynamic by default","NO")
+ ,("GHC Dynamic","NO")
+ ,("GHC Profiled","NO")
+ ,("Leading underscore","NO")
+ ,("Debug on","False")
+ ]
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/numeric-ghc-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/numeric-ghc-version
@ -0,0 +1 @@
+8.6.5
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/numeric-ghcjs-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/numeric-ghcjs-version
@ -0,0 +1 @@
+8.6.5
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/numeric-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/numeric-version
@ -0,0 +1 @@
+8.6.5
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/supported-languages
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/supported-languages
@ -0,0 +1,247 @@
+Haskell98
+Haskell2010
+Unsafe
+Trustworthy
+Safe
+AllowAmbiguousTypes
+NoAllowAmbiguousTypes
+AlternativeLayoutRule
+NoAlternativeLayoutRule
+AlternativeLayoutRuleTransitional
+NoAlternativeLayoutRuleTransitional
+Arrows
+NoArrows
+AutoDeriveTypeable
+NoAutoDeriveTypeable
+BangPatterns
+NoBangPatterns
+BinaryLiterals
+NoBinaryLiterals
+CApiFFI
+NoCApiFFI
+CPP
+NoCPP
+ConstrainedClassMethods
+NoConstrainedClassMethods
+ConstraintKinds
+NoConstraintKinds
+DataKinds
+NoDataKinds
+DatatypeContexts
+NoDatatypeContexts
+DefaultSignatures
+NoDefaultSignatures
+DeriveAnyClass
+NoDeriveAnyClass
+DeriveDataTypeable
+NoDeriveDataTypeable
+DeriveFoldable
+NoDeriveFoldable
+DeriveFunctor
+NoDeriveFunctor
+DeriveGeneric
+NoDeriveGeneric
+DeriveLift
+NoDeriveLift
+DeriveTraversable
+NoDeriveTraversable
+DerivingStrategies
+NoDerivingStrategies
+DerivingVia
+NoDerivingVia
+DisambiguateRecordFields
+NoDisambiguateRecordFields
+DoAndIfThenElse
+NoDoAndIfThenElse
+BlockArguments
+NoBlockArguments
+DoRec
+NoDoRec
+DuplicateRecordFields
+NoDuplicateRecordFields
+EmptyCase
+NoEmptyCase
+EmptyDataDecls
+NoEmptyDataDecls
+EmptyDataDeriving
+NoEmptyDataDeriving
+ExistentialQuantification
+NoExistentialQuantification
+ExplicitForAll
+NoExplicitForAll
+ExplicitNamespaces
+NoExplicitNamespaces
+ExtendedDefaultRules
+NoExtendedDefaultRules
+FlexibleContexts
+NoFlexibleContexts
+FlexibleInstances
+NoFlexibleInstances
+ForeignFunctionInterface
+NoForeignFunctionInterface
+FunctionalDependencies
+NoFunctionalDependencies
+GADTSyntax
+NoGADTSyntax
+GADTs
+NoGADTs
+GHCForeignImportPrim
+NoGHCForeignImportPrim
+GeneralizedNewtypeDeriving
+NoGeneralizedNewtypeDeriving
+GeneralisedNewtypeDeriving
+NoGeneralisedNewtypeDeriving
+ImplicitParams
+NoImplicitParams
+ImplicitPrelude
+NoImplicitPrelude
+ImpredicativeTypes
+NoImpredicativeTypes
+IncoherentInstances
+NoIncoherentInstances
+TypeFamilyDependencies
+NoTypeFamilyDependencies
+InstanceSigs
+NoInstanceSigs
+ApplicativeDo
+NoApplicativeDo
+InterruptibleFFI
+NoInterruptibleFFI
+JavaScriptFFI
+NoJavaScriptFFI
+KindSignatures
+NoKindSignatures
+LambdaCase
+NoLambdaCase
+LiberalTypeSynonyms
+NoLiberalTypeSynonyms
+MagicHash
+NoMagicHash
+MonadComprehensions
+NoMonadComprehensions
+MonadFailDesugaring
+NoMonadFailDesugaring
+MonoLocalBinds
+NoMonoLocalBinds
+MonoPatBinds
+NoMonoPatBinds
+MonomorphismRestriction
+NoMonomorphismRestriction
+MultiParamTypeClasses
+NoMultiParamTypeClasses
+MultiWayIf
+NoMultiWayIf
+NumericUnderscores
+NoNumericUnderscores
+NPlusKPatterns
+NoNPlusKPatterns
+NamedFieldPuns
+NoNamedFieldPuns
+NamedWildCards
+NoNamedWildCards
+NegativeLiterals
+NoNegativeLiterals
+HexFloatLiterals
+NoHexFloatLiterals
+NondecreasingIndentation
+NoNondecreasingIndentation
+NullaryTypeClasses
+NoNullaryTypeClasses
+NumDecimals
+NoNumDecimals
+OverlappingInstances
+NoOverlappingInstances
+OverloadedLabels
+NoOverloadedLabels
+OverloadedLists
+NoOverloadedLists
+OverloadedStrings
+NoOverloadedStrings
+PackageImports
+NoPackageImports
+ParallelArrays
+NoParallelArrays
+ParallelListComp
+NoParallelListComp
+PartialTypeSignatures
+NoPartialTypeSignatures
+PatternGuards
+NoPatternGuards
+PatternSignatures
+NoPatternSignatures
+PatternSynonyms
+NoPatternSynonyms
+PolyKinds
+NoPolyKinds
+PolymorphicComponents
+NoPolymorphicComponents
+QuantifiedConstraints
+NoQuantifiedConstraints
+PostfixOperators
+NoPostfixOperators
+QuasiQuotes
+NoQuasiQuotes
+Rank2Types
+NoRank2Types
+RankNTypes
+NoRankNTypes
+RebindableSyntax
+NoRebindableSyntax
+RecordPuns
+NoRecordPuns
+RecordWildCards
+NoRecordWildCards
+RecursiveDo
+NoRecursiveDo
+RelaxedLayout
+NoRelaxedLayout
+RelaxedPolyRec
+NoRelaxedPolyRec
+RoleAnnotations
+NoRoleAnnotations
+ScopedTypeVariables
+NoScopedTypeVariables
+StandaloneDeriving
+NoStandaloneDeriving
+StarIsType
+NoStarIsType
+StaticPointers
+NoStaticPointers
+Strict
+NoStrict
+StrictData
+NoStrictData
+TemplateHaskell
+NoTemplateHaskell
+TemplateHaskellQuotes
+NoTemplateHaskellQuotes
+TraditionalRecordSyntax
+NoTraditionalRecordSyntax
+TransformListComp
+NoTransformListComp
+TupleSections
+NoTupleSections
+TypeApplications
+NoTypeApplications
+TypeInType
+NoTypeInType
+TypeFamilies
+NoTypeFamilies
+TypeOperators
+NoTypeOperators
+TypeSynonymInstances
+NoTypeSynonymInstances
+UnboxedTuples
+NoUnboxedTuples
+UnboxedSums
+NoUnboxedSums
+UndecidableInstances
+NoUndecidableInstances
+UndecidableSuperClasses
+NoUndecidableSuperClasses
+UnicodeSyntax
+NoUnicodeSyntax
+UnliftedFFITypes
+NoUnliftedFFITypes
+ViewPatterns
+NoViewPatterns
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc-pkg/dump-global
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc-pkg/dump-global
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc-pkg/numeric-ghcjs-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc-pkg/numeric-ghcjs-version
@ -0,0 +1 @@
+8.6.5
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc-pkg/version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc-pkg/version
@ -0,0 +1 @@
+GHCJS package manager version 8.6.5
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc/info
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc/info
@ -0,0 +1,58 @@
+ [("Project name","The Glorious Glasgow Haskell Compilation System for JavaScript")
+ ,("Project version","8.6.5")
+ ,("Native Too","NO")
+ ,("GCC extra via C opts"," -fwrapv -fno-builtin")
+ ,("C compiler flags"," -fno-stack-protector")
+ ,("C compiler link flags"," ")
+ ,("C compiler supports -no-pie","YES")
+ ,("Haskell CPP flags","-E -undef -traditional")
+ ,("ld flags","")
+ ,("ld supports compact unwind","YES")
+ ,("ld supports build-id","YES")
+ ,("ld supports filelist","NO")
+ ,("ld is GNU ld","YES")
+ ,("ar flags","q")
+ ,("ar supports at file","YES")
+ ,("touch command","touch")
+ ,("dllwrap command","/bin/false")
+ ,("windres command","/bin/false")
+ ,("libtool command","libtool")
+ ,("cross compiling","NO")
+ ,("target os","OSLinux")
+ ,("target arch","ArchX86_64")
+ ,("target word size","8")
+ ,("target has GNU nonexec stack","True")
+ ,("target has .ident directive","True")
+ ,("target has subsections via symbols","False")
+ ,("target has RTS linker","YES")
+ ,("Unregisterised","NO")
+ ,("LLVM llc command","llc")
+ ,("LLVM opt command","opt")
+ ,("LLVM clang command","clang")
+ ,("Project Git commit id","9dd298d09697d625bc648c7ff5f5f4241fb56ade")
+ ,("Booter version","8.6.1")
+ ,("Stage","2")
+ ,("Build platform","x86_64-unknown-linux")
+ ,("Host platform","x86_64-unknown-linux")
+ ,("Target platform","x86_64-unknown-linux")
+ ,("Have interpreter","YES")
+ ,("Object splitting supported","YES")
+ ,("Have native code generator","YES")
+ ,("Support SMP","YES")
+ ,("Tables next to code","YES")
+ ,("RTS ways","l debug thr thr_debug thr_l thr_p dyn debug_dyn thr_dyn thr_debug_dyn l_dyn thr_l_dyn")
+ ,("RTS expects libdw","NO")
+ ,("Support dynamic-too","YES")
+ ,("Support parallel --make","YES")
+ ,("Support reexported-modules","YES")
+ ,("Support thinning and renaming package flags","YES")
+ ,("Support Backpack","YES")
+ ,("Requires unified installed package IDs","YES")
+ ,("Uses package keys","YES")
+ ,("Uses unit IDs","YES")
+ ,("Dynamic by default","NO")
+ ,("GHC Dynamic","NO")
+ ,("GHC Profiled","NO")
+ ,("Leading underscore","NO")
+ ,("Debug on","False")
+ ]
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc/numeric-ghc-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc/numeric-ghc-version
@ -0,0 +1 @@
+8.6.5
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc/numeric-ghcjs-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc/numeric-ghcjs-version
@ -0,0 +1 @@
+8.6.5
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc/numeric-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc/numeric-version
@ -0,0 +1 @@
+8.6.5
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc/supported-languages
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc/supported-languages
@ -0,0 +1,247 @@
+Haskell98
+Haskell2010
+Unsafe
+Trustworthy
+Safe
+AllowAmbiguousTypes
+NoAllowAmbiguousTypes
+AlternativeLayoutRule
+NoAlternativeLayoutRule
+AlternativeLayoutRuleTransitional
+NoAlternativeLayoutRuleTransitional
+Arrows
+NoArrows
+AutoDeriveTypeable
+NoAutoDeriveTypeable
+BangPatterns
+NoBangPatterns
+BinaryLiterals
+NoBinaryLiterals
+CApiFFI
+NoCApiFFI
+CPP
+NoCPP
+ConstrainedClassMethods
+NoConstrainedClassMethods
+ConstraintKinds
+NoConstraintKinds
+DataKinds
+NoDataKinds
+DatatypeContexts
+NoDatatypeContexts
+DefaultSignatures
+NoDefaultSignatures
+DeriveAnyClass
+NoDeriveAnyClass
+DeriveDataTypeable
+NoDeriveDataTypeable
+DeriveFoldable
+NoDeriveFoldable
+DeriveFunctor
+NoDeriveFunctor
+DeriveGeneric
+NoDeriveGeneric
+DeriveLift
+NoDeriveLift
+DeriveTraversable
+NoDeriveTraversable
+DerivingStrategies
+NoDerivingStrategies
+DerivingVia
+NoDerivingVia
+DisambiguateRecordFields
+NoDisambiguateRecordFields
+DoAndIfThenElse
+NoDoAndIfThenElse
+BlockArguments
+NoBlockArguments
+DoRec
+NoDoRec
+DuplicateRecordFields
+NoDuplicateRecordFields
+EmptyCase
+NoEmptyCase
+EmptyDataDecls
+NoEmptyDataDecls
+EmptyDataDeriving
+NoEmptyDataDeriving
+ExistentialQuantification
+NoExistentialQuantification
+ExplicitForAll
+NoExplicitForAll
+ExplicitNamespaces
+NoExplicitNamespaces
+ExtendedDefaultRules
+NoExtendedDefaultRules
+FlexibleContexts
+NoFlexibleContexts
+FlexibleInstances
+NoFlexibleInstances
+ForeignFunctionInterface
+NoForeignFunctionInterface
+FunctionalDependencies
+NoFunctionalDependencies
+GADTSyntax
+NoGADTSyntax
+GADTs
+NoGADTs
+GHCForeignImportPrim
+NoGHCForeignImportPrim
+GeneralizedNewtypeDeriving
+NoGeneralizedNewtypeDeriving
+GeneralisedNewtypeDeriving
+NoGeneralisedNewtypeDeriving
+ImplicitParams
+NoImplicitParams
+ImplicitPrelude
+NoImplicitPrelude
+ImpredicativeTypes
+NoImpredicativeTypes
+IncoherentInstances
+NoIncoherentInstances
+TypeFamilyDependencies
+NoTypeFamilyDependencies
+InstanceSigs
+NoInstanceSigs
+ApplicativeDo
+NoApplicativeDo
+InterruptibleFFI
+NoInterruptibleFFI
+JavaScriptFFI
+NoJavaScriptFFI
+KindSignatures
+NoKindSignatures
+LambdaCase
+NoLambdaCase
+LiberalTypeSynonyms
+NoLiberalTypeSynonyms
+MagicHash
+NoMagicHash
+MonadComprehensions
+NoMonadComprehensions
+MonadFailDesugaring
+NoMonadFailDesugaring
+MonoLocalBinds
+NoMonoLocalBinds
+MonoPatBinds
+NoMonoPatBinds
+MonomorphismRestriction
+NoMonomorphismRestriction
+MultiParamTypeClasses
+NoMultiParamTypeClasses
+MultiWayIf
+NoMultiWayIf
+NumericUnderscores
+NoNumericUnderscores
+NPlusKPatterns
+NoNPlusKPatterns
+NamedFieldPuns
+NoNamedFieldPuns
+NamedWildCards
+NoNamedWildCards
+NegativeLiterals
+NoNegativeLiterals
+HexFloatLiterals
+NoHexFloatLiterals
+NondecreasingIndentation
+NoNondecreasingIndentation
+NullaryTypeClasses
+NoNullaryTypeClasses
+NumDecimals
+NoNumDecimals
+OverlappingInstances
+NoOverlappingInstances
+OverloadedLabels
+NoOverloadedLabels
+OverloadedLists
+NoOverloadedLists
+OverloadedStrings
+NoOverloadedStrings
+PackageImports
+NoPackageImports
+ParallelArrays
+NoParallelArrays
+ParallelListComp
+NoParallelListComp
+PartialTypeSignatures
+NoPartialTypeSignatures
+PatternGuards
+NoPatternGuards
+PatternSignatures
+NoPatternSignatures
+PatternSynonyms
+NoPatternSynonyms
+PolyKinds
+NoPolyKinds
+PolymorphicComponents
+NoPolymorphicComponents
+QuantifiedConstraints
+NoQuantifiedConstraints
+PostfixOperators
+NoPostfixOperators
+QuasiQuotes
+NoQuasiQuotes
+Rank2Types
+NoRank2Types
+RankNTypes
+NoRankNTypes
+RebindableSyntax
+NoRebindableSyntax
+RecordPuns
+NoRecordPuns
+RecordWildCards
+NoRecordWildCards
+RecursiveDo
+NoRecursiveDo
+RelaxedLayout
+NoRelaxedLayout
+RelaxedPolyRec
+NoRelaxedPolyRec
+RoleAnnotations
+NoRoleAnnotations
+ScopedTypeVariables
+NoScopedTypeVariables
+StandaloneDeriving
+NoStandaloneDeriving
+StarIsType
+NoStarIsType
+StaticPointers
+NoStaticPointers
+Strict
+NoStrict
+StrictData
+NoStrictData
+TemplateHaskell
+NoTemplateHaskell
+TemplateHaskellQuotes
+NoTemplateHaskellQuotes
+TraditionalRecordSyntax
+NoTraditionalRecordSyntax
+TransformListComp
+NoTransformListComp
+TupleSections
+NoTupleSections
+TypeApplications
+NoTypeApplications
+TypeInType
+NoTypeInType
+TypeFamilies
+NoTypeFamilies
+TypeOperators
+NoTypeOperators
+TypeSynonymInstances
+NoTypeSynonymInstances
+UnboxedTuples
+NoUnboxedTuples
+UnboxedSums
+NoUnboxedSums
+UndecidableInstances
+NoUndecidableInstances
+UndecidableSuperClasses
+NoUndecidableSuperClasses
+UnicodeSyntax
+NoUnicodeSyntax
+UnliftedFFITypes
+NoUnliftedFFITypes
+ViewPatterns
+NoViewPatterns
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc/version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc/version
@ -1 +1 @@
-The Glorious Glasgow Haskell Compilation System, version 8.6.5
+The Glorious Glasgow Haskell Compilation System for JavaScript, version 8.6.5 (GHC 8.6.5)
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc-pkg/dump-global
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc-pkg/dump-global
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc-pkg/numeric-ghcjs-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc-pkg/numeric-ghcjs-version
@ -0,0 +1 @@
+8.8.3
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc-pkg/version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc-pkg/version
@ -0,0 +1 @@
+GHCJS package manager version 8.8.1.20200101
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc/info
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc/info
@ -0,0 +1,59 @@
+ [("Project name","The Glorious Glasgow Haskell Compilation System for JavaScript")
+ ,("Project version","8.8.3")
+ ,("GCC extra via C opts"," -fwrapv -fno-builtin")
+ ,("C compiler flags","")
+ ,("C compiler link flags"," ")
+ ,("C compiler supports -no-pie","NO")
+ ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")
+ ,("ld command","ld")
+ ,("ld flags","")
+ ,("ld supports compact unwind","YES")
+ ,("ld supports build-id","NO")
+ ,("ld supports filelist","YES")
+ ,("ld is GNU ld","NO")
+ ,("ar flags","qcls")
+ ,("ar supports at file","NO")
+ ,("touch command","touch")
+ ,("dllwrap command","/bin/false")
+ ,("windres command","/bin/false")
+ ,("libtool command","libtool")
+ ,("perl command","/usr/bin/perl")
+ ,("cross compiling","YES")
+ ,("target os","OSUnknown")
+ ,("target arch","ArchJavaScript")
+ ,("Target platform","wasm32-unknown-none")
+ ,("target word size","4")
+ ,("target has GNU nonexec stack","False")
+ ,("target has .ident directive","True")
+ ,("target has subsections via symbols","True")
+ ,("target has RTS linker","YES")
+ ,("Unregisterised","YES")
+ ,("LLVM llc command","llc")
+ ,("LLVM opt command","opt")
+ ,("LLVM clang command","clang")
+ ,("Project Git commit id","dc8b78fc7ecb616ab535a03b4410f610ef8dd3d0")
+ ,("Booter version","8.6.5")
+ ,("Stage","2")
+ ,("Build platform","x86_64-unknown-linux")
+ ,("Host platform","x86_64-unknown-linux")
+ ,("Have interpreter","YES")
+ ,("Object splitting supported","YES")
+ ,("Have native code generator","YES")
+ ,("Support SMP","YES")
+ ,("Tables next to code","YES")
+ ,("RTS ways","l debug thr thr_debug thr_l thr_p dyn debug_dyn thr_dyn thr_debug_dyn l_dyn thr_l_dyn thr_debug_p debug_p")
+ ,("RTS expects libdw","NO")
+ ,("Support dynamic-too","YES")
+ ,("Support parallel --make","YES")
+ ,("Support reexported-modules","YES")
+ ,("Support thinning and renaming package flags","YES")
+ ,("Support Backpack","YES")
+ ,("Requires unified installed package IDs","YES")
+ ,("Uses package keys","YES")
+ ,("Uses unit IDs","YES")
+ ,("Dynamic by default","NO")
+ ,("GHC Dynamic","NO")
+ ,("GHC Profiled","NO")
+ ,("Leading underscore","NO")
+ ,("Debug on","False")
+ ]
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc/numeric-ghc-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc/numeric-ghc-version
@ -0,0 +1 @@
+8.8.1.20200101
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc/numeric-ghcjs-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc/numeric-ghcjs-version
@ -0,0 +1 @@
+8.8.3
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc/numeric-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc/numeric-version
@ -0,0 +1 @@
+8.8.3
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc/supported-languages
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-darwin/ghc/supported-languages
@ -0,0 +1,247 @@
+Haskell98
+Haskell2010
+Unsafe
+Trustworthy
+Safe
+AllowAmbiguousTypes
+NoAllowAmbiguousTypes
+AlternativeLayoutRule
+NoAlternativeLayoutRule
+AlternativeLayoutRuleTransitional
+NoAlternativeLayoutRuleTransitional
+Arrows
+NoArrows
+AutoDeriveTypeable
+NoAutoDeriveTypeable
+BangPatterns
+NoBangPatterns
+BinaryLiterals
+NoBinaryLiterals
+CApiFFI
+NoCApiFFI
+CPP
+NoCPP
+ConstrainedClassMethods
+NoConstrainedClassMethods
+ConstraintKinds
+NoConstraintKinds
+DataKinds
+NoDataKinds
+DatatypeContexts
+NoDatatypeContexts
+DefaultSignatures
+NoDefaultSignatures
+DeriveAnyClass
+NoDeriveAnyClass
+DeriveDataTypeable
+NoDeriveDataTypeable
+DeriveFoldable
+NoDeriveFoldable
+DeriveFunctor
+NoDeriveFunctor
+DeriveGeneric
+NoDeriveGeneric
+DeriveLift
+NoDeriveLift
+DeriveTraversable
+NoDeriveTraversable
+DerivingStrategies
+NoDerivingStrategies
+DerivingVia
+NoDerivingVia
+DisambiguateRecordFields
+NoDisambiguateRecordFields
+DoAndIfThenElse
+NoDoAndIfThenElse
+BlockArguments
+NoBlockArguments
+DoRec
+NoDoRec
+DuplicateRecordFields
+NoDuplicateRecordFields
+EmptyCase
+NoEmptyCase
+EmptyDataDecls
+NoEmptyDataDecls
+EmptyDataDeriving
+NoEmptyDataDeriving
+ExistentialQuantification
+NoExistentialQuantification
+ExplicitForAll
+NoExplicitForAll
+ExplicitNamespaces
+NoExplicitNamespaces
+ExtendedDefaultRules
+NoExtendedDefaultRules
+FlexibleContexts
+NoFlexibleContexts
+FlexibleInstances
+NoFlexibleInstances
+ForeignFunctionInterface
+NoForeignFunctionInterface
+FunctionalDependencies
+NoFunctionalDependencies
+GADTSyntax
+NoGADTSyntax
+GADTs
+NoGADTs
+GHCForeignImportPrim
+NoGHCForeignImportPrim
+GeneralizedNewtypeDeriving
+NoGeneralizedNewtypeDeriving
+GeneralisedNewtypeDeriving
+NoGeneralisedNewtypeDeriving
+ImplicitParams
+NoImplicitParams
+ImplicitPrelude
+NoImplicitPrelude
+ImpredicativeTypes
+NoImpredicativeTypes
+IncoherentInstances
+NoIncoherentInstances
+TypeFamilyDependencies
+NoTypeFamilyDependencies
+InstanceSigs
+NoInstanceSigs
+ApplicativeDo
+NoApplicativeDo
+InterruptibleFFI
+NoInterruptibleFFI
+JavaScriptFFI
+NoJavaScriptFFI
+KindSignatures
+NoKindSignatures
+LambdaCase
+NoLambdaCase
+LiberalTypeSynonyms
+NoLiberalTypeSynonyms
+MagicHash
+NoMagicHash
+MonadComprehensions
+NoMonadComprehensions
+MonadFailDesugaring
+NoMonadFailDesugaring
+MonoLocalBinds
+NoMonoLocalBinds
+MonoPatBinds
+NoMonoPatBinds
+MonomorphismRestriction
+NoMonomorphismRestriction
+MultiParamTypeClasses
+NoMultiParamTypeClasses
+MultiWayIf
+NoMultiWayIf
+NumericUnderscores
+NoNumericUnderscores
+NPlusKPatterns
+NoNPlusKPatterns
+NamedFieldPuns
+NoNamedFieldPuns
+NamedWildCards
+NoNamedWildCards
+NegativeLiterals
+NoNegativeLiterals
+HexFloatLiterals
+NoHexFloatLiterals
+NondecreasingIndentation
+NoNondecreasingIndentation
+NullaryTypeClasses
+NoNullaryTypeClasses
+NumDecimals
+NoNumDecimals
+OverlappingInstances
+NoOverlappingInstances
+OverloadedLabels
+NoOverloadedLabels
+OverloadedLists
+NoOverloadedLists
+OverloadedStrings
+NoOverloadedStrings
+PackageImports
+NoPackageImports
+ParallelArrays
+NoParallelArrays
+ParallelListComp
+NoParallelListComp
+PartialTypeSignatures
+NoPartialTypeSignatures
+PatternGuards
+NoPatternGuards
+PatternSignatures
+NoPatternSignatures
+PatternSynonyms
+NoPatternSynonyms
+PolyKinds
+NoPolyKinds
+PolymorphicComponents
+NoPolymorphicComponents
+QuantifiedConstraints
+NoQuantifiedConstraints
+PostfixOperators
+NoPostfixOperators
+QuasiQuotes
+NoQuasiQuotes
+Rank2Types
+NoRank2Types
+RankNTypes
+NoRankNTypes
+RebindableSyntax
+NoRebindableSyntax
+RecordPuns
+NoRecordPuns
+RecordWildCards
+NoRecordWildCards
+RecursiveDo
+NoRecursiveDo
+RelaxedLayout
+NoRelaxedLayout
+RelaxedPolyRec
+NoRelaxedPolyRec
+RoleAnnotations
+NoRoleAnnotations
+ScopedTypeVariables
+NoScopedTypeVariables
+StandaloneDeriving
+NoStandaloneDeriving
+StarIsType
+NoStarIsType
+StaticPointers
+NoStaticPointers
+Strict
+NoStrict
+StrictData
+NoStrictData
+TemplateHaskell
+NoTemplateHaskell
+TemplateHaskellQuotes
+NoTemplateHaskellQuotes
+TraditionalRecordSyntax
+NoTraditionalRecordSyntax
+TransformListComp
+NoTransformListComp
+TupleSections
+NoTupleSections
+TypeApplications
+NoTypeApplications
+TypeInType
+NoTypeInType
+TypeFamilies
+NoTypeFamilies
+TypeOperators
+NoTypeOperators
+TypeSynonymInstances
+NoTypeSynonymInstances
+UnboxedTuples
+NoUnboxedTuples
+UnboxedSums
+NoUnboxedSums
+UndecidableInstances
+NoUndecidableInstances
+UndecidableSuperClasses
+NoUndecidableSuperClasses
+UnicodeSyntax
+NoUnicodeSyntax
+UnliftedFFITypes
+NoUnliftedFFITypes
+ViewPatterns
+NoViewPatterns
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc-pkg/dump-global
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc-pkg/dump-global
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc-pkg/numeric-ghcjs-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc-pkg/numeric-ghcjs-version
@ -0,0 +1 @@
+8.8.3
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc-pkg/version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc-pkg/version
@ -0,0 +1 @@
+GHCJS package manager version 8.8.1.20200101
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc/info
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc/info
@ -0,0 +1,59 @@
+ [("Project name","The Glorious Glasgow Haskell Compilation System for JavaScript")
+ ,("Project version","8.8.3")
+ ,("GCC extra via C opts"," -fwrapv -fno-builtin")
+ ,("C compiler flags","")
+ ,("C compiler link flags"," ")
+ ,("C compiler supports -no-pie","NO")
+ ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")
+ ,("ld command","ld")
+ ,("ld flags","")
+ ,("ld supports compact unwind","YES")
+ ,("ld supports build-id","NO")
+ ,("ld supports filelist","YES")
+ ,("ld is GNU ld","NO")
+ ,("ar flags","qcls")
+ ,("ar supports at file","NO")
+ ,("touch command","touch")
+ ,("dllwrap command","/bin/false")
+ ,("windres command","/bin/false")
+ ,("libtool command","libtool")
+ ,("perl command","/usr/bin/perl")
+ ,("cross compiling","YES")
+ ,("target os","OSUnknown")
+ ,("target arch","ArchJavaScript")
+ ,("Target platform","wasm32-unknown-none")
+ ,("target word size","4")
+ ,("target has GNU nonexec stack","False")
+ ,("target has .ident directive","True")
+ ,("target has subsections via symbols","True")
+ ,("target has RTS linker","YES")
+ ,("Unregisterised","YES")
+ ,("LLVM llc command","llc")
+ ,("LLVM opt command","opt")
+ ,("LLVM clang command","clang")
+ ,("Project Git commit id","dc8b78fc7ecb616ab535a03b4410f610ef8dd3d0")
+ ,("Booter version","8.6.5")
+ ,("Stage","2")
+ ,("Build platform","x86_64-unknown-linux")
+ ,("Host platform","x86_64-unknown-linux")
+ ,("Have interpreter","YES")
+ ,("Object splitting supported","YES")
+ ,("Have native code generator","YES")
+ ,("Support SMP","YES")
+ ,("Tables next to code","YES")
+ ,("RTS ways","l debug thr thr_debug thr_l thr_p dyn debug_dyn thr_dyn thr_debug_dyn l_dyn thr_l_dyn thr_debug_p debug_p")
+ ,("RTS expects libdw","NO")
+ ,("Support dynamic-too","YES")
+ ,("Support parallel --make","YES")
+ ,("Support reexported-modules","YES")
+ ,("Support thinning and renaming package flags","YES")
+ ,("Support Backpack","YES")
+ ,("Requires unified installed package IDs","YES")
+ ,("Uses package keys","YES")
+ ,("Uses unit IDs","YES")
+ ,("Dynamic by default","NO")
+ ,("GHC Dynamic","NO")
+ ,("GHC Profiled","NO")
+ ,("Leading underscore","NO")
+ ,("Debug on","False")
+ ]
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc/numeric-ghc-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc/numeric-ghc-version
@ -0,0 +1 @@
+8.8.1.20200101
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc/numeric-ghcjs-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc/numeric-ghcjs-version
@ -0,0 +1 @@
+8.8.3
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc/numeric-version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc/numeric-version
@ -0,0 +1 @@
+8.8.3
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc/supported-languages
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc/supported-languages
@ -0,0 +1,247 @@
+Haskell98
+Haskell2010
+Unsafe
+Trustworthy
+Safe
+AllowAmbiguousTypes
+NoAllowAmbiguousTypes
+AlternativeLayoutRule
+NoAlternativeLayoutRule
+AlternativeLayoutRuleTransitional
+NoAlternativeLayoutRuleTransitional
+Arrows
+NoArrows
+AutoDeriveTypeable
+NoAutoDeriveTypeable
+BangPatterns
+NoBangPatterns
+BinaryLiterals
+NoBinaryLiterals
+CApiFFI
+NoCApiFFI
+CPP
+NoCPP
+ConstrainedClassMethods
+NoConstrainedClassMethods
+ConstraintKinds
+NoConstraintKinds
+DataKinds
+NoDataKinds
+DatatypeContexts
+NoDatatypeContexts
+DefaultSignatures
+NoDefaultSignatures
+DeriveAnyClass
+NoDeriveAnyClass
+DeriveDataTypeable
+NoDeriveDataTypeable
+DeriveFoldable
+NoDeriveFoldable
+DeriveFunctor
+NoDeriveFunctor
+DeriveGeneric
+NoDeriveGeneric
+DeriveLift
+NoDeriveLift
+DeriveTraversable
+NoDeriveTraversable
+DerivingStrategies
+NoDerivingStrategies
+DerivingVia
+NoDerivingVia
+DisambiguateRecordFields
+NoDisambiguateRecordFields
+DoAndIfThenElse
+NoDoAndIfThenElse
+BlockArguments
+NoBlockArguments
+DoRec
+NoDoRec
+DuplicateRecordFields
+NoDuplicateRecordFields
+EmptyCase
+NoEmptyCase
+EmptyDataDecls
+NoEmptyDataDecls
+EmptyDataDeriving
+NoEmptyDataDeriving
+ExistentialQuantification
+NoExistentialQuantification
+ExplicitForAll
+NoExplicitForAll
+ExplicitNamespaces
+NoExplicitNamespaces
+ExtendedDefaultRules
+NoExtendedDefaultRules
+FlexibleContexts
+NoFlexibleContexts
+FlexibleInstances
+NoFlexibleInstances
+ForeignFunctionInterface
+NoForeignFunctionInterface
+FunctionalDependencies
+NoFunctionalDependencies
+GADTSyntax
+NoGADTSyntax
+GADTs
+NoGADTs
+GHCForeignImportPrim
+NoGHCForeignImportPrim
+GeneralizedNewtypeDeriving
+NoGeneralizedNewtypeDeriving
+GeneralisedNewtypeDeriving
+NoGeneralisedNewtypeDeriving
+ImplicitParams
+NoImplicitParams
+ImplicitPrelude
+NoImplicitPrelude
+ImpredicativeTypes
+NoImpredicativeTypes
+IncoherentInstances
+NoIncoherentInstances
+TypeFamilyDependencies
+NoTypeFamilyDependencies
+InstanceSigs
+NoInstanceSigs
+ApplicativeDo
+NoApplicativeDo
+InterruptibleFFI
+NoInterruptibleFFI
+JavaScriptFFI
+NoJavaScriptFFI
+KindSignatures
+NoKindSignatures
+LambdaCase
+NoLambdaCase
+LiberalTypeSynonyms
+NoLiberalTypeSynonyms
+MagicHash
+NoMagicHash
+MonadComprehensions
+NoMonadComprehensions
+MonadFailDesugaring
+NoMonadFailDesugaring
+MonoLocalBinds
+NoMonoLocalBinds
+MonoPatBinds
+NoMonoPatBinds
+MonomorphismRestriction
+NoMonomorphismRestriction
+MultiParamTypeClasses
+NoMultiParamTypeClasses
+MultiWayIf
+NoMultiWayIf
+NumericUnderscores
+NoNumericUnderscores
+NPlusKPatterns
+NoNPlusKPatterns
+NamedFieldPuns
+NoNamedFieldPuns
+NamedWildCards
+NoNamedWildCards
+NegativeLiterals
+NoNegativeLiterals
+HexFloatLiterals
+NoHexFloatLiterals
+NondecreasingIndentation
+NoNondecreasingIndentation
+NullaryTypeClasses
+NoNullaryTypeClasses
+NumDecimals
+NoNumDecimals
+OverlappingInstances
+NoOverlappingInstances
+OverloadedLabels
+NoOverloadedLabels
+OverloadedLists
+NoOverloadedLists
+OverloadedStrings
+NoOverloadedStrings
+PackageImports
+NoPackageImports
+ParallelArrays
+NoParallelArrays
+ParallelListComp
+NoParallelListComp
+PartialTypeSignatures
+NoPartialTypeSignatures
+PatternGuards
+NoPatternGuards
+PatternSignatures
+NoPatternSignatures
+PatternSynonyms
+NoPatternSynonyms
+PolyKinds
+NoPolyKinds
+PolymorphicComponents
+NoPolymorphicComponents
+QuantifiedConstraints
+NoQuantifiedConstraints
+PostfixOperators
+NoPostfixOperators
+QuasiQuotes
+NoQuasiQuotes
+Rank2Types
+NoRank2Types
+RankNTypes
+NoRankNTypes
+RebindableSyntax
+NoRebindableSyntax
+RecordPuns
+NoRecordPuns
+RecordWildCards
+NoRecordWildCards
+RecursiveDo
+NoRecursiveDo
+RelaxedLayout
+NoRelaxedLayout
+RelaxedPolyRec
+NoRelaxedPolyRec
+RoleAnnotations
+NoRoleAnnotations
+ScopedTypeVariables
+NoScopedTypeVariables
+StandaloneDeriving
+NoStandaloneDeriving
+StarIsType
+NoStarIsType
+StaticPointers
+NoStaticPointers
+Strict
+NoStrict
+StrictData
+NoStrictData
+TemplateHaskell
+NoTemplateHaskell
+TemplateHaskellQuotes
+NoTemplateHaskellQuotes
+TraditionalRecordSyntax
+NoTraditionalRecordSyntax
+TransformListComp
+NoTransformListComp
+TupleSections
+NoTupleSections
+TypeApplications
+NoTypeApplications
+TypeInType
+NoTypeInType
+TypeFamilies
+NoTypeFamilies
+TypeOperators
+NoTypeOperators
+TypeSynonymInstances
+NoTypeSynonymInstances
+UnboxedTuples
+NoUnboxedTuples
+UnboxedSums
+NoUnboxedSums
+UndecidableInstances
+NoUndecidableInstances
+UndecidableSuperClasses
+NoUndecidableSuperClasses
+UnicodeSyntax
+NoUnicodeSyntax
+UnliftedFFITypes
+NoUnliftedFFITypes
+ViewPatterns
+NoViewPatterns
--- a/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc/version
+++ b/materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.8.3-x86_64-linux/ghc/version
@ -1 +1 @@
-The Glorious Glasgow Haskell Compilation System, version 8.8.3
+The Glorious Glasgow Haskell Compilation System for JavaScript, version 8.8.3 (GHC 8.8.1.20200101)
--- a/materialized/ghcjs/alex/ghc865/.plan.nix/alex.nix
+++ b/materialized/ghcjs/alex/ghc865/.plan.nix/alex.nix
@ -0,0 +1,160 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = { small_base = true; };
+    package = {
+      specVersion = "1.8";
+      identifier = { name = "alex"; version = "3.2.5"; };
+      license = "BSD-3-Clause";
+      copyright = "(c) Chis Dornan, Simon Marlow";
+      maintainer = "Simon Marlow <marlowsd@gmail.com>";
+      author = "Chris Dornan and Simon Marlow";
+      homepage = "http://www.haskell.org/alex/";
+      url = "";
+      synopsis = "Alex is a tool for generating lexical analysers in Haskell";
+      description = "Alex is a tool for generating lexical analysers in Haskell.\nIt takes a description of tokens based on regular\nexpressions and generates a Haskell module containing code\nfor scanning text efficiently. It is similar to the tool\nlex or flex for C/C++.";
+      buildType = "Simple";
+      isLocal = true;
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "data/";
+      dataFiles = [
+        "AlexTemplate"
+        "AlexTemplate-ghc"
+        "AlexTemplate-ghc-nopred"
+        "AlexTemplate-ghc-debug"
+        "AlexTemplate-debug"
+        "AlexWrapper-basic"
+        "AlexWrapper-basic-bytestring"
+        "AlexWrapper-strict-bytestring"
+        "AlexWrapper-posn"
+        "AlexWrapper-posn-bytestring"
+        "AlexWrapper-monad"
+        "AlexWrapper-monad-bytestring"
+        "AlexWrapper-monadUserState"
+        "AlexWrapper-monadUserState-bytestring"
+        "AlexWrapper-gscan"
+        ];
+      extraSrcFiles = [
+        "CHANGELOG.md"
+        "README.md"
+        "TODO"
+        "alex.spec"
+        "doc/Makefile"
+        "doc/aclocal.m4"
+        "doc/alex.1.in"
+        "doc/alex.xml"
+        "doc/config.mk.in"
+        "doc/configure.ac"
+        "doc/docbook-xml.mk"
+        "doc/fptools.css"
+        "examples/Makefile"
+        "examples/Tokens.x"
+        "examples/Tokens_gscan.x"
+        "examples/Tokens_posn.x"
+        "examples/examples.x"
+        "examples/haskell.x"
+        "examples/lit.x"
+        "examples/pp.x"
+        "examples/state.x"
+        "examples/tiny.y"
+        "examples/words.x"
+        "examples/words_monad.x"
+        "examples/words_posn.x"
+        "src/Parser.y.boot"
+        "src/Scan.x.boot"
+        "src/ghc_hooks.c"
+        "templates/GenericTemplate.hs"
+        "templates/wrappers.hs"
+        "tests/Makefile"
+        "tests/simple.x"
+        "tests/null.x"
+        "tests/tokens.x"
+        "tests/tokens_gscan.x"
+        "tests/tokens_posn.x"
+        "tests/tokens_bytestring.x"
+        "tests/tokens_posn_bytestring.x"
+        "tests/tokens_scan_user.x"
+        "tests/tokens_strict_bytestring.x"
+        "tests/tokens_monad_bytestring.x"
+        "tests/tokens_monadUserState_bytestring.x"
+        "tests/tokens_bytestring_unicode.x"
+        "tests/basic_typeclass.x"
+        "tests/basic_typeclass_bytestring.x"
+        "tests/default_typeclass.x"
+        "tests/gscan_typeclass.x"
+        "tests/posn_typeclass.x"
+        "tests/monad_typeclass.x"
+        "tests/monad_typeclass_bytestring.x"
+        "tests/monadUserState_typeclass.x"
+        "tests/monadUserState_typeclass_bytestring.x"
+        "tests/posn_typeclass_bytestring.x"
+        "tests/strict_typeclass.x"
+        "tests/unicode.x"
+        ];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      exes = {
+        "alex" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            ] ++ (if flags.small_base
+            then [
+              (hsPkgs."base" or (errorHandler.buildDepError "base"))
+              (hsPkgs."array" or (errorHandler.buildDepError "array"))
+              (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+              (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+              ]
+            else [ (hsPkgs."base" or (errorHandler.buildDepError "base")) ]);
+          buildable = true;
+          modules = [
+            "AbsSyn"
+            "CharSet"
+            "DFA"
+            "DFAMin"
+            "DFS"
+            "Info"
+            "Map"
+            "NFA"
+            "Output"
+            "Paths_alex"
+            "Parser"
+            "ParseMonad"
+            "Scan"
+            "Set"
+            "Sort"
+            "Util"
+            "UTF8"
+            "Data/Ranged"
+            "Data/Ranged/Boundaries"
+            "Data/Ranged/RangedSet"
+            "Data/Ranged/Ranges"
+            ];
+          hsSourceDirs = [ "src" ];
+          mainPath = [ "Main.hs" ] ++ [ "" ];
+          };
+        };
+      tests = {
+        "tests" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            ];
+          build-tools = [
+            (hsPkgs.buildPackages.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex")))
+            ];
+          buildable = true;
+          mainPath = [ "test.hs" ];
+          };
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../.; }
--- a/materialized/ghcjs/alex/ghc865/default.nix
+++ b/materialized/ghcjs/alex/ghc865/default.nix
@ -0,0 +1,49 @@
+{
+  pkgs = hackage:
+    {
+      packages = {
+        "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;
+        "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;
+        "rts".revision = (((hackage."rts")."1.0").revisions).default;
+        "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;
+        "directory".revision = (((hackage."directory")."1.3.3.0").revisions).default;
+        "containers".revision = (((hackage."containers")."0.6.0.1").revisions).default;
+        "bytestring".revision = (((hackage."bytestring")."0.10.8.2").revisions).default;
+        "base".revision = (((hackage."base")."4.12.0.0").revisions).default;
+        "time".revision = (((hackage."time")."1.8.0.2").revisions).default;
+        "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;
+        "process".revision = (((hackage."process")."1.6.5.0").revisions).default;
+        "array".revision = (((hackage."array")."0.5.3.0").revisions).default;
+        "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;
+        };
+      compiler = {
+        version = "8.6.5";
+        nix-name = "ghc865";
+        packages = {
+          "ghc-prim" = "0.5.3";
+          "unix" = "2.7.2.2";
+          "rts" = "1.0";
+          "deepseq" = "1.4.4.0";
+          "directory" = "1.3.3.0";
+          "containers" = "0.6.0.1";
+          "bytestring" = "0.10.8.2";
+          "base" = "4.12.0.0";
+          "time" = "1.8.0.2";
+          "filepath" = "1.4.2.1";
+          "process" = "1.6.5.0";
+          "array" = "0.5.3.0";
+          "integer-gmp" = "1.0.2.0";
+          };
+        };
+      };
+  extras = hackage:
+    { packages = { alex = ./.plan.nix/alex.nix; }; };
+  modules = [
+    ({ lib, ... }:
+      {
+        packages = {
+          "alex" = { flags = { "small_base" = lib.mkOverride 900 true; }; };
+          };
+        })
+    ];
+  }
--- a/materialized/ghcjs/alex/ghc884/.plan.nix/alex.nix
+++ b/materialized/ghcjs/alex/ghc884/.plan.nix/alex.nix
@ -0,0 +1,160 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = { small_base = true; };
+    package = {
+      specVersion = "1.8";
+      identifier = { name = "alex"; version = "3.2.5"; };
+      license = "BSD-3-Clause";
+      copyright = "(c) Chis Dornan, Simon Marlow";
+      maintainer = "Simon Marlow <marlowsd@gmail.com>";
+      author = "Chris Dornan and Simon Marlow";
+      homepage = "http://www.haskell.org/alex/";
+      url = "";
+      synopsis = "Alex is a tool for generating lexical analysers in Haskell";
+      description = "Alex is a tool for generating lexical analysers in Haskell.\nIt takes a description of tokens based on regular\nexpressions and generates a Haskell module containing code\nfor scanning text efficiently. It is similar to the tool\nlex or flex for C/C++.";
+      buildType = "Simple";
+      isLocal = true;
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "data/";
+      dataFiles = [
+        "AlexTemplate"
+        "AlexTemplate-ghc"
+        "AlexTemplate-ghc-nopred"
+        "AlexTemplate-ghc-debug"
+        "AlexTemplate-debug"
+        "AlexWrapper-basic"
+        "AlexWrapper-basic-bytestring"
+        "AlexWrapper-strict-bytestring"
+        "AlexWrapper-posn"
+        "AlexWrapper-posn-bytestring"
+        "AlexWrapper-monad"
+        "AlexWrapper-monad-bytestring"
+        "AlexWrapper-monadUserState"
+        "AlexWrapper-monadUserState-bytestring"
+        "AlexWrapper-gscan"
+        ];
+      extraSrcFiles = [
+        "CHANGELOG.md"
+        "README.md"
+        "TODO"
+        "alex.spec"
+        "doc/Makefile"
+        "doc/aclocal.m4"
+        "doc/alex.1.in"
+        "doc/alex.xml"
+        "doc/config.mk.in"
+        "doc/configure.ac"
+        "doc/docbook-xml.mk"
+        "doc/fptools.css"
+        "examples/Makefile"
+        "examples/Tokens.x"
+        "examples/Tokens_gscan.x"
+        "examples/Tokens_posn.x"
+        "examples/examples.x"
+        "examples/haskell.x"
+        "examples/lit.x"
+        "examples/pp.x"
+        "examples/state.x"
+        "examples/tiny.y"
+        "examples/words.x"
+        "examples/words_monad.x"
+        "examples/words_posn.x"
+        "src/Parser.y.boot"
+        "src/Scan.x.boot"
+        "src/ghc_hooks.c"
+        "templates/GenericTemplate.hs"
+        "templates/wrappers.hs"
+        "tests/Makefile"
+        "tests/simple.x"
+        "tests/null.x"
+        "tests/tokens.x"
+        "tests/tokens_gscan.x"
+        "tests/tokens_posn.x"
+        "tests/tokens_bytestring.x"
+        "tests/tokens_posn_bytestring.x"
+        "tests/tokens_scan_user.x"
+        "tests/tokens_strict_bytestring.x"
+        "tests/tokens_monad_bytestring.x"
+        "tests/tokens_monadUserState_bytestring.x"
+        "tests/tokens_bytestring_unicode.x"
+        "tests/basic_typeclass.x"
+        "tests/basic_typeclass_bytestring.x"
+        "tests/default_typeclass.x"
+        "tests/gscan_typeclass.x"
+        "tests/posn_typeclass.x"
+        "tests/monad_typeclass.x"
+        "tests/monad_typeclass_bytestring.x"
+        "tests/monadUserState_typeclass.x"
+        "tests/monadUserState_typeclass_bytestring.x"
+        "tests/posn_typeclass_bytestring.x"
+        "tests/strict_typeclass.x"
+        "tests/unicode.x"
+        ];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      exes = {
+        "alex" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            ] ++ (if flags.small_base
+            then [
+              (hsPkgs."base" or (errorHandler.buildDepError "base"))
+              (hsPkgs."array" or (errorHandler.buildDepError "array"))
+              (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+              (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+              ]
+            else [ (hsPkgs."base" or (errorHandler.buildDepError "base")) ]);
+          buildable = true;
+          modules = [
+            "AbsSyn"
+            "CharSet"
+            "DFA"
+            "DFAMin"
+            "DFS"
+            "Info"
+            "Map"
+            "NFA"
+            "Output"
+            "Paths_alex"
+            "Parser"
+            "ParseMonad"
+            "Scan"
+            "Set"
+            "Sort"
+            "Util"
+            "UTF8"
+            "Data/Ranged"
+            "Data/Ranged/Boundaries"
+            "Data/Ranged/RangedSet"
+            "Data/Ranged/Ranges"
+            ];
+          hsSourceDirs = [ "src" ];
+          mainPath = [ "Main.hs" ] ++ [ "" ];
+          };
+        };
+      tests = {
+        "tests" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            ];
+          build-tools = [
+            (hsPkgs.buildPackages.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex")))
+            ];
+          buildable = true;
+          mainPath = [ "test.hs" ];
+          };
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../.; }
--- a/materialized/ghcjs/alex/ghc884/default.nix
+++ b/materialized/ghcjs/alex/ghc884/default.nix
@ -0,0 +1,49 @@
+{
+  pkgs = hackage:
+    {
+      packages = {
+        "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;
+        "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;
+        "rts".revision = (((hackage."rts")."1.0").revisions).default;
+        "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;
+        "directory".revision = (((hackage."directory")."1.3.6.0").revisions).default;
+        "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;
+        "bytestring".revision = (((hackage."bytestring")."0.10.10.1").revisions).default;
+        "base".revision = (((hackage."base")."4.13.0.0").revisions).default;
+        "time".revision = (((hackage."time")."1.9.3").revisions).default;
+        "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;
+        "process".revision = (((hackage."process")."1.6.9.0").revisions).default;
+        "array".revision = (((hackage."array")."0.5.4.0").revisions).default;
+        "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;
+        };
+      compiler = {
+        version = "8.8.4";
+        nix-name = "ghc884";
+        packages = {
+          "ghc-prim" = "0.5.3";
+          "unix" = "2.7.2.2";
+          "rts" = "1.0";
+          "deepseq" = "1.4.4.0";
+          "directory" = "1.3.6.0";
+          "containers" = "0.6.2.1";
+          "bytestring" = "0.10.10.1";
+          "base" = "4.13.0.0";
+          "time" = "1.9.3";
+          "filepath" = "1.4.2.1";
+          "process" = "1.6.9.0";
+          "array" = "0.5.4.0";
+          "integer-gmp" = "1.0.2.0";
+          };
+        };
+      };
+  extras = hackage:
+    { packages = { alex = ./.plan.nix/alex.nix; }; };
+  modules = [
+    ({ lib, ... }:
+      {
+        packages = {
+          "alex" = { flags = { "small_base" = lib.mkOverride 900 true; }; };
+          };
+        })
+    ];
+  }
--- a/materialized/ghcjs/happy/ghc865/.plan.nix/happy.nix
+++ b/materialized/ghcjs/happy/ghc865/.plan.nix/happy.nix
@ -0,0 +1,200 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = { small_base = true; };
+    package = {
+      specVersion = "1.8";
+      identifier = { name = "happy"; version = "1.19.12"; };
+      license = "BSD-2-Clause";
+      copyright = "(c) Andy Gill, Simon Marlow";
+      maintainer = "Simon Marlow <marlowsd@gmail.com>";
+      author = "Andy Gill and Simon Marlow";
+      homepage = "https://www.haskell.org/happy/";
+      url = "";
+      synopsis = "Happy is a parser generator for Haskell";
+      description = "Happy is a parser generator for Haskell.  Given a grammar\nspecification in BNF, Happy generates Haskell code to parse the\ngrammar.  Happy works in a similar way to the @yacc@ tool for C.";
+      buildType = "Simple";
+      isLocal = true;
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "data/";
+      dataFiles = [
+        "HappyTemplate"
+        "HappyTemplate-arrays"
+        "HappyTemplate-arrays-coerce"
+        "HappyTemplate-arrays-coerce-debug"
+        "HappyTemplate-arrays-debug"
+        "HappyTemplate-arrays-ghc"
+        "HappyTemplate-arrays-ghc-debug"
+        "HappyTemplate-coerce"
+        "HappyTemplate-ghc"
+        "GLR_Base"
+        "GLR_Lib"
+        "GLR_Lib-ghc"
+        "GLR_Lib-ghc-debug"
+        ];
+      extraSrcFiles = [
+        "ANNOUNCE"
+        "CHANGES"
+        "Makefile"
+        "README.md"
+        "TODO"
+        "doc/Makefile"
+        "doc/aclocal.m4"
+        "doc/config.mk.in"
+        "doc/configure.ac"
+        "doc/docbook-xml.mk"
+        "doc/fptools.css"
+        "doc/happy.1.in"
+        "doc/happy.xml"
+        "examples/glr/nlp/Main.lhs"
+        "examples/glr/nlp/Makefile"
+        "examples/glr/nlp/README"
+        "examples/glr/nlp/English.y"
+        "examples/glr/nlp/Hugs.lhs"
+        "examples/glr/Makefile"
+        "examples/glr/Makefile.defs"
+        "examples/glr/expr-eval/Main.lhs"
+        "examples/glr/expr-eval/Makefile"
+        "examples/glr/expr-eval/Expr.y"
+        "examples/glr/expr-eval/README"
+        "examples/glr/expr-eval/Hugs.lhs"
+        "examples/glr/expr-tree/Main.lhs"
+        "examples/glr/expr-tree/Makefile"
+        "examples/glr/expr-tree/Expr.y"
+        "examples/glr/expr-tree/README"
+        "examples/glr/expr-tree/Tree.lhs"
+        "examples/glr/expr-tree/Hugs.lhs"
+        "examples/glr/highly-ambiguous/Main.lhs"
+        "examples/glr/highly-ambiguous/Makefile"
+        "examples/glr/highly-ambiguous/Expr.y"
+        "examples/glr/highly-ambiguous/README"
+        "examples/glr/highly-ambiguous/Hugs.lhs"
+        "examples/glr/hidden-leftrec/Main.lhs"
+        "examples/glr/hidden-leftrec/Makefile"
+        "examples/glr/hidden-leftrec/Expr.y"
+        "examples/glr/hidden-leftrec/README"
+        "examples/glr/hidden-leftrec/Hugs.lhs"
+        "examples/glr/expr-monad/Main.lhs"
+        "examples/glr/expr-monad/Makefile"
+        "examples/glr/expr-monad/Expr.y"
+        "examples/glr/expr-monad/README"
+        "examples/glr/expr-monad/Hugs.lhs"
+        "examples/glr/bio-eg/Main.lhs"
+        "examples/glr/bio-eg/Makefile"
+        "examples/glr/bio-eg/Bio.y"
+        "examples/glr/bio-eg/README"
+        "examples/glr/bio-eg/1-1200.dna"
+        "examples/glr/bio-eg/1-600.dna"
+        "examples/glr/common/DV_lhs"
+        "examples/glr/common/DaVinciTypes.hs"
+        "examples/glr/packing/Main.lhs"
+        "examples/glr/packing/Makefile"
+        "examples/glr/packing/Expr.y"
+        "examples/glr/packing/README"
+        "examples/glr/packing/Hugs.lhs"
+        "examples/PgnParser.ly"
+        "examples/MonadTest.ly"
+        "examples/igloo/ParserM.hs"
+        "examples/igloo/Makefile"
+        "examples/igloo/Parser.y"
+        "examples/igloo/Foo.hs"
+        "examples/igloo/README"
+        "examples/igloo/Lexer.x"
+        "examples/README"
+        "examples/Calc.ly"
+        "examples/DavesExample.ly"
+        "examples/ErrorTest.ly"
+        "examples/ErlParser.ly"
+        "examples/SimonsExample.ly"
+        "examples/LexerTest.ly"
+        "happy.spec"
+        "src/ARRAY-NOTES"
+        "tests/AttrGrammar001.y"
+        "tests/AttrGrammar002.y"
+        "tests/Makefile"
+        "tests/Partial.ly"
+        "tests/Test.ly"
+        "tests/TestMulti.ly"
+        "tests/TestPrecedence.ly"
+        "tests/bogus-token.y"
+        "tests/bug001.ly"
+        "tests/bug002.y"
+        "tests/error001.stderr"
+        "tests/error001.stdout"
+        "tests/error001.y"
+        "tests/monad001.y"
+        "tests/monad002.ly"
+        "tests/monaderror.y"
+        "tests/precedence001.ly"
+        "tests/precedence002.y"
+        "tests/test_rules.y"
+        "tests/issue91.y"
+        "tests/issue93.y"
+        "tests/issue94.y"
+        "tests/issue95.y"
+        "tests/monaderror-explist.y"
+        "tests/typeclass_monad001.y"
+        "tests/typeclass_monad002.ly"
+        "tests/typeclass_monad_lexer.y"
+        "tests/rank2.y"
+        ];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      exes = {
+        "happy" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."array" or (errorHandler.buildDepError "array"))
+            (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+            (hsPkgs."mtl" or (errorHandler.buildDepError "mtl"))
+            ];
+          buildable = true;
+          modules = [
+            "Paths_happy"
+            "AbsSyn"
+            "First"
+            "GenUtils"
+            "Grammar"
+            "Info"
+            "LALR"
+            "Lexer"
+            "ParseMonad"
+            "Parser"
+            "ProduceCode"
+            "ProduceGLRCode"
+            "NameSet"
+            "Target"
+            "AttrGrammar"
+            "AttrGrammarParser"
+            "ParamRules"
+            "PrettyGrammar"
+            ];
+          hsSourceDirs = [ "src" ];
+          mainPath = [ "Main.lhs" ];
+          };
+        };
+      tests = {
+        "tests" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            ];
+          build-tools = [
+            (hsPkgs.buildPackages.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy")))
+            ];
+          buildable = true;
+          mainPath = [ "test.hs" ];
+          };
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../.; }
--- a/materialized/ghcjs/happy/ghc865/default.nix
+++ b/materialized/ghcjs/happy/ghc865/default.nix
@ -0,0 +1,53 @@
+{
+  pkgs = hackage:
+    {
+      packages = {
+        "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;
+        "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;
+        "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;
+        "rts".revision = (((hackage."rts")."1.0").revisions).default;
+        "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;
+        "directory".revision = (((hackage."directory")."1.3.3.0").revisions).default;
+        "containers".revision = (((hackage."containers")."0.6.0.1").revisions).default;
+        "bytestring".revision = (((hackage."bytestring")."0.10.8.2").revisions).default;
+        "base".revision = (((hackage."base")."4.12.0.0").revisions).default;
+        "time".revision = (((hackage."time")."1.8.0.2").revisions).default;
+        "transformers".revision = (((hackage."transformers")."0.5.6.2").revisions).default;
+        "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;
+        "process".revision = (((hackage."process")."1.6.5.0").revisions).default;
+        "array".revision = (((hackage."array")."0.5.3.0").revisions).default;
+        "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;
+        };
+      compiler = {
+        version = "8.6.5";
+        nix-name = "ghc865";
+        packages = {
+          "ghc-prim" = "0.5.3";
+          "unix" = "2.7.2.2";
+          "mtl" = "2.2.2";
+          "rts" = "1.0";
+          "deepseq" = "1.4.4.0";
+          "directory" = "1.3.3.0";
+          "containers" = "0.6.0.1";
+          "bytestring" = "0.10.8.2";
+          "base" = "4.12.0.0";
+          "time" = "1.8.0.2";
+          "transformers" = "0.5.6.2";
+          "filepath" = "1.4.2.1";
+          "process" = "1.6.5.0";
+          "array" = "0.5.3.0";
+          "integer-gmp" = "1.0.2.0";
+          };
+        };
+      };
+  extras = hackage:
+    { packages = { happy = ./.plan.nix/happy.nix; }; };
+  modules = [
+    ({ lib, ... }:
+      {
+        packages = {
+          "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };
+          };
+        })
+    ];
+  }
--- a/materialized/ghcjs/happy/ghc884/.plan.nix/happy.nix
+++ b/materialized/ghcjs/happy/ghc884/.plan.nix/happy.nix
@ -0,0 +1,200 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = { small_base = true; };
+    package = {
+      specVersion = "1.8";
+      identifier = { name = "happy"; version = "1.19.12"; };
+      license = "BSD-2-Clause";
+      copyright = "(c) Andy Gill, Simon Marlow";
+      maintainer = "Simon Marlow <marlowsd@gmail.com>";
+      author = "Andy Gill and Simon Marlow";
+      homepage = "https://www.haskell.org/happy/";
+      url = "";
+      synopsis = "Happy is a parser generator for Haskell";
+      description = "Happy is a parser generator for Haskell.  Given a grammar\nspecification in BNF, Happy generates Haskell code to parse the\ngrammar.  Happy works in a similar way to the @yacc@ tool for C.";
+      buildType = "Simple";
+      isLocal = true;
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "data/";
+      dataFiles = [
+        "HappyTemplate"
+        "HappyTemplate-arrays"
+        "HappyTemplate-arrays-coerce"
+        "HappyTemplate-arrays-coerce-debug"
+        "HappyTemplate-arrays-debug"
+        "HappyTemplate-arrays-ghc"
+        "HappyTemplate-arrays-ghc-debug"
+        "HappyTemplate-coerce"
+        "HappyTemplate-ghc"
+        "GLR_Base"
+        "GLR_Lib"
+        "GLR_Lib-ghc"
+        "GLR_Lib-ghc-debug"
+        ];
+      extraSrcFiles = [
+        "ANNOUNCE"
+        "CHANGES"
+        "Makefile"
+        "README.md"
+        "TODO"
+        "doc/Makefile"
+        "doc/aclocal.m4"
+        "doc/config.mk.in"
+        "doc/configure.ac"
+        "doc/docbook-xml.mk"
+        "doc/fptools.css"
+        "doc/happy.1.in"
+        "doc/happy.xml"
+        "examples/glr/nlp/Main.lhs"
+        "examples/glr/nlp/Makefile"
+        "examples/glr/nlp/README"
+        "examples/glr/nlp/English.y"
+        "examples/glr/nlp/Hugs.lhs"
+        "examples/glr/Makefile"
+        "examples/glr/Makefile.defs"
+        "examples/glr/expr-eval/Main.lhs"
+        "examples/glr/expr-eval/Makefile"
+        "examples/glr/expr-eval/Expr.y"
+        "examples/glr/expr-eval/README"
+        "examples/glr/expr-eval/Hugs.lhs"
+        "examples/glr/expr-tree/Main.lhs"
+        "examples/glr/expr-tree/Makefile"
+        "examples/glr/expr-tree/Expr.y"
+        "examples/glr/expr-tree/README"
+        "examples/glr/expr-tree/Tree.lhs"
+        "examples/glr/expr-tree/Hugs.lhs"
+        "examples/glr/highly-ambiguous/Main.lhs"
+        "examples/glr/highly-ambiguous/Makefile"
+        "examples/glr/highly-ambiguous/Expr.y"
+        "examples/glr/highly-ambiguous/README"
+        "examples/glr/highly-ambiguous/Hugs.lhs"
+        "examples/glr/hidden-leftrec/Main.lhs"
+        "examples/glr/hidden-leftrec/Makefile"
+        "examples/glr/hidden-leftrec/Expr.y"
+        "examples/glr/hidden-leftrec/README"
+        "examples/glr/hidden-leftrec/Hugs.lhs"
+        "examples/glr/expr-monad/Main.lhs"
+        "examples/glr/expr-monad/Makefile"
+        "examples/glr/expr-monad/Expr.y"
+        "examples/glr/expr-monad/README"
+        "examples/glr/expr-monad/Hugs.lhs"
+        "examples/glr/bio-eg/Main.lhs"
+        "examples/glr/bio-eg/Makefile"
+        "examples/glr/bio-eg/Bio.y"
+        "examples/glr/bio-eg/README"
+        "examples/glr/bio-eg/1-1200.dna"
+        "examples/glr/bio-eg/1-600.dna"
+        "examples/glr/common/DV_lhs"
+        "examples/glr/common/DaVinciTypes.hs"
+        "examples/glr/packing/Main.lhs"
+        "examples/glr/packing/Makefile"
+        "examples/glr/packing/Expr.y"
+        "examples/glr/packing/README"
+        "examples/glr/packing/Hugs.lhs"
+        "examples/PgnParser.ly"
+        "examples/MonadTest.ly"
+        "examples/igloo/ParserM.hs"
+        "examples/igloo/Makefile"
+        "examples/igloo/Parser.y"
+        "examples/igloo/Foo.hs"
+        "examples/igloo/README"
+        "examples/igloo/Lexer.x"
+        "examples/README"
+        "examples/Calc.ly"
+        "examples/DavesExample.ly"
+        "examples/ErrorTest.ly"
+        "examples/ErlParser.ly"
+        "examples/SimonsExample.ly"
+        "examples/LexerTest.ly"
+        "happy.spec"
+        "src/ARRAY-NOTES"
+        "tests/AttrGrammar001.y"
+        "tests/AttrGrammar002.y"
+        "tests/Makefile"
+        "tests/Partial.ly"
+        "tests/Test.ly"
+        "tests/TestMulti.ly"
+        "tests/TestPrecedence.ly"
+        "tests/bogus-token.y"
+        "tests/bug001.ly"
+        "tests/bug002.y"
+        "tests/error001.stderr"
+        "tests/error001.stdout"
+        "tests/error001.y"
+        "tests/monad001.y"
+        "tests/monad002.ly"
+        "tests/monaderror.y"
+        "tests/precedence001.ly"
+        "tests/precedence002.y"
+        "tests/test_rules.y"
+        "tests/issue91.y"
+        "tests/issue93.y"
+        "tests/issue94.y"
+        "tests/issue95.y"
+        "tests/monaderror-explist.y"
+        "tests/typeclass_monad001.y"
+        "tests/typeclass_monad002.ly"
+        "tests/typeclass_monad_lexer.y"
+        "tests/rank2.y"
+        ];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      exes = {
+        "happy" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."array" or (errorHandler.buildDepError "array"))
+            (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+            (hsPkgs."mtl" or (errorHandler.buildDepError "mtl"))
+            ];
+          buildable = true;
+          modules = [
+            "Paths_happy"
+            "AbsSyn"
+            "First"
+            "GenUtils"
+            "Grammar"
+            "Info"
+            "LALR"
+            "Lexer"
+            "ParseMonad"
+            "Parser"
+            "ProduceCode"
+            "ProduceGLRCode"
+            "NameSet"
+            "Target"
+            "AttrGrammar"
+            "AttrGrammarParser"
+            "ParamRules"
+            "PrettyGrammar"
+            ];
+          hsSourceDirs = [ "src" ];
+          mainPath = [ "Main.lhs" ];
+          };
+        };
+      tests = {
+        "tests" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            ];
+          build-tools = [
+            (hsPkgs.buildPackages.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy")))
+            ];
+          buildable = true;
+          mainPath = [ "test.hs" ];
+          };
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../.; }
--- a/materialized/ghcjs/happy/ghc884/default.nix
+++ b/materialized/ghcjs/happy/ghc884/default.nix
@ -0,0 +1,53 @@
+{
+  pkgs = hackage:
+    {
+      packages = {
+        "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;
+        "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;
+        "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;
+        "rts".revision = (((hackage."rts")."1.0").revisions).default;
+        "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;
+        "directory".revision = (((hackage."directory")."1.3.6.0").revisions).default;
+        "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;
+        "bytestring".revision = (((hackage."bytestring")."0.10.10.1").revisions).default;
+        "base".revision = (((hackage."base")."4.13.0.0").revisions).default;
+        "time".revision = (((hackage."time")."1.9.3").revisions).default;
+        "transformers".revision = (((hackage."transformers")."0.5.6.2").revisions).default;
+        "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;
+        "process".revision = (((hackage."process")."1.6.9.0").revisions).default;
+        "array".revision = (((hackage."array")."0.5.4.0").revisions).default;
+        "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;
+        };
+      compiler = {
+        version = "8.8.4";
+        nix-name = "ghc884";
+        packages = {
+          "ghc-prim" = "0.5.3";
+          "unix" = "2.7.2.2";
+          "mtl" = "2.2.2";
+          "rts" = "1.0";
+          "deepseq" = "1.4.4.0";
+          "directory" = "1.3.6.0";
+          "containers" = "0.6.2.1";
+          "bytestring" = "0.10.10.1";
+          "base" = "4.13.0.0";
+          "time" = "1.9.3";
+          "transformers" = "0.5.6.2";
+          "filepath" = "1.4.2.1";
+          "process" = "1.6.9.0";
+          "array" = "0.5.4.0";
+          "integer-gmp" = "1.0.2.0";
+          };
+        };
+      };
+  extras = hackage:
+    { packages = { happy = ./.plan.nix/happy.nix; }; };
+  modules = [
+    ({ lib, ... }:
+      {
+        packages = {
+          "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };
+          };
+        })
+    ];
+  }
--- a/materialized/ghcjs865/.plan.nix/ghc-api-ghcjs.nix
+++ b/materialized/ghcjs865/.plan.nix/ghc-api-ghcjs.nix
@ -0,0 +1,589 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = {
+      debug = false;
+      ghci = true;
+      stage1 = false;
+      stage2 = true;
+      stage3 = false;
+      terminfo = true;
+      use-host-template-haskell = false;
+      };
+    package = {
+      specVersion = "2.0";
+      identifier = { name = "ghc-api-ghcjs"; version = "8.6.5"; };
+      license = "BSD-3-Clause";
+      copyright = "";
+      maintainer = "glasgow-haskell-users@haskell.org";
+      author = "The GHC Team";
+      homepage = "http://www.haskell.org/ghc/";
+      url = "";
+      synopsis = "The GHC API (customized for GHCJS)";
+      description = "GHC's functionality can be useful for more things than just\ncompiling Haskell programs. Important use cases are programs\nthat analyse (and perhaps transform) Haskell code. Others\ninclude loading Haskell code dynamically in a GHCi-like manner.\nFor this reason, a lot of GHC's functionality is made available\nthrough this package.";
+      buildType = "Simple";
+      isLocal = true;
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "";
+      dataFiles = [];
+      extraSrcFiles = [
+        "compiler/utils/md5.h"
+        "compiler/Unique.h"
+        "compiler/HsVersions.h"
+        "compiler/nativeGen/NCG.h"
+        "compiler/parser/cutils.h"
+        "compiler/utils/md5.h"
+        "includes/CodeGen.Platform.hs"
+        "autogen/Config.hs"
+        "autogen/864/Config.hs"
+        "autogen/863/Config.hs"
+        "includes/GHCConstantsHaskellExports.hs"
+        "includes/GHCConstantsHaskellType.hs"
+        "includes/GHCConstantsHaskellWrappers.hs"
+        "includes/*.h"
+        "includes/*.hs-incl"
+        "includes/rts/*.h"
+        "includes/rts/storage/*.h"
+        "includes/stg/*.h"
+        ];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      "library" = {
+        depends = ([
+          (hsPkgs."base" or (errorHandler.buildDepError "base"))
+          (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq"))
+          (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+          (hsPkgs."process" or (errorHandler.buildDepError "process"))
+          (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+          (hsPkgs."binary" or (errorHandler.buildDepError "binary"))
+          (hsPkgs."time" or (errorHandler.buildDepError "time"))
+          (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+          (hsPkgs."array" or (errorHandler.buildDepError "array"))
+          (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+          (hsPkgs."hpc" or (errorHandler.buildDepError "hpc"))
+          (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+          (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot"))
+          (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th"))
+          (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap"))
+          ] ++ (if flags.use-host-template-haskell || compiler.isGhcjs && true
+          then [
+            (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell"))
+            (hsPkgs."ghci" or (errorHandler.buildDepError "ghci"))
+            ]
+          else [
+            (hsPkgs."template-haskell-ghcjs" or (errorHandler.buildDepError "template-haskell-ghcjs"))
+            (hsPkgs."ghci-ghcjs" or (errorHandler.buildDepError "ghci-ghcjs"))
+            ])) ++ (if system.isWindows
+          then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ]
+          else [
+            (hsPkgs."unix" or (errorHandler.buildDepError "unix"))
+            ] ++ (pkgs.lib).optional (flags.terminfo) (hsPkgs."terminfo" or (errorHandler.buildDepError "terminfo")));
+        build-tools = [
+          (hsPkgs.buildPackages.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy")))
+          (hsPkgs.buildPackages.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex")))
+          (hsPkgs.buildPackages.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex")))
+          (hsPkgs.buildPackages.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy")))
+          ];
+        buildable = true;
+        modules = [
+          "GhcPrelude"
+          "Ar"
+          "FileCleanup"
+          "DriverBkp"
+          "BkpSyn"
+          "NameShape"
+          "RnModIface"
+          "Avail"
+          "AsmUtils"
+          "BasicTypes"
+          "ConLike"
+          "DataCon"
+          "PatSyn"
+          "Demand"
+          "Debug"
+          "Exception"
+          "FieldLabel"
+          "GhcMonad"
+          "Hooks"
+          "Id"
+          "IdInfo"
+          "Lexeme"
+          "Literal"
+          "Llvm"
+          "Llvm/AbsSyn"
+          "Llvm/MetaData"
+          "Llvm/PpLlvm"
+          "Llvm/Types"
+          "LlvmCodeGen"
+          "LlvmCodeGen/Base"
+          "LlvmCodeGen/CodeGen"
+          "LlvmCodeGen/Data"
+          "LlvmCodeGen/Ppr"
+          "LlvmCodeGen/Regs"
+          "LlvmMangler"
+          "MkId"
+          "Module"
+          "Name"
+          "NameEnv"
+          "NameSet"
+          "OccName"
+          "RdrName"
+          "NameCache"
+          "SrcLoc"
+          "UniqSupply"
+          "Unique"
+          "Var"
+          "VarEnv"
+          "VarSet"
+          "UnVarGraph"
+          "BlockId"
+          "CLabel"
+          "Cmm"
+          "CmmBuildInfoTables"
+          "CmmPipeline"
+          "CmmCallConv"
+          "CmmCommonBlockElim"
+          "CmmImplementSwitchPlans"
+          "CmmContFlowOpt"
+          "CmmExpr"
+          "CmmInfo"
+          "CmmLex"
+          "CmmLint"
+          "CmmLive"
+          "CmmMachOp"
+          "CmmMonad"
+          "CmmSwitch"
+          "CmmNode"
+          "CmmOpt"
+          "CmmParse"
+          "CmmProcPoint"
+          "CmmSink"
+          "CmmType"
+          "CmmUtils"
+          "CmmLayoutStack"
+          "EnumSet"
+          "MkGraph"
+          "PprBase"
+          "PprC"
+          "PprCmm"
+          "PprCmmDecl"
+          "PprCmmExpr"
+          "Bitmap"
+          "CodeGen/Platform"
+          "CodeGen/Platform/ARM"
+          "CodeGen/Platform/ARM64"
+          "CodeGen/Platform/NoRegs"
+          "CodeGen/Platform/PPC"
+          "CodeGen/Platform/PPC_Darwin"
+          "CodeGen/Platform/SPARC"
+          "CodeGen/Platform/X86"
+          "CodeGen/Platform/X86_64"
+          "CgUtils"
+          "StgCmm"
+          "StgCmmBind"
+          "StgCmmClosure"
+          "StgCmmCon"
+          "StgCmmEnv"
+          "StgCmmExpr"
+          "StgCmmForeign"
+          "StgCmmHeap"
+          "StgCmmHpc"
+          "StgCmmArgRep"
+          "StgCmmLayout"
+          "StgCmmMonad"
+          "StgCmmPrim"
+          "StgCmmProf"
+          "StgCmmTicky"
+          "StgCmmUtils"
+          "StgCmmExtCode"
+          "SMRep"
+          "CoreArity"
+          "CoreFVs"
+          "CoreLint"
+          "CorePrep"
+          "CoreSubst"
+          "CoreOpt"
+          "CoreSyn"
+          "TrieMap"
+          "CoreTidy"
+          "CoreUnfold"
+          "CoreUtils"
+          "CoreMap"
+          "CoreSeq"
+          "CoreStats"
+          "MkCore"
+          "PprCore"
+          "PmExpr"
+          "TmOracle"
+          "Check"
+          "Coverage"
+          "Desugar"
+          "DsArrows"
+          "DsBinds"
+          "DsCCall"
+          "DsExpr"
+          "DsForeign"
+          "DsGRHSs"
+          "DsListComp"
+          "DsMonad"
+          "DsUsage"
+          "DsUtils"
+          "ExtractDocs"
+          "Match"
+          "MatchCon"
+          "MatchLit"
+          "HsBinds"
+          "HsDecls"
+          "HsDoc"
+          "HsExpr"
+          "HsImpExp"
+          "HsLit"
+          "PlaceHolder"
+          "HsExtension"
+          "HsInstances"
+          "HsPat"
+          "HsSyn"
+          "HsTypes"
+          "HsUtils"
+          "HsDumpAst"
+          "BinIface"
+          "BinFingerprint"
+          "BuildTyCl"
+          "IfaceEnv"
+          "IfaceSyn"
+          "IfaceType"
+          "ToIface"
+          "LoadIface"
+          "MkIface"
+          "TcIface"
+          "FlagChecker"
+          "Annotations"
+          "CmdLineParser"
+          "CodeOutput"
+          "Config"
+          "Constants"
+          "DriverMkDepend"
+          "DriverPhases"
+          "PipelineMonad"
+          "DriverPipeline"
+          "DynFlags"
+          "ErrUtils"
+          "Finder"
+          "GHC"
+          "GhcMake"
+          "GhcPlugins"
+          "DynamicLoading"
+          "HeaderInfo"
+          "HscMain"
+          "HscStats"
+          "HscTypes"
+          "InteractiveEval"
+          "InteractiveEvalTypes"
+          "PackageConfig"
+          "Packages"
+          "PlatformConstants"
+          "Plugins"
+          "TcPluginM"
+          "PprTyThing"
+          "StaticPtrTable"
+          "SysTools"
+          "SysTools/BaseDir"
+          "SysTools/Terminal"
+          "SysTools/ExtraObj"
+          "SysTools/Info"
+          "SysTools/Process"
+          "SysTools/Tasks"
+          "Elf"
+          "TidyPgm"
+          "Ctype"
+          "HaddockUtils"
+          "Lexer"
+          "OptCoercion"
+          "Parser"
+          "RdrHsSyn"
+          "ApiAnnotation"
+          "ForeignCall"
+          "KnownUniques"
+          "PrelInfo"
+          "PrelNames"
+          "PrelRules"
+          "PrimOp"
+          "TysPrim"
+          "TysWiredIn"
+          "CostCentre"
+          "CostCentreState"
+          "ProfInit"
+          "RnBinds"
+          "RnEnv"
+          "RnExpr"
+          "RnHsDoc"
+          "RnNames"
+          "RnPat"
+          "RnSource"
+          "RnSplice"
+          "RnTypes"
+          "RnFixity"
+          "RnUtils"
+          "RnUnbound"
+          "CoreMonad"
+          "CSE"
+          "FloatIn"
+          "FloatOut"
+          "LiberateCase"
+          "OccurAnal"
+          "SAT"
+          "SetLevels"
+          "SimplCore"
+          "SimplEnv"
+          "SimplMonad"
+          "SimplUtils"
+          "Simplify"
+          "SimplStg"
+          "StgStats"
+          "StgCse"
+          "UnariseStg"
+          "RepType"
+          "Rules"
+          "SpecConstr"
+          "Specialise"
+          "CoreToStg"
+          "StgLint"
+          "StgSyn"
+          "CallArity"
+          "DmdAnal"
+          "Exitify"
+          "WorkWrap"
+          "WwLib"
+          "FamInst"
+          "Inst"
+          "TcAnnotations"
+          "TcArrows"
+          "TcBinds"
+          "TcSigs"
+          "TcClassDcl"
+          "TcDefaults"
+          "TcDeriv"
+          "TcDerivInfer"
+          "TcDerivUtils"
+          "TcEnv"
+          "TcExpr"
+          "TcForeign"
+          "TcGenDeriv"
+          "TcGenFunctor"
+          "TcGenGenerics"
+          "TcHsSyn"
+          "TcHsType"
+          "TcInstDcls"
+          "TcMType"
+          "TcValidity"
+          "TcMatches"
+          "TcPat"
+          "TcPatSyn"
+          "TcRnDriver"
+          "TcBackpack"
+          "TcRnExports"
+          "TcRnMonad"
+          "TcRnTypes"
+          "TcRules"
+          "TcSimplify"
+          "TcHoleErrors"
+          "TcErrors"
+          "TcTyClsDecls"
+          "TcTyDecls"
+          "TcTypeable"
+          "TcType"
+          "TcEvidence"
+          "TcEvTerm"
+          "TcUnify"
+          "TcInteract"
+          "TcCanonical"
+          "TcFlatten"
+          "TcSMonad"
+          "TcTypeNats"
+          "TcSplice"
+          "Class"
+          "Coercion"
+          "DsMeta"
+          "THNames"
+          "FamInstEnv"
+          "FunDeps"
+          "InstEnv"
+          "TyCon"
+          "CoAxiom"
+          "Kind"
+          "Type"
+          "TyCoRep"
+          "Unify"
+          "Bag"
+          "Binary"
+          "BooleanFormula"
+          "BufWrite"
+          "Digraph"
+          "Encoding"
+          "FastFunctions"
+          "FastMutInt"
+          "FastString"
+          "FastStringEnv"
+          "Fingerprint"
+          "FiniteMap"
+          "FV"
+          "GraphBase"
+          "GraphColor"
+          "GraphOps"
+          "GraphPpr"
+          "IOEnv"
+          "Json"
+          "ListSetOps"
+          "ListT"
+          "Maybes"
+          "MonadUtils"
+          "OrdList"
+          "Outputable"
+          "Pair"
+          "Panic"
+          "PprColour"
+          "Pretty"
+          "State"
+          "Stream"
+          "StringBuffer"
+          "UniqDFM"
+          "UniqDSet"
+          "UniqFM"
+          "UniqMap"
+          "UniqSet"
+          "Util"
+          "Hoopl/Block"
+          "Hoopl/Collections"
+          "Hoopl/Dataflow"
+          "Hoopl/Graph"
+          "Hoopl/Label"
+          "AsmCodeGen"
+          "TargetReg"
+          "NCGMonad"
+          "Instruction"
+          "Format"
+          "Reg"
+          "RegClass"
+          "PIC"
+          "Platform"
+          "CPrim"
+          "X86/Regs"
+          "X86/RegInfo"
+          "X86/Instr"
+          "X86/Cond"
+          "X86/Ppr"
+          "X86/CodeGen"
+          "PPC/Regs"
+          "PPC/RegInfo"
+          "PPC/Instr"
+          "PPC/Cond"
+          "PPC/Ppr"
+          "PPC/CodeGen"
+          "SPARC/Base"
+          "SPARC/Regs"
+          "SPARC/Imm"
+          "SPARC/AddrMode"
+          "SPARC/Cond"
+          "SPARC/Instr"
+          "SPARC/Stack"
+          "SPARC/ShortcutJump"
+          "SPARC/Ppr"
+          "SPARC/CodeGen"
+          "SPARC/CodeGen/Amode"
+          "SPARC/CodeGen/Base"
+          "SPARC/CodeGen/CondCode"
+          "SPARC/CodeGen/Gen32"
+          "SPARC/CodeGen/Gen64"
+          "SPARC/CodeGen/Sanity"
+          "SPARC/CodeGen/Expand"
+          "RegAlloc/Liveness"
+          "RegAlloc/Graph/Main"
+          "RegAlloc/Graph/Stats"
+          "RegAlloc/Graph/ArchBase"
+          "RegAlloc/Graph/ArchX86"
+          "RegAlloc/Graph/Coalesce"
+          "RegAlloc/Graph/Spill"
+          "RegAlloc/Graph/SpillClean"
+          "RegAlloc/Graph/SpillCost"
+          "RegAlloc/Graph/TrivColorable"
+          "RegAlloc/Linear/Main"
+          "RegAlloc/Linear/JoinToTargets"
+          "RegAlloc/Linear/State"
+          "RegAlloc/Linear/Stats"
+          "RegAlloc/Linear/FreeRegs"
+          "RegAlloc/Linear/StackMap"
+          "RegAlloc/Linear/Base"
+          "RegAlloc/Linear/X86/FreeRegs"
+          "RegAlloc/Linear/X86_64/FreeRegs"
+          "RegAlloc/Linear/PPC/FreeRegs"
+          "RegAlloc/Linear/SPARC/FreeRegs"
+          "Dwarf"
+          "Dwarf/Types"
+          "Dwarf/Constants"
+          "Convert"
+          "ByteCodeTypes"
+          "ByteCodeAsm"
+          "ByteCodeGen"
+          "ByteCodeInstr"
+          "ByteCodeItbls"
+          "ByteCodeLink"
+          "Debugger"
+          "Linker"
+          "RtClosureInspect"
+          "GHCi"
+          ];
+        cSources = [
+          "compiler/parser/cutils.c"
+          "compiler/ghci/keepCAFsForGHCi.c"
+          "compiler/cbits/genSym.c"
+          ];
+        hsSourceDirs = [
+          "compiler/backpack"
+          "compiler/basicTypes"
+          "compiler/cmm"
+          "compiler/codeGen"
+          "compiler/coreSyn"
+          "compiler/deSugar"
+          "compiler/ghci"
+          "compiler/hsSyn"
+          "compiler/iface"
+          "compiler/llvmGen"
+          "compiler/main"
+          "compiler/nativeGen"
+          "compiler/parser"
+          "compiler/prelude"
+          "compiler/profiling"
+          "compiler/rename"
+          "compiler/simplCore"
+          "compiler/simplStg"
+          "compiler/specialise"
+          "compiler/stgSyn"
+          "compiler/stranal"
+          "compiler/typecheck"
+          "compiler/types"
+          "compiler/utils"
+          ] ++ (if compiler.isGhc && (compiler.version).eq "8.6.3"
+          then [ "autogen/863" ]
+          else if compiler.isGhc && (compiler.version).eq "8.6.4"
+            then [ "autogen/864" ]
+            else [ "autogen" ]);
+        includeDirs = [
+          "compiler"
+          "compiler/parser"
+          "compiler/utils"
+          "includes"
+          "autogen"
+          ];
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../lib/ghc-api-ghcjs; }
--- a/materialized/ghcjs865/.plan.nix/ghci-ghcjs.nix
+++ b/materialized/ghcjs865/.plan.nix/ghci-ghcjs.nix
@ -0,0 +1,70 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = { ghci = true; };
+    package = {
+      specVersion = "1.10";
+      identifier = { name = "ghci-ghcjs"; version = "8.6.1"; };
+      license = "BSD-3-Clause";
+      copyright = "";
+      maintainer = "ghc-devs@haskell.org";
+      author = "";
+      homepage = "";
+      url = "";
+      synopsis = "The library supporting GHC's interactive interpreter (customized for GHCJS)";
+      description = "This library offers interfaces which mediate interactions between the\n@ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter\nbackend.";
+      buildType = "Simple";
+      isLocal = true;
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "";
+      dataFiles = [];
+      extraSrcFiles = [ "changelog.md" ];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      "library" = {
+        depends = [
+          (hsPkgs."array" or (errorHandler.buildDepError "array"))
+          (hsPkgs."base" or (errorHandler.buildDepError "base"))
+          (hsPkgs."binary" or (errorHandler.buildDepError "binary"))
+          (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+          (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+          (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq"))
+          (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+          (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot"))
+          (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th"))
+          (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap"))
+          (hsPkgs."template-haskell-ghcjs" or (errorHandler.buildDepError "template-haskell-ghcjs"))
+          (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+          ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix"));
+        buildable = true;
+        modules = [
+          "GHCi/BreakArray"
+          "GHCi/BinaryArray"
+          "GHCi/Message"
+          "GHCi/ResolvedBCO"
+          "GHCi/RemoteTypes"
+          "GHCi/FFI"
+          "GHCi/InfoTable"
+          "GHCi/StaticPtrTable"
+          "GHCi/TH/Binary"
+          "SizedSeq"
+          ] ++ (pkgs.lib).optionals (flags.ghci) [
+          "GHCi/Run"
+          "GHCi/CreateBCO"
+          "GHCi/ObjLink"
+          "GHCi/Signals"
+          "GHCi/TH"
+          ];
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../lib/ghci-ghcjs; }
--- a/materialized/ghcjs865/.plan.nix/ghcjs-th.nix
+++ b/materialized/ghcjs865/.plan.nix/ghcjs-th.nix
@ -0,0 +1,58 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = { use-host-template-haskell = false; };
+    package = {
+      specVersion = "1.10";
+      identifier = { name = "ghcjs-th"; version = "0.1.0.0"; };
+      license = "MIT";
+      copyright = "";
+      maintainer = "stegeman@gmail.com";
+      author = "Luite Stegeman";
+      homepage = "http://github.com/ghcjs";
+      url = "";
+      synopsis = "";
+      description = "";
+      buildType = "Simple";
+      isLocal = true;
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "";
+      dataFiles = [];
+      extraSrcFiles = [];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      "library" = {
+        depends = [
+          (hsPkgs."base" or (errorHandler.buildDepError "base"))
+          (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim"))
+          (hsPkgs."binary" or (errorHandler.buildDepError "binary"))
+          (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+          (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+          ] ++ (if compiler.isGhcjs && true || flags.use-host-template-haskell
+          then [
+            (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell"))
+            (hsPkgs."ghci" or (errorHandler.buildDepError "ghci"))
+            ]
+          else [
+            (hsPkgs."template-haskell-ghcjs" or (errorHandler.buildDepError "template-haskell-ghcjs"))
+            (hsPkgs."ghci-ghcjs" or (errorHandler.buildDepError "ghci-ghcjs"))
+            ]);
+        buildable = true;
+        modules = [
+          "GHCJS/Prim/TH/Eval"
+          "GHCJS/Prim/TH/Serialized"
+          "GHCJS/Prim/TH/Types"
+          ];
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../lib/ghcjs-th; }
--- a/materialized/ghcjs865/.plan.nix/ghcjs.nix
+++ b/materialized/ghcjs865/.plan.nix/ghcjs.nix
@ -0,0 +1,331 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = {
+      compiler-only = false;
+      no-wrapper-install = false;
+      disable-optimizer = false;
+      runtime-assertions = false;
+      use-host-template-haskell = false;
+      };
+    package = {
+      specVersion = "2.0";
+      identifier = { name = "ghcjs"; version = "8.6.5"; };
+      license = "MIT";
+      copyright = "Victor Nazarov, Hamish Mackenzie, Luite Stegeman";
+      maintainer = "Luite Stegeman <stegeman@gmail.com>";
+      author = "Victor Nazarov, Hamish Mackenzie, Luite Stegeman";
+      homepage = "";
+      url = "";
+      synopsis = "Haskell to JavaScript compiler";
+      description = "Haskell to JavaScript compiler based on GHC";
+      buildType = "Custom";
+      isLocal = true;
+      setup-depends = [
+        (hsPkgs.buildPackages.base or (pkgs.buildPackages.base or (errorHandler.buildToolDepError "base")))
+        (hsPkgs.buildPackages.Cabal or (pkgs.buildPackages.Cabal or (errorHandler.buildToolDepError "Cabal")))
+        (hsPkgs.buildPackages.containers or (pkgs.buildPackages.containers or (errorHandler.buildToolDepError "containers")))
+        (hsPkgs.buildPackages.filepath or (pkgs.buildPackages.filepath or (errorHandler.buildToolDepError "filepath")))
+        (hsPkgs.buildPackages.directory or (pkgs.buildPackages.directory or (errorHandler.buildToolDepError "directory")))
+        (hsPkgs.buildPackages.process or (pkgs.buildPackages.process or (errorHandler.buildToolDepError "process")))
+        (hsPkgs.buildPackages.template-haskell or (pkgs.buildPackages.template-haskell or (errorHandler.buildToolDepError "template-haskell")))
+        (hsPkgs.buildPackages.transformers or (pkgs.buildPackages.transformers or (errorHandler.buildToolDepError "transformers")))
+        ];
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "data";
+      dataFiles = [ "*.tar" "bin/*.sh" "bin/*.exe.options" ];
+      extraSrcFiles = [
+        "utils/*.hs"
+        "utils/*.sh"
+        "include/prim/*.hs-incl"
+        "include/prim/*.txt"
+        "include/*.h"
+        "src-bin/haddock/*.hs"
+        "HACKING.markdown"
+        "README.markdown"
+        "test/LICENSE"
+        "test/ghcjs-testsuite.cabal"
+        "stack.yaml"
+        ];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      "library" = {
+        depends = [
+          (hsPkgs."base" or (errorHandler.buildDepError "base"))
+          (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal"))
+          (hsPkgs."ghc-api-ghcjs" or (errorHandler.buildDepError "ghc-api-ghcjs"))
+          (hsPkgs."ghcjs-th" or (errorHandler.buildDepError "ghcjs-th"))
+          (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot"))
+          (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+          (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+          (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+          (hsPkgs."process" or (errorHandler.buildDepError "process"))
+          (hsPkgs."mtl" or (errorHandler.buildDepError "mtl"))
+          (hsPkgs."ghc-paths" or (errorHandler.buildDepError "ghc-paths"))
+          (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell"))
+          (hsPkgs."syb" or (errorHandler.buildDepError "syb"))
+          (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+          (hsPkgs."attoparsec" or (errorHandler.buildDepError "attoparsec"))
+          (hsPkgs."aeson" or (errorHandler.buildDepError "aeson"))
+          (hsPkgs."text" or (errorHandler.buildDepError "text"))
+          (hsPkgs."wl-pprint-text" or (errorHandler.buildDepError "wl-pprint-text"))
+          (hsPkgs."lens" or (errorHandler.buildDepError "lens"))
+          (hsPkgs."yaml" or (errorHandler.buildDepError "yaml"))
+          (hsPkgs."time" or (errorHandler.buildDepError "time"))
+          (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+          (hsPkgs."split" or (errorHandler.buildDepError "split"))
+          (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq"))
+          (hsPkgs."vector" or (errorHandler.buildDepError "vector"))
+          (hsPkgs."data-default" or (errorHandler.buildDepError "data-default"))
+          (hsPkgs."array" or (errorHandler.buildDepError "array"))
+          (hsPkgs."binary" or (errorHandler.buildDepError "binary"))
+          (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers"))
+          (hsPkgs."parallel" or (errorHandler.buildDepError "parallel"))
+          (hsPkgs."cryptohash" or (errorHandler.buildDepError "cryptohash"))
+          (hsPkgs."hashable" or (errorHandler.buildDepError "hashable"))
+          (hsPkgs."optparse-applicative" or (errorHandler.buildDepError "optparse-applicative"))
+          (hsPkgs."stringsearch" or (errorHandler.buildDepError "stringsearch"))
+          (hsPkgs."base16-bytestring" or (errorHandler.buildDepError "base16-bytestring"))
+          (hsPkgs."base64-bytestring" or (errorHandler.buildDepError "base64-bytestring"))
+          (hsPkgs."regex-posix" or (errorHandler.buildDepError "regex-posix"))
+          (hsPkgs."safe" or (errorHandler.buildDepError "safe"))
+          (hsPkgs."parsec" or (errorHandler.buildDepError "parsec"))
+          (hsPkgs."haskell-src-exts" or (errorHandler.buildDepError "haskell-src-exts"))
+          (hsPkgs."haskell-src-meta" or (errorHandler.buildDepError "haskell-src-meta"))
+          ] ++ (if flags.use-host-template-haskell
+          then [ (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) ]
+          else [
+            (hsPkgs."template-haskell-ghcjs" or (errorHandler.buildDepError "template-haskell-ghcjs"))
+            (hsPkgs."ghci-ghcjs" or (errorHandler.buildDepError "ghci-ghcjs"))
+            ]);
+        buildable = true;
+        modules = [
+          "Paths_ghcjs"
+          "Gen2/Generator"
+          "Gen2/Profiling"
+          "Gen2/Floater"
+          "Gen2/Prim"
+          "Gen2/Rts"
+          "Gen2/RtsApply"
+          "Gen2/RtsTypes"
+          "Gen2/RtsAlloc"
+          "Gen2/Utils"
+          "Gen2/StgAst"
+          "Gen2/Optimizer"
+          "Gen2/Dataflow"
+          "Gen2/Deps"
+          "Gen2/Printer"
+          "Gen2/Linker"
+          "Gen2/Shim"
+          "Gen2/Compactor"
+          "Gen2/Object"
+          "Gen2/Archive"
+          "Gen2/ClosureInfo"
+          "Gen2/Foreign"
+          "Gen2/Sinker"
+          "Gen2/TH"
+          "Gen2/Base"
+          "Gen2/Cache"
+          "Gen2/DynamicLinking"
+          "Gen2/GHC/Digraph"
+          "Gen2/GHC/DsForeign"
+          "Compiler/Compat"
+          "Compiler/GhcjsHooks"
+          "Compiler/GhcjsPlatform"
+          "Compiler/Info"
+          "Compiler/Plugins"
+          "Compiler/Program"
+          "Compiler/GhcjsProgram"
+          "Compiler/Settings"
+          "Compiler/Utils"
+          "Compiler/Variants"
+          "Compiler/JMacro"
+          "Compiler/JMacro/Base"
+          "Compiler/JMacro/Lens"
+          "Compiler/JMacro/QQ"
+          "Compiler/JMacro/ParseTH"
+          "Compiler/JMacro/Util"
+          "GHCJS"
+          ];
+        hsSourceDirs = [ "src" ];
+        includeDirs = [ "include" ];
+        };
+      exes = {
+        "ghcjs" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."ghcjs" or (errorHandler.buildDepError "ghcjs"))
+            ];
+          buildable = true;
+          hsSourceDirs = [ "src-bin" ];
+          mainPath = [ "Main.hs" ];
+          };
+        "haddock-ghcjs" = {
+          depends = [
+            (hsPkgs."ghc-api-ghcjs" or (errorHandler.buildDepError "ghc-api-ghcjs"))
+            (hsPkgs."haddock-api-ghcjs" or (errorHandler.buildDepError "haddock-api-ghcjs"))
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+            (hsPkgs."transformers-compat" or (errorHandler.buildDepError "transformers-compat"))
+            (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            (hsPkgs."ghcjs" or (errorHandler.buildDepError "ghcjs"))
+            ];
+          buildable = true;
+          modules = [ "ResponseFile" ];
+          hsSourceDirs = [ "src-bin" "src-bin/haddock" ];
+          mainPath = [
+            "Haddock.hs"
+            ] ++ (pkgs.lib).optional (system.isWindows) "";
+          };
+        "hsc2hs-ghcjs" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."ghcjs" or (errorHandler.buildDepError "ghcjs"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            ];
+          buildable = true;
+          hsSourceDirs = [ "src-bin" ];
+          mainPath = [
+            "Hsc2Hs.hs"
+            ] ++ (pkgs.lib).optional (system.isWindows) "";
+          };
+        "ghcjs-pkg" = {
+          depends = [
+            (hsPkgs."ghcjs" or (errorHandler.buildDepError "ghcjs"))
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+            (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal"))
+            (hsPkgs."binary" or (errorHandler.buildDepError "binary"))
+            (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+            (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot"))
+            ] ++ (pkgs.lib).optionals (!system.isWindows) [
+            (hsPkgs."unix" or (errorHandler.buildDepError "unix"))
+            (hsPkgs."terminfo" or (errorHandler.buildDepError "terminfo"))
+            ];
+          buildable = if flags.compiler-only then false else true;
+          cSources = (pkgs.lib).optional (system.isWindows) "cbits/CRT_noglob.c";
+          hsSourceDirs = [ "src-bin" ];
+          mainPath = (([
+            "Pkg.hs"
+            ] ++ (pkgs.lib).optional (flags.compiler-only) "") ++ (pkgs.lib).optional (!system.isWindows) "") ++ (pkgs.lib).optional (system.isWindows) "";
+          };
+        "ghcjs-boot" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."ghcjs" or (errorHandler.buildDepError "ghcjs"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal"))
+            (hsPkgs."mtl" or (errorHandler.buildDepError "mtl"))
+            (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+            (hsPkgs."lens" or (errorHandler.buildDepError "lens"))
+            (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers"))
+            (hsPkgs."vector" or (errorHandler.buildDepError "vector"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            (hsPkgs."aeson" or (errorHandler.buildDepError "aeson"))
+            (hsPkgs."text" or (errorHandler.buildDepError "text"))
+            (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+            (hsPkgs."system-filepath" or (errorHandler.buildDepError "system-filepath"))
+            (hsPkgs."shelly" or (errorHandler.buildDepError "shelly"))
+            (hsPkgs."system-fileio" or (errorHandler.buildDepError "system-fileio"))
+            (hsPkgs."optparse-applicative" or (errorHandler.buildDepError "optparse-applicative"))
+            (hsPkgs."tar" or (errorHandler.buildDepError "tar"))
+            (hsPkgs."yaml" or (errorHandler.buildDepError "yaml"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            (hsPkgs."time" or (errorHandler.buildDepError "time"))
+            (hsPkgs."unix-compat" or (errorHandler.buildDepError "unix-compat"))
+            (hsPkgs."executable-path" or (errorHandler.buildDepError "executable-path"))
+            ];
+          buildable = if flags.compiler-only then false else true;
+          hsSourceDirs = [ "src-bin" ];
+          mainPath = ([
+            "Boot.hs"
+            ] ++ (pkgs.lib).optional (flags.compiler-only) "") ++ (pkgs.lib).optional (system.isWindows) "";
+          };
+        "ghcjs-run" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            ];
+          buildable = if flags.compiler-only then false else true;
+          hsSourceDirs = [ "src-bin" ];
+          mainPath = ([
+            "Run.hs"
+            ] ++ (pkgs.lib).optional (flags.compiler-only) "") ++ (pkgs.lib).optional (system.isWindows) "";
+          };
+        "ghcjs-dumparchive" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."text" or (errorHandler.buildDepError "text"))
+            (hsPkgs."ghc-api-ghcjs" or (errorHandler.buildDepError "ghc-api-ghcjs"))
+            (hsPkgs."ghcjs" or (errorHandler.buildDepError "ghcjs"))
+            (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            ];
+          buildable = if flags.compiler-only then false else true;
+          hsSourceDirs = [ "utils" ];
+          mainPath = ([
+            "dumpArchive.hs"
+            ] ++ (pkgs.lib).optional (flags.compiler-only) "") ++ (pkgs.lib).optional (system.isWindows) "";
+          };
+        };
+      tests = {
+        "test" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            (hsPkgs."network" or (errorHandler.buildDepError "network"))
+            (hsPkgs."aeson" or (errorHandler.buildDepError "aeson"))
+            (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework"))
+            (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit"))
+            (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit"))
+            (hsPkgs."system-filepath" or (errorHandler.buildDepError "system-filepath"))
+            (hsPkgs."system-fileio" or (errorHandler.buildDepError "system-fileio"))
+            (hsPkgs."text" or (errorHandler.buildDepError "text"))
+            (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+            (hsPkgs."lens" or (errorHandler.buildDepError "lens"))
+            (hsPkgs."random" or (errorHandler.buildDepError "random"))
+            (hsPkgs."time" or (errorHandler.buildDepError "time"))
+            (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+            (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq"))
+            (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers"))
+            (hsPkgs."shelly" or (errorHandler.buildDepError "shelly"))
+            (hsPkgs."data-default" or (errorHandler.buildDepError "data-default"))
+            (hsPkgs."yaml" or (errorHandler.buildDepError "yaml"))
+            (hsPkgs."optparse-applicative" or (errorHandler.buildDepError "optparse-applicative"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."http-types" or (errorHandler.buildDepError "http-types"))
+            (hsPkgs."warp" or (errorHandler.buildDepError "warp"))
+            (hsPkgs."wai" or (errorHandler.buildDepError "wai"))
+            (hsPkgs."wai-extra" or (errorHandler.buildDepError "wai-extra"))
+            (hsPkgs."wai-app-static" or (errorHandler.buildDepError "wai-app-static"))
+            (hsPkgs."wai-websockets" or (errorHandler.buildDepError "wai-websockets"))
+            (hsPkgs."websockets" or (errorHandler.buildDepError "websockets"))
+            (hsPkgs."webdriver" or (errorHandler.buildDepError "webdriver"))
+            (hsPkgs."lifted-base" or (errorHandler.buildDepError "lifted-base"))
+            ];
+          buildable = true;
+          modules = [ "Server" "Client" "Types" ];
+          hsSourceDirs = [ "test" ];
+          mainPath = [ "TestRunner.hs" ];
+          };
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../.; }
--- a/materialized/ghcjs865/.plan.nix/haddock-api-ghcjs.nix
+++ b/materialized/ghcjs865/.plan.nix/haddock-api-ghcjs.nix
@ -0,0 +1,184 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = {};
+    package = {
+      specVersion = "2.0";
+      identifier = { name = "haddock-api-ghcjs"; version = "2.20.0"; };
+      license = "BSD-3-Clause";
+      copyright = "(c) Simon Marlow, David Waern";
+      maintainer = "Alex Biehl <alexbiehl@gmail.com>, Simon Hengel <sol@typeful.net>, Mateusz Kowalczyk <fuuzetsu@fuuzetsu.co.uk>";
+      author = "Simon Marlow, David Waern";
+      homepage = "http://www.haskell.org/haddock/";
+      url = "";
+      synopsis = "A documentation-generation tool for Haskell libraries";
+      description = "Haddock is a documentation-generation tool for Haskell\nlibraries";
+      buildType = "Simple";
+      isLocal = true;
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "resources";
+      dataFiles = [
+        "html/quick-jump.min.js"
+        "html/haddock-bundle.min.js"
+        "html/quick-jump.css"
+        "html/solarized.css"
+        "html/highlight.js"
+        "html/Classic.theme/haskell_icon.gif"
+        "html/Classic.theme/minus.gif"
+        "html/Classic.theme/plus.gif"
+        "html/Classic.theme/xhaddock.css"
+        "html/Ocean.std-theme/hslogo-16.png"
+        "html/Ocean.std-theme/minus.gif"
+        "html/Ocean.std-theme/ocean.css"
+        "html/Ocean.std-theme/plus.gif"
+        "html/Ocean.std-theme/synopsis.png"
+        "latex/haddock.sty"
+        ];
+      extraSrcFiles = [ "CHANGES.md" ];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      "library" = {
+        depends = [
+          (hsPkgs."base" or (errorHandler.buildDepError "base"))
+          (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal"))
+          (hsPkgs."ghc-api-ghcjs" or (errorHandler.buildDepError "ghc-api-ghcjs"))
+          (hsPkgs."ghc-paths" or (errorHandler.buildDepError "ghc-paths"))
+          (hsPkgs."haddock-library-ghcjs" or (errorHandler.buildDepError "haddock-library-ghcjs"))
+          (hsPkgs."xhtml" or (errorHandler.buildDepError "xhtml"))
+          (hsPkgs."array" or (errorHandler.buildDepError "array"))
+          (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+          (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+          (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq"))
+          (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+          (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+          (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot"))
+          (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+          ];
+        buildable = true;
+        modules = [
+          "Haddock"
+          "Haddock/Interface"
+          "Haddock/Interface/Rename"
+          "Haddock/Interface/Create"
+          "Haddock/Interface/AttachInstances"
+          "Haddock/Interface/Json"
+          "Haddock/Interface/LexParseRn"
+          "Haddock/Interface/ParseModuleHeader"
+          "Haddock/Interface/Specialize"
+          "Haddock/Parser"
+          "Haddock/Utils"
+          "Haddock/Utils/Json"
+          "Haddock/Backends/Xhtml"
+          "Haddock/Backends/Xhtml/Decl"
+          "Haddock/Backends/Xhtml/DocMarkup"
+          "Haddock/Backends/Xhtml/Layout"
+          "Haddock/Backends/Xhtml/Meta"
+          "Haddock/Backends/Xhtml/Names"
+          "Haddock/Backends/Xhtml/Themes"
+          "Haddock/Backends/Xhtml/Types"
+          "Haddock/Backends/Xhtml/Utils"
+          "Haddock/Backends/LaTeX"
+          "Haddock/Backends/HaddockDB"
+          "Haddock/Backends/Hoogle"
+          "Haddock/Backends/Hyperlinker"
+          "Haddock/Backends/Hyperlinker/Ast"
+          "Haddock/Backends/Hyperlinker/Parser"
+          "Haddock/Backends/Hyperlinker/Renderer"
+          "Haddock/Backends/Hyperlinker/Types"
+          "Haddock/Backends/Hyperlinker/Utils"
+          "Haddock/ModuleTree"
+          "Haddock/Types"
+          "Haddock/Doc"
+          "Haddock/Version"
+          "Haddock/InterfaceFile"
+          "Haddock/Options"
+          "Haddock/GhcUtils"
+          "Haddock/Syb"
+          "Haddock/Convert"
+          "Paths_haddock_api_ghcjs"
+          "Documentation/Haddock"
+          ];
+        hsSourceDirs = [ "src" ];
+        };
+      tests = {
+        "spec" = {
+          depends = [
+            (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal"))
+            (hsPkgs."ghc-api-ghcjs" or (errorHandler.buildDepError "ghc-api-ghcjs"))
+            (hsPkgs."ghc-paths" or (errorHandler.buildDepError "ghc-paths"))
+            (hsPkgs."haddock-library-ghcjs" or (errorHandler.buildDepError "haddock-library-ghcjs"))
+            (hsPkgs."xhtml" or (errorHandler.buildDepError "xhtml"))
+            (hsPkgs."hspec" or (errorHandler.buildDepError "hspec"))
+            (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck"))
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."array" or (errorHandler.buildDepError "array"))
+            (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+            (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+            (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot"))
+            (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+            ];
+          build-tools = [
+            (hsPkgs.buildPackages.hspec-discover or (pkgs.buildPackages.hspec-discover or (errorHandler.buildToolDepError "hspec-discover")))
+            ];
+          buildable = true;
+          modules = [
+            "Haddock"
+            "Haddock/Backends/Hoogle"
+            "Haddock/Backends/Hyperlinker"
+            "Haddock/Backends/Hyperlinker/Ast"
+            "Haddock/Backends/Hyperlinker/Renderer"
+            "Haddock/Backends/Hyperlinker/Utils"
+            "Haddock/Backends/LaTeX"
+            "Haddock/Backends/Xhtml"
+            "Haddock/Backends/Xhtml/Decl"
+            "Haddock/Backends/Xhtml/DocMarkup"
+            "Haddock/Backends/Xhtml/Layout"
+            "Haddock/Backends/Xhtml/Meta"
+            "Haddock/Backends/Xhtml/Names"
+            "Haddock/Backends/Xhtml/Themes"
+            "Haddock/Backends/Xhtml/Types"
+            "Haddock/Backends/Xhtml/Utils"
+            "Haddock/Convert"
+            "Haddock/Doc"
+            "Haddock/GhcUtils"
+            "Haddock/Interface"
+            "Haddock/Interface/AttachInstances"
+            "Haddock/Interface/Create"
+            "Haddock/Interface/Json"
+            "Haddock/Interface/LexParseRn"
+            "Haddock/Interface/ParseModuleHeader"
+            "Haddock/Interface/Rename"
+            "Haddock/Interface/Specialize"
+            "Haddock/InterfaceFile"
+            "Haddock/ModuleTree"
+            "Haddock/Options"
+            "Haddock/Parser"
+            "Haddock/Syb"
+            "Haddock/Types"
+            "Haddock/Utils"
+            "Haddock/Utils/Json"
+            "Haddock/Version"
+            "Paths_haddock_api_ghcjs"
+            "Haddock/Backends/Hyperlinker/ParserSpec"
+            "Haddock/Backends/Hyperlinker/Parser"
+            "Haddock/Backends/Hyperlinker/Types"
+            ];
+          hsSourceDirs = [ "test" "src" ];
+          mainPath = [ "Spec.hs" ];
+          };
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../lib/haddock-api-ghcjs; }
--- a/materialized/ghcjs865/.plan.nix/haddock-library-ghcjs.nix
+++ b/materialized/ghcjs865/.plan.nix/haddock-library-ghcjs.nix
@ -0,0 +1,103 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = {};
+    package = {
+      specVersion = "2.0";
+      identifier = { name = "haddock-library-ghcjs"; version = "1.6.0"; };
+      license = "BSD-3-Clause";
+      copyright = "";
+      maintainer = "Alex Biehl <alexbiehl@gmail.com>, Simon Hengel <sol@typeful.net>, Mateusz Kowalczyk <fuuzetsu@fuuzetsu.co.uk>";
+      author = "";
+      homepage = "http://www.haskell.org/haddock/";
+      url = "";
+      synopsis = "Library exposing some functionality of Haddock.";
+      description = "Haddock is a documentation-generation tool for Haskell\nlibraries. These modules expose some functionality of it\nwithout pulling in the GHC dependency. Please note that the\nAPI is likely to change so specify upper bounds in your\nproject if you can't release often. For interacting with Haddock\nitself, see the ‘haddock’ package.";
+      buildType = "Simple";
+      isLocal = true;
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "";
+      dataFiles = [];
+      extraSrcFiles = [ "CHANGES.md" ];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      "library" = {
+        depends = [
+          (hsPkgs."base" or (errorHandler.buildDepError "base"))
+          (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+          (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+          (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+          (hsPkgs."text" or (errorHandler.buildDepError "text"))
+          (hsPkgs."parsec" or (errorHandler.buildDepError "parsec"))
+          ];
+        buildable = true;
+        modules = [
+          "Documentation/Haddock/Parser/Util"
+          "Documentation/Haddock/Doc"
+          "Documentation/Haddock/Markup"
+          "Documentation/Haddock/Parser"
+          "Documentation/Haddock/Parser/Monad"
+          "Documentation/Haddock/Types"
+          "Documentation/Haddock/Utf8"
+          ];
+        hsSourceDirs = [ "src" ];
+        };
+      tests = {
+        "spec" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."base-compat" or (errorHandler.buildDepError "base-compat"))
+            (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+            (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+            (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+            (hsPkgs."hspec" or (errorHandler.buildDepError "hspec"))
+            (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck"))
+            (hsPkgs."text" or (errorHandler.buildDepError "text"))
+            (hsPkgs."parsec" or (errorHandler.buildDepError "parsec"))
+            (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq"))
+            ];
+          build-tools = [
+            (hsPkgs.buildPackages.hspec-discover or (pkgs.buildPackages.hspec-discover or (errorHandler.buildToolDepError "hspec-discover")))
+            ];
+          buildable = true;
+          modules = [
+            "Documentation/Haddock/Doc"
+            "Documentation/Haddock/Parser"
+            "Documentation/Haddock/Parser/Monad"
+            "Documentation/Haddock/Parser/Util"
+            "Documentation/Haddock/Parser/UtilSpec"
+            "Documentation/Haddock/ParserSpec"
+            "Documentation/Haddock/Types"
+            "Documentation/Haddock/Utf8"
+            "Documentation/Haddock/Utf8Spec"
+            ];
+          hsSourceDirs = [ "test" "src" ];
+          mainPath = [ "Spec.hs" ];
+          };
+        "fixtures" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."base-compat" or (errorHandler.buildDepError "base-compat"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            (hsPkgs."optparse-applicative" or (errorHandler.buildDepError "optparse-applicative"))
+            (hsPkgs."tree-diff" or (errorHandler.buildDepError "tree-diff"))
+            (hsPkgs."haddock-library" or (errorHandler.buildDepError "haddock-library"))
+            ];
+          buildable = true;
+          hsSourceDirs = [ "fixtures" ];
+          mainPath = [ "Fixtures.hs" ];
+          };
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../lib/haddock-library-ghcjs; }
--- a/materialized/ghcjs865/.plan.nix/template-haskell-ghcjs.nix
+++ b/materialized/ghcjs865/.plan.nix/template-haskell-ghcjs.nix
@ -0,0 +1,54 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = {};
+    package = {
+      specVersion = "1.10";
+      identifier = { name = "template-haskell-ghcjs"; version = "2.14.0.0"; };
+      license = "BSD-3-Clause";
+      copyright = "";
+      maintainer = "libraries@haskell.org";
+      author = "";
+      homepage = "";
+      url = "";
+      synopsis = "Support library for Template Haskell (customized for GHCJS)";
+      description = "This package provides modules containing facilities for manipulating\nHaskell source code using Template Haskell.\n\nSee <http://www.haskell.org/haskellwiki/Template_Haskell> for more\ninformation.";
+      buildType = "Simple";
+      isLocal = true;
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "";
+      dataFiles = [];
+      extraSrcFiles = [ "changelog.md" ];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      "library" = {
+        depends = [
+          (hsPkgs."base" or (errorHandler.buildDepError "base"))
+          (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th"))
+          (hsPkgs."pretty" or (errorHandler.buildDepError "pretty"))
+          ];
+        buildable = true;
+        modules = [
+          "Language/Haskell/TH/Lib/Map"
+          "Language/Haskell/TH"
+          "Language/Haskell/TH/Lib"
+          "Language/Haskell/TH/Ppr"
+          "Language/Haskell/TH/PprLib"
+          "Language/Haskell/TH/Quote"
+          "Language/Haskell/TH/Syntax"
+          "Language/Haskell/TH/LanguageExtensions"
+          "Language/Haskell/TH/Lib/Internal"
+          ];
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../lib/template-haskell-ghcjs; }
--- a/materialized/ghcjs865/default.nix
+++ b/materialized/ghcjs865/default.nix
@ -0,0 +1,415 @@
+{
+  pkgs = hackage:
+    {
+      packages = {
+        "warp".revision = (((hackage."warp")."3.2.28").revisions).default;
+        "warp".flags.allow-sendfilefd = true;
+        "warp".flags.network-bytestring = false;
+        "warp".flags.warp-debug = false;
+        "test-framework-hunit".revision = (((hackage."test-framework-hunit")."0.3.0.2").revisions).default;
+        "test-framework-hunit".flags.base4 = true;
+        "test-framework-hunit".flags.base3 = false;
+        "http-client".revision = (((hackage."http-client")."0.6.4.1").revisions).default;
+        "http-client".flags.network-uri = true;
+        "haddock-library".revision = (((hackage."haddock-library")."1.9.0").revisions).default;
+        "wai-websockets".revision = (((hackage."wai-websockets")."3.0.1.2").revisions).default;
+        "wai-websockets".flags.example = true;
+        "cookie".revision = (((hackage."cookie")."0.4.5").revisions).default;
+        "void".revision = (((hackage."void")."0.7.3").revisions).default;
+        "void".flags.safe = false;
+        "semigroupoids".revision = (((hackage."semigroupoids")."5.3.4").revisions).default;
+        "semigroupoids".flags.comonad = true;
+        "semigroupoids".flags.doctests = true;
+        "semigroupoids".flags.unordered-containers = true;
+        "semigroupoids".flags.distributive = true;
+        "semigroupoids".flags.tagged = true;
+        "semigroupoids".flags.containers = true;
+        "semigroupoids".flags.contravariant = true;
+        "byteorder".revision = (((hackage."byteorder")."1.0.4").revisions).default;
+        "free".revision = (((hackage."free")."5.1.3").revisions).default;
+        "tf-random".revision = (((hackage."tf-random")."0.5").revisions).default;
+        "zip-archive".revision = (((hackage."zip-archive")."0.4.1").revisions).default;
+        "zip-archive".flags.executable = false;
+        "exceptions".revision = (((hackage."exceptions")."0.10.4").revisions).default;
+        "exceptions".flags.transformers-0-4 = true;
+        "ghc-paths".revision = (((hackage."ghc-paths")."0.1.0.12").revisions).default;
+        "binary".revision = (((hackage."binary")."0.8.6.0").revisions).default;
+        "ghc-boot".revision = (((hackage."ghc-boot")."8.6.5").revisions).default;
+        "wl-pprint-text".revision = (((hackage."wl-pprint-text")."1.2.0.1").revisions).default;
+        "tar".revision = (((hackage."tar")."0.5.1.1").revisions).default;
+        "tar".flags.old-time = false;
+        "tar".flags.old-bytestring = false;
+        "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;
+        "old-time".revision = (((hackage."old-time")."1.1.0.3").revisions).default;
+        "bifunctors".revision = (((hackage."bifunctors")."5.5.7").revisions).default;
+        "bifunctors".flags.semigroups = true;
+        "bifunctors".flags.tagged = true;
+        "split".revision = (((hackage."split")."0.2.3.4").revisions).default;
+        "stm".revision = (((hackage."stm")."2.5.0.0").revisions).default;
+        "unix-time".revision = (((hackage."unix-time")."0.4.7").revisions).default;
+        "http2".revision = (((hackage."http2")."1.6.5").revisions).default;
+        "http2".flags.devel = false;
+        "base-compat-batteries".revision = (((hackage."base-compat-batteries")."0.10.5").revisions).default;
+        "appar".revision = (((hackage."appar")."0.1.8").revisions).default;
+        "case-insensitive".revision = (((hackage."case-insensitive")."1.2.1.0").revisions).default;
+        "network-byte-order".revision = (((hackage."network-byte-order")."0.1.4.0").revisions).default;
+        "sop-core".revision = (((hackage."sop-core")."0.5.0.1").revisions).default;
+        "extensible-exceptions".revision = (((hackage."extensible-exceptions")."0.1.1.4").revisions).default;
+        "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;
+        "SHA".revision = (((hackage."SHA")."1.6.4.4").revisions).default;
+        "SHA".flags.exe = false;
+        "ghc-heap".revision = (((hackage."ghc-heap")."8.6.5").revisions).default;
+        "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;
+        "lifted-async".revision = (((hackage."lifted-async")."0.10.0.6").revisions).default;
+        "network-uri".revision = (((hackage."network-uri")."2.6.3.0").revisions).default;
+        "regex-base".revision = (((hackage."regex-base")."0.94.0.0").revisions).default;
+        "zlib".revision = (((hackage."zlib")."0.6.2.1").revisions).default;
+        "zlib".flags.non-blocking-ffi = false;
+        "zlib".flags.pkg-config = false;
+        "rts".revision = (((hackage."rts")."1.0").revisions).default;
+        "easy-file".revision = (((hackage."easy-file")."0.2.2").revisions).default;
+        "th-expand-syns".revision = (((hackage."th-expand-syns")."0.4.6.0").revisions).default;
+        "regex-posix".revision = (((hackage."regex-posix")."0.96.0.0").revisions).default;
+        "regex-posix".flags._regex-posix-clib = false;
+        "cryptonite".revision = (((hackage."cryptonite")."0.26").revisions).default;
+        "cryptonite".flags.support_sse = false;
+        "cryptonite".flags.integer-gmp = true;
+        "cryptonite".flags.support_rdrand = true;
+        "cryptonite".flags.support_aesni = true;
+        "cryptonite".flags.support_deepseq = true;
+        "cryptonite".flags.support_pclmuldq = false;
+        "cryptonite".flags.check_alignment = false;
+        "cryptonite".flags.old_toolchain_inliner = false;
+        "alex".revision = (((hackage."alex")."3.2.5").revisions).default;
+        "alex".flags.small_base = true;
+        "clock".revision = (((hackage."clock")."0.8").revisions).default;
+        "clock".flags.llvm = false;
+        "system-fileio".revision = (((hackage."system-fileio")."0.3.16.4").revisions).default;
+        "adjunctions".revision = (((hackage."adjunctions")."4.4").revisions).default;
+        "invariant".revision = (((hackage."invariant")."0.5.3").revisions).default;
+        "enclosed-exceptions".revision = (((hackage."enclosed-exceptions")."1.0.3").revisions).default;
+        "th-orphans".revision = (((hackage."th-orphans")."0.13.10").revisions).default;
+        "executable-path".revision = (((hackage."executable-path")."0.0.3.1").revisions).default;
+        "syb".revision = (((hackage."syb")."0.7.1").revisions).default;
+        "distributive".revision = (((hackage."distributive")."0.6.2").revisions).default;
+        "distributive".flags.semigroups = true;
+        "distributive".flags.tagged = true;
+        "generics-sop".revision = (((hackage."generics-sop")."0.5.1.0").revisions).default;
+        "system-filepath".revision = (((hackage."system-filepath")."0.4.14").revisions).default;
+        "bytestring-builder".revision = (((hackage."bytestring-builder")."0.10.8.2.0").revisions).default;
+        "bytestring-builder".flags.bytestring_has_builder = true;
+        "QuickCheck".revision = (((hackage."QuickCheck")."2.13.2").revisions).default;
+        "QuickCheck".flags.templatehaskell = true;
+        "scientific".revision = (((hackage."scientific")."0.3.6.2").revisions).default;
+        "scientific".flags.integer-simple = false;
+        "scientific".flags.bytestring-builder = false;
+        "time-manager".revision = (((hackage."time-manager")."0.0.0").revisions).default;
+        "newtype-generics".revision = (((hackage."newtype-generics")."0.5.4").revisions).default;
+        "hspec-discover".revision = (((hackage."hspec-discover")."2.7.1").revisions).default;
+        "parallel".revision = (((hackage."parallel")."3.2.2.0").revisions).default;
+        "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;
+        "haskell-src-meta".revision = (((hackage."haskell-src-meta")."0.8.5").revisions).default;
+        "random".revision = (((hackage."random")."1.1").revisions).default;
+        "temporary".revision = (((hackage."temporary")."1.3").revisions).default;
+        "uuid-types".revision = (((hackage."uuid-types")."1.0.3").revisions).default;
+        "optparse-applicative".revision = (((hackage."optparse-applicative")."0.14.3.0").revisions).default;
+        "network".revision = (((hackage."network")."3.1.1.1").revisions).default;
+        "word8".revision = (((hackage."word8")."0.1.3").revisions).default;
+        "splitmix".revision = (((hackage."splitmix")."0.0.4").revisions).default;
+        "splitmix".flags.optimised-mixer = false;
+        "splitmix".flags.random = true;
+        "async".revision = (((hackage."async")."2.2.2").revisions).default;
+        "async".flags.bench = false;
+        "dlist".revision = (((hackage."dlist")."0.8.0.8").revisions).default;
+        "websockets".revision = (((hackage."websockets")."0.12.7.0").revisions).default;
+        "websockets".flags.example = false;
+        "conduit".revision = (((hackage."conduit")."1.3.2").revisions).default;
+        "constraints".revision = (((hackage."constraints")."0.12").revisions).default;
+        "semigroups".revision = (((hackage."semigroups")."0.19.1").revisions).default;
+        "semigroups".flags.bytestring = true;
+        "semigroups".flags.unordered-containers = true;
+        "semigroups".flags.text = true;
+        "semigroups".flags.tagged = true;
+        "semigroups".flags.containers = true;
+        "semigroups".flags.binary = true;
+        "semigroups".flags.hashable = true;
+        "semigroups".flags.transformers = true;
+        "semigroups".flags.deepseq = true;
+        "semigroups".flags.bytestring-builder = false;
+        "semigroups".flags.template-haskell = true;
+        "data-default".revision = (((hackage."data-default")."0.7.1.1").revisions).default;
+        "HUnit".revision = (((hackage."HUnit")."1.6.0.0").revisions).default;
+        "lifted-base".revision = (((hackage."lifted-base")."0.2.3.12").revisions).default;
+        "data-default-instances-old-locale".revision = (((hackage."data-default-instances-old-locale")."0.0.1").revisions).default;
+        "tree-diff".revision = (((hackage."tree-diff")."0.0.2.1").revisions).default;
+        "parsec".revision = (((hackage."parsec")."3.1.13.0").revisions).default;
+        "th-reify-many".revision = (((hackage."th-reify-many")."0.1.9").revisions).default;
+        "hsc2hs".revision = (((hackage."hsc2hs")."0.68.7").revisions).default;
+        "hsc2hs".flags.in-ghc-tree = false;
+        "directory".revision = (((hackage."directory")."1.3.3.0").revisions).default;
+        "yaml".revision = (((hackage."yaml")."0.10.4.0").revisions).default;
+        "yaml".flags.no-exe = true;
+        "yaml".flags.no-examples = true;
+        "yaml".flags.system-libyaml = false;
+        "yaml".flags.no-unicode = false;
+        "transformers-compat".revision = (((hackage."transformers-compat")."0.6.5").revisions).default;
+        "transformers-compat".flags.five = false;
+        "transformers-compat".flags.generic-deriving = true;
+        "transformers-compat".flags.two = false;
+        "transformers-compat".flags.five-three = true;
+        "transformers-compat".flags.mtl = true;
+        "transformers-compat".flags.four = false;
+        "transformers-compat".flags.three = false;
+        "template-haskell".revision = (((hackage."template-haskell")."2.14.0.0").revisions).default;
+        "hspec-expectations".revision = (((hackage."hspec-expectations")."0.8.2").revisions).default;
+        "mono-traversable".revision = (((hackage."mono-traversable")."1.0.15.1").revisions).default;
+        "psqueues".revision = (((hackage."psqueues")."0.2.7.2").revisions).default;
+        "vector".revision = (((hackage."vector")."0.12.1.2").revisions).default;
+        "vector".flags.unsafechecks = false;
+        "vector".flags.internalchecks = false;
+        "vector".flags.wall = false;
+        "vector".flags.boundschecks = true;
+        "call-stack".revision = (((hackage."call-stack")."0.2.0").revisions).default;
+        "primitive".revision = (((hackage."primitive")."0.7.0.1").revisions).default;
+        "cryptohash".revision = (((hackage."cryptohash")."0.11.9").revisions).default;
+        "profunctors".revision = (((hackage."profunctors")."5.5.2").revisions).default;
+        "safe".revision = (((hackage."safe")."0.3.18").revisions).default;
+        "blaze-builder".revision = (((hackage."blaze-builder")."0.4.1.0").revisions).default;
+        "base-compat".revision = (((hackage."base-compat")."0.10.5").revisions).default;
+        "time-compat".revision = (((hackage."time-compat")."1.9.3").revisions).default;
+        "time-compat".flags.old-locale = false;
+        "ansi-terminal".revision = (((hackage."ansi-terminal")."0.9.1").revisions).default;
+        "ansi-terminal".flags.example = false;
+        "tagged".revision = (((hackage."tagged")."0.8.6").revisions).default;
+        "tagged".flags.transformers = true;
+        "tagged".flags.deepseq = true;
+        "parsers".revision = (((hackage."parsers")."0.12.10").revisions).default;
+        "parsers".flags.parsec = true;
+        "parsers".flags.binary = true;
+        "parsers".flags.attoparsec = true;
+        "haskell-src-exts".revision = (((hackage."haskell-src-exts")."1.20.3").revisions).default;
+        "lens".revision = (((hackage."lens")."4.17.1").revisions).default;
+        "lens".flags.j = false;
+        "lens".flags.test-properties = true;
+        "lens".flags.old-inline-pragmas = false;
+        "lens".flags.test-templates = true;
+        "lens".flags.trustworthy = true;
+        "lens".flags.test-doctests = true;
+        "lens".flags.benchmark-uniplate = false;
+        "lens".flags.inlining = true;
+        "lens".flags.dump-splices = false;
+        "lens".flags.test-hunit = true;
+        "lens".flags.safe = false;
+        "unliftio-core".revision = (((hackage."unliftio-core")."0.2.0.1").revisions).default;
+        "containers".revision = (((hackage."containers")."0.6.0.1").revisions).default;
+        "integer-logarithms".revision = (((hackage."integer-logarithms")."1.0.3").revisions).default;
+        "integer-logarithms".flags.check-bounds = false;
+        "integer-logarithms".flags.integer-gmp = true;
+        "reflection".revision = (((hackage."reflection")."2.1.5").revisions).default;
+        "reflection".flags.slow = false;
+        "reflection".flags.template-haskell = true;
+        "streaming-commons".revision = (((hackage."streaming-commons")."0.2.1.2").revisions).default;
+        "streaming-commons".flags.use-bytestring-builder = false;
+        "shelly".revision = (((hackage."shelly")."1.8.1").revisions).default;
+        "shelly".flags.build-examples = false;
+        "shelly".flags.lifted = false;
+        "bytestring".revision = (((hackage."bytestring")."0.10.8.2").revisions).default;
+        "ansi-wl-pprint".revision = (((hackage."ansi-wl-pprint")."0.6.9").revisions).default;
+        "ansi-wl-pprint".flags.example = false;
+        "wai".revision = (((hackage."wai")."3.2.2.1").revisions).default;
+        "basement".revision = (((hackage."basement")."0.0.11").revisions).default;
+        "setenv".revision = (((hackage."setenv")."0.1.1.3").revisions).default;
+        "test-framework".revision = (((hackage."test-framework")."0.8.2.0").revisions).default;
+        "hostname".revision = (((hackage."hostname")."1.0").revisions).default;
+        "old-locale".revision = (((hackage."old-locale")."1.0.0.7").revisions).default;
+        "directory-tree".revision = (((hackage."directory-tree")."0.12.1").revisions).default;
+        "StateVar".revision = (((hackage."StateVar")."1.2").revisions).default;
+        "vault".revision = (((hackage."vault")."0.3.1.4").revisions).default;
+        "vault".flags.useghc = true;
+        "mime-types".revision = (((hackage."mime-types")."0.1.0.9").revisions).default;
+        "charset".revision = (((hackage."charset")."0.3.7.1").revisions).default;
+        "contravariant".revision = (((hackage."contravariant")."1.5.2").revisions).default;
+        "contravariant".flags.semigroups = true;
+        "contravariant".flags.tagged = true;
+        "contravariant".flags.statevar = true;
+        "data-default-instances-dlist".revision = (((hackage."data-default-instances-dlist")."0.0.1").revisions).default;
+        "xhtml".revision = (((hackage."xhtml")."3000.2.2.1").revisions).default;
+        "type-equality".revision = (((hackage."type-equality")."1").revisions).default;
+        "blaze-markup".revision = (((hackage."blaze-markup")."0.8.2.5").revisions).default;
+        "text".revision = (((hackage."text")."1.2.3.1").revisions).default;
+        "Cabal".revision = (((hackage."Cabal")."2.4.0.1").revisions).default;
+        "unordered-containers".revision = (((hackage."unordered-containers")."0.2.10.0").revisions).default;
+        "unordered-containers".flags.debug = false;
+        "base64-bytestring".revision = (((hackage."base64-bytestring")."1.0.0.3").revisions).default;
+        "base".revision = (((hackage."base")."4.12.0.0").revisions).default;
+        "comonad".revision = (((hackage."comonad")."5.0.6").revisions).default;
+        "comonad".flags.distributive = true;
+        "comonad".flags.test-doctests = true;
+        "comonad".flags.containers = true;
+        "hspec".revision = (((hackage."hspec")."2.7.1").revisions).default;
+        "time".revision = (((hackage."time")."1.8.0.2").revisions).default;
+        "data-default-class".revision = (((hackage."data-default-class")."0.1.2.0").revisions).default;
+        "terminfo".revision = (((hackage."terminfo")."0.4.1.2").revisions).default;
+        "base16-bytestring".revision = (((hackage."base16-bytestring")."0.1.1.6").revisions).default;
+        "vector-algorithms".revision = (((hackage."vector-algorithms")."0.8.0.3").revisions).default;
+        "vector-algorithms".flags.unsafechecks = false;
+        "vector-algorithms".flags.internalchecks = false;
+        "vector-algorithms".flags.llvm = false;
+        "vector-algorithms".flags.boundschecks = true;
+        "vector-algorithms".flags.bench = true;
+        "vector-algorithms".flags.properties = true;
+        "iproute".revision = (((hackage."iproute")."1.7.9").revisions).default;
+        "transformers".revision = (((hackage."transformers")."0.5.6.2").revisions).default;
+        "hashable".revision = (((hackage."hashable")."1.3.0.0").revisions).default;
+        "hashable".flags.sse2 = true;
+        "hashable".flags.integer-gmp = true;
+        "hashable".flags.sse41 = false;
+        "hashable".flags.examples = false;
+        "quickcheck-io".revision = (((hackage."quickcheck-io")."0.2.0").revisions).default;
+        "wai-extra".revision = (((hackage."wai-extra")."3.0.29.1").revisions).default;
+        "wai-extra".flags.build-example = false;
+        "data-default-instances-containers".revision = (((hackage."data-default-instances-containers")."0.0.1").revisions).default;
+        "attoparsec".revision = (((hackage."attoparsec")."0.13.2.4").revisions).default;
+        "attoparsec".flags.developer = false;
+        "blaze-html".revision = (((hackage."blaze-html")."0.9.1.2").revisions).default;
+        "digest".revision = (((hackage."digest")."0.0.1.2").revisions).default;
+        "digest".flags.bytestring-in-base = false;
+        "MemoTrie".revision = (((hackage."MemoTrie")."0.6.10").revisions).default;
+        "MemoTrie".flags.examples = false;
+        "colour".revision = (((hackage."colour")."2.3.5").revisions).default;
+        "transformers-base".revision = (((hackage."transformers-base")."0.4.5.2").revisions).default;
+        "transformers-base".flags.orphaninstances = true;
+        "happy".revision = (((hackage."happy")."1.19.9").revisions).default;
+        "happy".flags.small_base = true;
+        "file-embed".revision = (((hackage."file-embed")."0.0.11.2").revisions).default;
+        "byteable".revision = (((hackage."byteable")."0.1.1").revisions).default;
+        "hpc".revision = (((hackage."hpc")."0.6.0.3").revisions).default;
+        "entropy".revision = (((hackage."entropy")."0.4.1.6").revisions).default;
+        "entropy".flags.halvm = false;
+        "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;
+        "auto-update".revision = (((hackage."auto-update")."0.1.6").revisions).default;
+        "hspec-core".revision = (((hackage."hspec-core")."2.7.1").revisions).default;
+        "stringsearch".revision = (((hackage."stringsearch")."0.3.6.6").revisions).default;
+        "stringsearch".flags.base4 = true;
+        "stringsearch".flags.base3 = false;
+        "unix-compat".revision = (((hackage."unix-compat")."0.5.2").revisions).default;
+        "unix-compat".flags.old-time = false;
+        "monad-control".revision = (((hackage."monad-control")."1.0.2.3").revisions).default;
+        "process".revision = (((hackage."process")."1.6.5.0").revisions).default;
+        "kan-extensions".revision = (((hackage."kan-extensions")."5.2").revisions).default;
+        "wai-logger".revision = (((hackage."wai-logger")."2.3.6").revisions).default;
+        "th-lift".revision = (((hackage."th-lift")."0.8.1").revisions).default;
+        "resourcet".revision = (((hackage."resourcet")."1.2.4").revisions).default;
+        "webdriver".revision = (((hackage."webdriver")."0.8.5").revisions).default;
+        "webdriver".flags.network-uri = true;
+        "webdriver".flags.developer = false;
+        "pretty".revision = (((hackage."pretty")."1.1.3.6").revisions).default;
+        "cabal-doctest".revision = (((hackage."cabal-doctest")."1.0.8").revisions).default;
+        "aeson".revision = (((hackage."aeson")."1.4.7.1").revisions).default;
+        "aeson".flags.cffi = false;
+        "aeson".flags.fast = false;
+        "aeson".flags.bytestring-builder = false;
+        "aeson".flags.developer = false;
+        "wai-app-static".revision = (((hackage."wai-app-static")."3.1.7.1").revisions).default;
+        "wai-app-static".flags.print = false;
+        "http-types".revision = (((hackage."http-types")."0.12.3").revisions).default;
+        "ghc-boot-th".revision = (((hackage."ghc-boot-th")."8.6.5").revisions).default;
+        "th-lift-instances".revision = (((hackage."th-lift-instances")."0.1.16").revisions).default;
+        "base-orphans".revision = (((hackage."base-orphans")."0.8.2").revisions).default;
+        "http-date".revision = (((hackage."http-date")."0.0.8").revisions).default;
+        "th-abstraction".revision = (((hackage."th-abstraction")."0.3.2.0").revisions).default;
+        "memory".revision = (((hackage."memory")."0.15.0").revisions).default;
+        "memory".flags.support_bytestring = true;
+        "memory".flags.support_basement = true;
+        "memory".flags.support_foundation = true;
+        "memory".flags.support_deepseq = true;
+        "fast-logger".revision = (((hackage."fast-logger")."3.0.1").revisions).default;
+        "bsb-http-chunked".revision = (((hackage."bsb-http-chunked")."0.0.0.4").revisions).default;
+        "array".revision = (((hackage."array")."0.5.3.0").revisions).default;
+        "xml".revision = (((hackage."xml")."1.3.14").revisions).default;
+        "simple-sendfile".revision = (((hackage."simple-sendfile")."0.2.30").revisions).default;
+        "simple-sendfile".flags.allow-bsd = true;
+        "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;
+        };
+      compiler = {
+        version = "8.6.5";
+        nix-name = "ghc865";
+        packages = {
+          "binary" = "0.8.6.0";
+          "ghc-boot" = "8.6.5";
+          "ghc-prim" = "0.5.3";
+          "stm" = "2.5.0.0";
+          "unix" = "2.7.2.2";
+          "ghc-heap" = "8.6.5";
+          "mtl" = "2.2.2";
+          "rts" = "1.0";
+          "deepseq" = "1.4.4.0";
+          "parsec" = "3.1.13.0";
+          "directory" = "1.3.3.0";
+          "template-haskell" = "2.14.0.0";
+          "containers" = "0.6.0.1";
+          "bytestring" = "0.10.8.2";
+          "xhtml" = "3000.2.2.1";
+          "text" = "1.2.3.1";
+          "Cabal" = "2.4.0.1";
+          "base" = "4.12.0.0";
+          "time" = "1.8.0.2";
+          "terminfo" = "0.4.1.2";
+          "transformers" = "0.5.6.2";
+          "hpc" = "0.6.0.3";
+          "filepath" = "1.4.2.1";
+          "process" = "1.6.5.0";
+          "pretty" = "1.1.3.6";
+          "ghc-boot-th" = "8.6.5";
+          "array" = "0.5.3.0";
+          "integer-gmp" = "1.0.2.0";
+          };
+        };
+      };
+  extras = hackage:
+    {
+      packages = {
+        haddock-library-ghcjs = ./.plan.nix/haddock-library-ghcjs.nix;
+        ghcjs-th = ./.plan.nix/ghcjs-th.nix;
+        ghc-api-ghcjs = ./.plan.nix/ghc-api-ghcjs.nix;
+        ghci-ghcjs = ./.plan.nix/ghci-ghcjs.nix;
+        ghcjs = ./.plan.nix/ghcjs.nix;
+        haddock-api-ghcjs = ./.plan.nix/haddock-api-ghcjs.nix;
+        template-haskell-ghcjs = ./.plan.nix/template-haskell-ghcjs.nix;
+        };
+      };
+  modules = [
+    ({ lib, ... }:
+      {
+        packages = {
+          "haddock-library-ghcjs" = { flags = {}; };
+          "ghcjs-th" = {
+            flags = { "use-host-template-haskell" = lib.mkOverride 900 false; };
+            };
+          "ghc-api-ghcjs" = {
+            flags = {
+              "stage1" = lib.mkOverride 900 false;
+              "stage2" = lib.mkOverride 900 true;
+              "debug" = lib.mkOverride 900 false;
+              "stage3" = lib.mkOverride 900 false;
+              "use-host-template-haskell" = lib.mkOverride 900 false;
+              "ghci" = lib.mkOverride 900 true;
+              "terminfo" = lib.mkOverride 900 true;
+              };
+            };
+          "ghci-ghcjs" = { flags = { "ghci" = lib.mkOverride 900 true; }; };
+          "ghcjs" = {
+            flags = {
+              "compiler-only" = lib.mkOverride 900 false;
+              "runtime-assertions" = lib.mkOverride 900 false;
+              "no-wrapper-install" = lib.mkOverride 900 false;
+              "use-host-template-haskell" = lib.mkOverride 900 false;
+              "disable-optimizer" = lib.mkOverride 900 false;
+              };
+            };
+          "haddock-api-ghcjs" = { flags = {}; };
+          "template-haskell-ghcjs" = { flags = {}; };
+          };
+        })
+    ];
+  }
--- a/materialized/ghcjs884/.plan.nix/ghcjs-th.nix
+++ b/materialized/ghcjs884/.plan.nix/ghcjs-th.nix
@ -0,0 +1,52 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = { use-host-template-haskell = false; };
+    package = {
+      specVersion = "1.10";
+      identifier = { name = "ghcjs-th"; version = "0.1.0.0"; };
+      license = "MIT";
+      copyright = "";
+      maintainer = "stegeman@gmail.com";
+      author = "Luite Stegeman";
+      homepage = "http://github.com/ghcjs";
+      url = "";
+      synopsis = "";
+      description = "";
+      buildType = "Simple";
+      isLocal = true;
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "";
+      dataFiles = [];
+      extraSrcFiles = [];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      "library" = {
+        depends = [
+          (hsPkgs."base" or (errorHandler.buildDepError "base"))
+          (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim"))
+          (hsPkgs."binary" or (errorHandler.buildDepError "binary"))
+          (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+          (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+          (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell"))
+          (hsPkgs."ghci" or (errorHandler.buildDepError "ghci"))
+          ];
+        buildable = true;
+        modules = [
+          "GHCJS/Prim/TH/Eval"
+          "GHCJS/Prim/TH/Serialized"
+          "GHCJS/Prim/TH/Types"
+          ];
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../lib/ghcjs-th; }
--- a/materialized/ghcjs884/.plan.nix/ghcjs.nix
+++ b/materialized/ghcjs884/.plan.nix/ghcjs.nix
@ -0,0 +1,980 @@
+{ system
+  , compiler
+  , flags
+  , pkgs
+  , hsPkgs
+  , pkgconfPkgs
+  , errorHandler
+  , config
+  , ... }:
+  {
+    flags = {
+      compiler-only = false;
+      no-wrapper-install = false;
+      disable-optimizer = false;
+      runtime-assertions = false;
+      use-host-template-haskell = true;
+      debug = false;
+      ghci = true;
+      stage1 = false;
+      stage2 = true;
+      stage3 = false;
+      terminfo = true;
+      };
+    package = {
+      specVersion = "2.4";
+      identifier = { name = "ghcjs"; version = "8.8.4"; };
+      license = "MIT";
+      copyright = "Victor Nazarov, Hamish Mackenzie, Luite Stegeman";
+      maintainer = "Luite Stegeman <stegeman@gmail.com>";
+      author = "Victor Nazarov, Hamish Mackenzie, Luite Stegeman";
+      homepage = "";
+      url = "";
+      synopsis = "Haskell to JavaScript compiler";
+      description = "Haskell to JavaScript compiler based on GHC";
+      buildType = "Simple";
+      isLocal = true;
+      detailLevel = "FullDetails";
+      licenseFiles = [ "LICENSE" ];
+      dataDir = "";
+      dataFiles = [];
+      extraSrcFiles = [
+        "utils/*.hs"
+        "utils/*.sh"
+        "include/prim/*.hs-incl"
+        "include/prim/*.txt"
+        "include/*.h"
+        "src-bin/haddock/*.hs"
+        "HACKING.markdown"
+        "README.markdown"
+        "test/LICENSE"
+        "test/ghcjs-testsuite.cabal"
+        "stack.yaml"
+        "cabal.project"
+        "inplace/bin/README.markdown"
+        "ghc/compiler/Unique.h"
+        "ghc/compiler/HsVersions.h"
+        "ghc/compiler/nativeGen/NCG.h"
+        "ghc/compiler/parser/cutils.h"
+        "ghc/compiler/utils/md5.h"
+        "ghc/includes/CodeGen.Platform.hs"
+        "lib/ghc/includes/*.h"
+        "lib/ghc/includes/*.hs"
+        "lib/ghc/includes/*.hs-incl"
+        "ghc/includes/rts/*.h"
+        "ghc/includes/rts/storage/*.h"
+        "ghc/includes/MachDeps.h"
+        "ghc/includes/Rts.h"
+        "ghc/includes/RtsAPI.h"
+        "ghc/includes/Stg.h"
+        "ghc/includes/HsFFI.h"
+        "ghc/includes/Cmm.h"
+        "ghc/includes/stg/*.h"
+        "ghc/utils/unlit/fs.h"
+        "ghc/driver/utils/cwrapper.h"
+        "ghc/driver/utils/getLocation.h"
+        "utils/wrapper/getline.h"
+        ];
+      extraTmpFiles = [];
+      extraDocFiles = [];
+      };
+    components = {
+      "library" = {
+        depends = ([
+          (hsPkgs."base" or (errorHandler.buildDepError "base"))
+          (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal"))
+          (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot"))
+          (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap"))
+          (hsPkgs."ghc-compact" or (errorHandler.buildDepError "ghc-compact"))
+          (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+          (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+          (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+          (hsPkgs."process" or (errorHandler.buildDepError "process"))
+          (hsPkgs."mtl" or (errorHandler.buildDepError "mtl"))
+          (hsPkgs."ghc-paths" or (errorHandler.buildDepError "ghc-paths"))
+          (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell"))
+          (hsPkgs."syb" or (errorHandler.buildDepError "syb"))
+          (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+          (hsPkgs."attoparsec" or (errorHandler.buildDepError "attoparsec"))
+          (hsPkgs."aeson" or (errorHandler.buildDepError "aeson"))
+          (hsPkgs."text" or (errorHandler.buildDepError "text"))
+          (hsPkgs."wl-pprint-text" or (errorHandler.buildDepError "wl-pprint-text"))
+          (hsPkgs."lens" or (errorHandler.buildDepError "lens"))
+          (hsPkgs."yaml" or (errorHandler.buildDepError "yaml"))
+          (hsPkgs."time" or (errorHandler.buildDepError "time"))
+          (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+          (hsPkgs."split" or (errorHandler.buildDepError "split"))
+          (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq"))
+          (hsPkgs."vector" or (errorHandler.buildDepError "vector"))
+          (hsPkgs."data-default" or (errorHandler.buildDepError "data-default"))
+          (hsPkgs."array" or (errorHandler.buildDepError "array"))
+          (hsPkgs."binary" or (errorHandler.buildDepError "binary"))
+          (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers"))
+          (hsPkgs."parallel" or (errorHandler.buildDepError "parallel"))
+          (hsPkgs."cryptohash" or (errorHandler.buildDepError "cryptohash"))
+          (hsPkgs."hashable" or (errorHandler.buildDepError "hashable"))
+          (hsPkgs."optparse-applicative" or (errorHandler.buildDepError "optparse-applicative"))
+          (hsPkgs."stringsearch" or (errorHandler.buildDepError "stringsearch"))
+          (hsPkgs."base16-bytestring" or (errorHandler.buildDepError "base16-bytestring"))
+          (hsPkgs."base64-bytestring" or (errorHandler.buildDepError "base64-bytestring"))
+          (hsPkgs."safe" or (errorHandler.buildDepError "safe"))
+          (hsPkgs."parsec" or (errorHandler.buildDepError "parsec"))
+          (hsPkgs."base" or (errorHandler.buildDepError "base"))
+          (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq"))
+          (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+          (hsPkgs."process" or (errorHandler.buildDepError "process"))
+          (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+          (hsPkgs."binary" or (errorHandler.buildDepError "binary"))
+          (hsPkgs."time" or (errorHandler.buildDepError "time"))
+          (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+          (hsPkgs."array" or (errorHandler.buildDepError "array"))
+          (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+          (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell"))
+          (hsPkgs."hpc" or (errorHandler.buildDepError "hpc"))
+          (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+          (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot"))
+          (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th"))
+          (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap"))
+          (hsPkgs."ghci" or (errorHandler.buildDepError "ghci"))
+          ] ++ (if flags.use-host-template-haskell
+          then [ (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) ]
+          else [
+            (hsPkgs."template-haskell-ghcjs" or (errorHandler.buildDepError "template-haskell-ghcjs"))
+            (hsPkgs."ghci-ghcjs" or (errorHandler.buildDepError "ghci-ghcjs"))
+            ])) ++ (if system.isWindows
+          then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ]
+          else [
+            (hsPkgs."unix" or (errorHandler.buildDepError "unix"))
+            ] ++ (pkgs.lib).optional (flags.terminfo) (hsPkgs."terminfo" or (errorHandler.buildDepError "terminfo")));
+        build-tools = [
+          (hsPkgs.buildPackages.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy")))
+          ];
+        buildable = true;
+        modules = [
+          "Paths_ghcjs"
+          "GhcPrelude"
+          "Gen2/Generator"
+          "Gen2/Profiling"
+          "Gen2/Floater"
+          "Gen2/Prim"
+          "Gen2/Rts"
+          "Gen2/RtsApply"
+          "Gen2/RtsTypes"
+          "Gen2/RtsAlloc"
+          "Gen2/Utils"
+          "Gen2/StgAst"
+          "Gen2/Optimizer"
+          "Gen2/Dataflow"
+          "Gen2/Deps"
+          "Gen2/Printer"
+          "Gen2/Linker"
+          "Gen2/Shim"
+          "Gen2/Compactor"
+          "Gen2/Object"
+          "Gen2/Archive"
+          "Gen2/ClosureInfo"
+          "Gen2/Foreign"
+          "Gen2/Sinker"
+          "Gen2/TH"
+          "Gen2/Base"
+          "Gen2/Cache"
+          "Gen2/DynamicLinking"
+          "Gen2/GHC/Digraph"
+          "Gen2/GHC/DsForeign"
+          "Compiler/Compat"
+          "Compiler/GhcjsHooks"
+          "Compiler/GhcjsPlatform"
+          "Compiler/Info"
+          "Compiler/Plugins"
+          "Compiler/Program"
+          "Compiler/GhcjsProgram"
+          "Compiler/Platform"
+          "Compiler/Settings"
+          "Compiler/Utils"
+          "Compiler/Variants"
+          "Compiler/JMacro"
+          "Compiler/JMacro/Base"
+          "Compiler/JMacro/Lens"
+          "Compiler/JMacro/QQ"
+          "Compiler/JMacro/Util"
+          "Compiler/JMacro/Combinators"
+          "Compiler/JMacro/Symbols"
+          "GHCJS"
+          "GHCJS/Prim/TH/Eval"
+          "GHCJS/Prim/TH/Serialized"
+          "GHCJS/Prim/TH/Types"
+          "HieTypes"
+          "HieDebug"
+          "HieBin"
+          "HieUtils"
+          "HieAst"
+          "Ar"
+          "FileCleanup"
+          "DriverBkp"
+          "BkpSyn"
+          "NameShape"
+          "RnModIface"
+          "Avail"
+          "AsmUtils"
+          "BasicTypes"
+          "ConLike"
+          "DataCon"
+          "PatSyn"
+          "Demand"
+          "Debug"
+          "Exception"
+          "FieldLabel"
+          "GhcMonad"
+          "Hooks"
+          "Id"
+          "IdInfo"
+          "Lexeme"
+          "Literal"
+          "Llvm"
+          "Llvm/AbsSyn"
+          "Llvm/MetaData"
+          "Llvm/PpLlvm"
+          "Llvm/Types"
+          "LlvmCodeGen"
+          "LlvmCodeGen/Base"
+          "LlvmCodeGen/CodeGen"
+          "LlvmCodeGen/Data"
+          "LlvmCodeGen/Ppr"
+          "LlvmCodeGen/Regs"
+          "LlvmMangler"
+          "MkId"
+          "Module"
+          "Name"
+          "NameEnv"
+          "NameSet"
+          "OccName"
+          "RdrName"
+          "NameCache"
+          "SrcLoc"
+          "UniqSupply"
+          "Unique"
+          "Var"
+          "VarEnv"
+          "VarSet"
+          "UnVarGraph"
+          "BlockId"
+          "CLabel"
+          "Cmm"
+          "CmmBuildInfoTables"
+          "CmmPipeline"
+          "CmmCallConv"
+          "CmmCommonBlockElim"
+          "CmmImplementSwitchPlans"
+          "CmmContFlowOpt"
+          "CmmExpr"
+          "CmmInfo"
+          "CmmLex"
+          "CmmLint"
+          "CmmLive"
+          "CmmMachOp"
+          "CmmMonad"
+          "CmmSwitch"
+          "CmmNode"
+          "CmmOpt"
+          "CmmParse"
+          "CmmProcPoint"
+          "CmmSink"
+          "CmmType"
+          "CmmUtils"
+          "CmmLayoutStack"
+          "EnumSet"
+          "MkGraph"
+          "PprBase"
+          "PprC"
+          "PprCmm"
+          "PprCmmDecl"
+          "PprCmmExpr"
+          "Bitmap"
+          "CodeGen/Platform"
+          "CodeGen/Platform/ARM"
+          "CodeGen/Platform/ARM64"
+          "CodeGen/Platform/NoRegs"
+          "CodeGen/Platform/PPC"
+          "CodeGen/Platform/SPARC"
+          "CodeGen/Platform/X86"
+          "CodeGen/Platform/X86_64"
+          "CgUtils"
+          "StgCmm"
+          "StgCmmBind"
+          "StgCmmClosure"
+          "StgCmmCon"
+          "StgCmmEnv"
+          "StgCmmExpr"
+          "StgCmmForeign"
+          "StgCmmHeap"
+          "StgCmmHpc"
+          "StgCmmArgRep"
+          "StgCmmLayout"
+          "StgCmmMonad"
+          "StgCmmPrim"
+          "StgCmmProf"
+          "StgCmmTicky"
+          "StgCmmUtils"
+          "StgCmmExtCode"
+          "SMRep"
+          "CoreArity"
+          "CoreFVs"
+          "CoreLint"
+          "CorePrep"
+          "CoreSubst"
+          "CoreOpt"
+          "CoreSyn"
+          "TrieMap"
+          "CoreTidy"
+          "CoreUnfold"
+          "CoreUtils"
+          "CoreMap"
+          "CoreSeq"
+          "CoreStats"
+          "MkCore"
+          "PprCore"
+          "PmExpr"
+          "TmOracle"
+          "Check"
+          "Coverage"
+          "Desugar"
+          "DsArrows"
+          "DsBinds"
+          "DsCCall"
+          "DsExpr"
+          "DsForeign"
+          "DsGRHSs"
+          "DsListComp"
+          "DsMonad"
+          "DsUsage"
+          "DsUtils"
+          "ExtractDocs"
+          "Match"
+          "MatchCon"
+          "MatchLit"
+          "HsBinds"
+          "HsDecls"
+          "HsDoc"
+          "HsExpr"
+          "HsImpExp"
+          "HsLit"
+          "PlaceHolder"
+          "HsExtension"
+          "HsInstances"
+          "HsPat"
+          "HsSyn"
+          "HsTypes"
+          "HsUtils"
+          "HsDumpAst"
+          "BinIface"
+          "BinFingerprint"
+          "BuildTyCl"
+          "IfaceEnv"
+          "IfaceSyn"
+          "IfaceType"
+          "ToIface"
+          "LoadIface"
+          "MkIface"
+          "TcIface"
+          "FlagChecker"
+          "Annotations"
+          "CmdLineParser"
+          "CodeOutput"
+          "Config"
+          "Constants"
+          "DriverMkDepend"
+          "DriverPhases"
+          "PipelineMonad"
+          "DriverPipeline"
+          "DynFlags"
+          "ErrUtils"
+          "Finder"
+          "GHC"
+          "GhcMake"
+          "GhcPlugins"
+          "DynamicLoading"
+          "HeaderInfo"
+          "HscMain"
+          "HscStats"
+          "HscTypes"
+          "InteractiveEval"
+          "InteractiveEvalTypes"
+          "PackageConfig"
+          "Packages"
+          "PlatformConstants"
+          "Plugins"
+          "TcPluginM"
+          "PprTyThing"
+          "StaticPtrTable"
+          "SysTools"
+          "SysTools/BaseDir"
+          "SysTools/Terminal"
+          "SysTools/ExtraObj"
+          "SysTools/Info"
+          "SysTools/Process"
+          "SysTools/Tasks"
+          "Elf"
+          "TidyPgm"
+          "Ctype"
+          "HaddockUtils"
+          "Lexer"
+          "OptCoercion"
+          "Parser"
+          "RdrHsSyn"
+          "ApiAnnotation"
+          "ForeignCall"
+          "KnownUniques"
+          "PrelInfo"
+          "PrelNames"
+          "PrelRules"
+          "PrimOp"
+          "TysPrim"
+          "TysWiredIn"
+          "CostCentre"
+          "CostCentreState"
+          "ProfInit"
+          "RnBinds"
+          "RnEnv"
+          "RnExpr"
+          "RnHsDoc"
+          "RnNames"
+          "RnPat"
+          "RnSource"
+          "RnSplice"
+          "RnTypes"
+          "RnFixity"
+          "RnUtils"
+          "RnUnbound"
+          "CoreMonad"
+          "CSE"
+          "FloatIn"
+          "FloatOut"
+          "LiberateCase"
+          "OccurAnal"
+          "SAT"
+          "SetLevels"
+          "SimplCore"
+          "SimplEnv"
+          "SimplMonad"
+          "SimplUtils"
+          "Simplify"
+          "SimplStg"
+          "StgStats"
+          "StgCse"
+          "StgLiftLams"
+          "StgLiftLams/Analysis"
+          "StgLiftLams/LiftM"
+          "StgLiftLams/Transformation"
+          "StgSubst"
+          "UnariseStg"
+          "RepType"
+          "Rules"
+          "SpecConstr"
+          "Specialise"
+          "CoreToStg"
+          "StgLint"
+          "StgSyn"
+          "StgFVs"
+          "CallArity"
+          "DmdAnal"
+          "Exitify"
+          "WorkWrap"
+          "WwLib"
+          "FamInst"
+          "ClsInst"
+          "Inst"
+          "TcAnnotations"
+          "TcArrows"
+          "TcBinds"
+          "TcSigs"
+          "TcClassDcl"
+          "TcDefaults"
+          "TcDeriv"
+          "TcDerivInfer"
+          "TcDerivUtils"
+          "TcEnv"
+          "TcExpr"
+          "TcForeign"
+          "TcGenDeriv"
+          "TcGenFunctor"
+          "TcGenGenerics"
+          "TcHsSyn"
+          "TcHsType"
+          "TcInstDcls"
+          "TcMType"
+          "TcValidity"
+          "TcMatches"
+          "TcPat"
+          "TcPatSyn"
+          "TcRnDriver"
+          "TcBackpack"
+          "TcRnExports"
+          "TcRnMonad"
+          "TcRnTypes"
+          "TcRules"
+          "TcSimplify"
+          "TcHoleErrors"
+          "TcErrors"
+          "TcTyClsDecls"
+          "TcTyDecls"
+          "TcTypeable"
+          "TcTypeableValidity"
+          "TcType"
+          "TcEvidence"
+          "TcEvTerm"
+          "TcUnify"
+          "TcInteract"
+          "TcCanonical"
+          "TcFlatten"
+          "TcSMonad"
+          "TcTypeNats"
+          "TcSplice"
+          "Class"
+          "Coercion"
+          "DsMeta"
+          "THNames"
+          "FamInstEnv"
+          "FunDeps"
+          "InstEnv"
+          "TyCon"
+          "CoAxiom"
+          "Kind"
+          "Type"
+          "TyCoRep"
+          "Unify"
+          "Bag"
+          "Binary"
+          "BooleanFormula"
+          "BufWrite"
+          "Digraph"
+          "Encoding"
+          "FastFunctions"
+          "FastMutInt"
+          "FastString"
+          "FastStringEnv"
+          "Fingerprint"
+          "FiniteMap"
+          "FV"
+          "GraphBase"
+          "GraphColor"
+          "GraphOps"
+          "GraphPpr"
+          "IOEnv"
+          "Json"
+          "ListSetOps"
+          "ListT"
+          "Maybes"
+          "MonadUtils"
+          "OrdList"
+          "Outputable"
+          "Pair"
+          "Panic"
+          "PlainPanic"
+          "PprColour"
+          "Pretty"
+          "State"
+          "Stream"
+          "StringBuffer"
+          "UniqDFM"
+          "UniqDSet"
+          "UniqFM"
+          "UniqMap"
+          "UniqSet"
+          "Util"
+          "Hoopl/Block"
+          "Hoopl/Collections"
+          "Hoopl/Dataflow"
+          "Hoopl/Graph"
+          "Hoopl/Label"
+          "AsmCodeGen"
+          "TargetReg"
+          "NCGMonad"
+          "Instruction"
+          "BlockLayout"
+          "CFG"
+          "Format"
+          "Reg"
+          "RegClass"
+          "PIC"
+          "Platform"
+          "CPrim"
+          "X86/Regs"
+          "X86/RegInfo"
+          "X86/Instr"
+          "X86/Cond"
+          "X86/Ppr"
+          "X86/CodeGen"
+          "PPC/Regs"
+          "PPC/RegInfo"
+          "PPC/Instr"
+          "PPC/Cond"
+          "PPC/Ppr"
+          "PPC/CodeGen"
+          "SPARC/Base"
+          "SPARC/Regs"
+          "SPARC/Imm"
+          "SPARC/AddrMode"
+          "SPARC/Cond"
+          "SPARC/Instr"
+          "SPARC/Stack"
+          "SPARC/ShortcutJump"
+          "SPARC/Ppr"
+          "SPARC/CodeGen"
+          "SPARC/CodeGen/Amode"
+          "SPARC/CodeGen/Base"
+          "SPARC/CodeGen/CondCode"
+          "SPARC/CodeGen/Gen32"
+          "SPARC/CodeGen/Gen64"
+          "SPARC/CodeGen/Sanity"
+          "SPARC/CodeGen/Expand"
+          "RegAlloc/Liveness"
+          "RegAlloc/Graph/Main"
+          "RegAlloc/Graph/Stats"
+          "RegAlloc/Graph/ArchBase"
+          "RegAlloc/Graph/ArchX86"
+          "RegAlloc/Graph/Coalesce"
+          "RegAlloc/Graph/Spill"
+          "RegAlloc/Graph/SpillClean"
+          "RegAlloc/Graph/SpillCost"
+          "RegAlloc/Graph/TrivColorable"
+          "RegAlloc/Linear/Main"
+          "RegAlloc/Linear/JoinToTargets"
+          "RegAlloc/Linear/State"
+          "RegAlloc/Linear/Stats"
+          "RegAlloc/Linear/FreeRegs"
+          "RegAlloc/Linear/StackMap"
+          "RegAlloc/Linear/Base"
+          "RegAlloc/Linear/X86/FreeRegs"
+          "RegAlloc/Linear/X86_64/FreeRegs"
+          "RegAlloc/Linear/PPC/FreeRegs"
+          "RegAlloc/Linear/SPARC/FreeRegs"
+          "Dwarf"
+          "Dwarf/Types"
+          "Dwarf/Constants"
+          "Convert"
+          "ByteCodeTypes"
+          "ByteCodeAsm"
+          "ByteCodeGen"
+          "ByteCodeInstr"
+          "ByteCodeItbls"
+          "ByteCodeLink"
+          "Debugger"
+          "Linker"
+          "RtClosureInspect"
+          "GHCi"
+          ];
+        cSources = [
+          "ghc/compiler/parser/cutils.c"
+          "ghc/compiler/cbits/genSym.c"
+          ];
+        hsSourceDirs = [
+          "lib/ghcjs-th"
+          "src"
+          "lib/ghc/autogen"
+          "ghc/compiler/backpack"
+          "ghc/compiler/basicTypes"
+          "ghc/compiler/cmm"
+          "ghc/compiler/codeGen"
+          "ghc/compiler/coreSyn"
+          "ghc/compiler/deSugar"
+          "ghc/compiler/ghci"
+          "ghc/compiler/hsSyn"
+          "ghc/compiler/iface"
+          "ghc/compiler/llvmGen"
+          "ghc/compiler/main"
+          "ghc/compiler/nativeGen"
+          "ghc/compiler/parser"
+          "ghc/compiler/prelude"
+          "ghc/compiler/profiling"
+          "ghc/compiler/rename"
+          "ghc/compiler/simplCore"
+          "ghc/compiler/simplStg"
+          "ghc/compiler/specialise"
+          "ghc/compiler/stgSyn"
+          "ghc/compiler/stranal"
+          "ghc/compiler/typecheck"
+          "ghc/compiler/types"
+          "ghc/compiler/utils"
+          "ghc/compiler/hieFile"
+          ] ++ (if system.isWindows
+          then [ "src-platform/windows" ]
+          else [ "src-platform/unix" ]);
+        includeDirs = [
+          "ghc/compiler"
+          "ghc/compiler/parser"
+          "ghc/compiler/utils"
+          "lib/ghc/includes"
+          "lib/ghc/autogen"
+          "ghc/includes"
+          ];
+        };
+      exes = {
+        "ghcjs" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."ghcjs" or (errorHandler.buildDepError "ghcjs"))
+            ];
+          buildable = true;
+          hsSourceDirs = [ "src-bin" ];
+          mainPath = [ "Main.hs" ];
+          };
+        "ghcjs-pkg" = {
+          depends = [
+            (hsPkgs."ghcjs" or (errorHandler.buildDepError "ghcjs"))
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+            (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal"))
+            (hsPkgs."binary" or (errorHandler.buildDepError "binary"))
+            (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+            (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot"))
+            ] ++ (pkgs.lib).optionals (!system.isWindows) [
+            (hsPkgs."unix" or (errorHandler.buildDepError "unix"))
+            (hsPkgs."terminfo" or (errorHandler.buildDepError "terminfo"))
+            ];
+          buildable = if flags.compiler-only then false else true;
+          cSources = (pkgs.lib).optional (system.isWindows) "cbits/CRT_noglob.c";
+          hsSourceDirs = [ "src-bin" ];
+          mainPath = (([
+            "Pkg.hs"
+            ] ++ (pkgs.lib).optional (flags.compiler-only) "") ++ (pkgs.lib).optional (!system.isWindows) "") ++ (pkgs.lib).optional (system.isWindows) "";
+          };
+        "ghcjs-boot" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."ghcjs" or (errorHandler.buildDepError "ghcjs"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal"))
+            (hsPkgs."mtl" or (errorHandler.buildDepError "mtl"))
+            (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+            (hsPkgs."lens" or (errorHandler.buildDepError "lens"))
+            (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers"))
+            (hsPkgs."vector" or (errorHandler.buildDepError "vector"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            (hsPkgs."aeson" or (errorHandler.buildDepError "aeson"))
+            (hsPkgs."text" or (errorHandler.buildDepError "text"))
+            (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+            (hsPkgs."optparse-applicative" or (errorHandler.buildDepError "optparse-applicative"))
+            (hsPkgs."tar" or (errorHandler.buildDepError "tar"))
+            (hsPkgs."yaml" or (errorHandler.buildDepError "yaml"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            (hsPkgs."time" or (errorHandler.buildDepError "time"))
+            (hsPkgs."unix-compat" or (errorHandler.buildDepError "unix-compat"))
+            (hsPkgs."executable-path" or (errorHandler.buildDepError "executable-path"))
+            ];
+          buildable = true;
+          hsSourceDirs = [ "src-bin" ];
+          mainPath = [ "Boot.hs" ] ++ (pkgs.lib).optional (system.isWindows) "";
+          };
+        "private-ghcjs-run" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            ];
+          buildable = if flags.compiler-only then false else true;
+          hsSourceDirs = [ "src-bin" ];
+          mainPath = ([
+            "Run.hs"
+            ] ++ (pkgs.lib).optional (flags.compiler-only) "") ++ (pkgs.lib).optional (system.isWindows) "";
+          };
+        "private-ghcjs-wrapper" = {
+          buildable = if flags.compiler-only || !system.isWindows
+            then false
+            else true;
+          cSources = [
+            "ghc/driver/utils/getLocation.c"
+            "ghc/driver/utils/cwrapper.c"
+            "utils/wrapper/getline.c"
+            ];
+          hsSourceDirs = [ "utils/wrapper" ];
+          includeDirs = [ "ghc/driver/utils" ];
+          includes = [
+            "ghc/driver/utils/cwrapper.h"
+            "ghc/driver/utils/getLocation.h"
+            "utils/wrapper/getline.h"
+            ];
+          mainPath = [
+            "wrapper.c"
+            ] ++ (pkgs.lib).optional (flags.compiler-only || !system.isWindows) "";
+          };
+        "private-ghcjs-unlit" = {
+          buildable = if flags.compiler-only then false else true;
+          cSources = [ "ghc/utils/unlit/fs.c" ];
+          hsSourceDirs = [ "ghc/utils/unlit" ];
+          includes = [ "ghc/utils/unlit/fs.h" ];
+          mainPath = [
+            "unlit.c"
+            ] ++ (pkgs.lib).optional (flags.compiler-only) "";
+          };
+        "private-ghcjs-touchy" = {
+          buildable = if flags.compiler-only || !system.isWindows
+            then false
+            else true;
+          hsSourceDirs = [ "ghc/utils/touchy" ];
+          mainPath = [
+            "touchy.c"
+            ] ++ (pkgs.lib).optional (flags.compiler-only || !system.isWindows) "";
+          };
+        "private-ghcjs-hsc2hs" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            ];
+          buildable = if flags.compiler-only then false else true;
+          modules = [
+            "C"
+            "Common"
+            "CrossCodegen"
+            "DirectCodegen"
+            "Flags"
+            "HSCParser"
+            "ATTParser"
+            "UtilsCodegen"
+            "Compat/ResponseFile"
+            "Paths_ghcjs"
+            ];
+          hsSourceDirs = [ "ghc/utils/hsc2hs" ];
+          mainPath = [
+            "Main.hs"
+            ] ++ (pkgs.lib).optional (flags.compiler-only) "";
+          };
+        "haddock" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            ] ++ (pkgs.lib).optionals true [
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."containers" or (errorHandler.buildDepError "containers"))
+            (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq"))
+            (hsPkgs."array" or (errorHandler.buildDepError "array"))
+            (hsPkgs."xhtml" or (errorHandler.buildDepError "xhtml"))
+            (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal"))
+            (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot"))
+            (hsPkgs."ghcjs" or (errorHandler.buildDepError "ghcjs"))
+            (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+            (hsPkgs."parsec" or (errorHandler.buildDepError "parsec"))
+            (hsPkgs."text" or (errorHandler.buildDepError "text"))
+            (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+            ];
+          buildable = if flags.compiler-only then false else true;
+          modules = (pkgs.lib).optionals true [
+            "Documentation/Haddock/Parser"
+            "Documentation/Haddock/Parser/Monad"
+            "Documentation/Haddock/Parser/Identifier"
+            "Documentation/Haddock/Types"
+            "Documentation/Haddock/Doc"
+            "Documentation/Haddock/Parser/Util"
+            "Documentation/Haddock/Markup"
+            "Documentation/Haddock"
+            "Haddock"
+            "Haddock/Interface"
+            "Haddock/Interface/Json"
+            "Haddock/Interface/Rename"
+            "Haddock/Interface/Create"
+            "Haddock/Interface/AttachInstances"
+            "Haddock/Interface/LexParseRn"
+            "Haddock/Interface/ParseModuleHeader"
+            "Haddock/Interface/Specialize"
+            "Haddock/Parser"
+            "Haddock/Utils"
+            "Haddock/Utils/Json"
+            "Haddock/Backends/Xhtml"
+            "Haddock/Backends/Xhtml/Decl"
+            "Haddock/Backends/Xhtml/DocMarkup"
+            "Haddock/Backends/Xhtml/Layout"
+            "Haddock/Backends/Xhtml/Meta"
+            "Haddock/Backends/Xhtml/Names"
+            "Haddock/Backends/Xhtml/Themes"
+            "Haddock/Backends/Xhtml/Types"
+            "Haddock/Backends/Xhtml/Utils"
+            "Haddock/Backends/LaTeX"
+            "Haddock/Backends/HaddockDB"
+            "Haddock/Backends/Hoogle"
+            "Haddock/Backends/Hyperlinker"
+            "Haddock/Backends/Hyperlinker/Parser"
+            "Haddock/Backends/Hyperlinker/Renderer"
+            "Haddock/Backends/Hyperlinker/Types"
+            "Haddock/Backends/Hyperlinker/Utils"
+            "Haddock/ModuleTree"
+            "Haddock/Types"
+            "Haddock/Doc"
+            "Haddock/Version"
+            "Haddock/InterfaceFile"
+            "Haddock/Options"
+            "Haddock/GhcUtils"
+            "Haddock/Syb"
+            "Haddock/Convert"
+            "Paths_ghcjs"
+            ];
+          hsSourceDirs = [ "src-bin" ] ++ (pkgs.lib).optionals true [
+            "ghc/utils/haddock/haddock-api/src"
+            "ghc/utils/haddock/haddock-library/src"
+            ];
+          mainPath = ([
+            "HaddockDriver.hs"
+            ] ++ (pkgs.lib).optional (flags.compiler-only) "") ++ (pkgs.lib).optional true "";
+          };
+        "ghcjs-dumparchive" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."text" or (errorHandler.buildDepError "text"))
+            (hsPkgs."ghcjs" or (errorHandler.buildDepError "ghcjs"))
+            (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            ];
+          buildable = if flags.compiler-only then false else true;
+          hsSourceDirs = [ "utils" ];
+          mainPath = ([
+            "dumpArchive.hs"
+            ] ++ (pkgs.lib).optional (flags.compiler-only) "") ++ (pkgs.lib).optional (system.isWindows) "";
+          };
+        };
+      tests = {
+        "test" = {
+          depends = [
+            (hsPkgs."base" or (errorHandler.buildDepError "base"))
+            (hsPkgs."process" or (errorHandler.buildDepError "process"))
+            (hsPkgs."network" or (errorHandler.buildDepError "network"))
+            (hsPkgs."aeson" or (errorHandler.buildDepError "aeson"))
+            (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework"))
+            (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit"))
+            (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit"))
+            (hsPkgs."filepath" or (errorHandler.buildDepError "filepath"))
+            (hsPkgs."text" or (errorHandler.buildDepError "text"))
+            (hsPkgs."transformers" or (errorHandler.buildDepError "transformers"))
+            (hsPkgs."lens" or (errorHandler.buildDepError "lens"))
+            (hsPkgs."random" or (errorHandler.buildDepError "random"))
+            (hsPkgs."time" or (errorHandler.buildDepError "time"))
+            (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring"))
+            (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq"))
+            (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers"))
+            (hsPkgs."shelly" or (errorHandler.buildDepError "shelly"))
+            (hsPkgs."data-default" or (errorHandler.buildDepError "data-default"))
+            (hsPkgs."yaml" or (errorHandler.buildDepError "yaml"))
+            (hsPkgs."optparse-applicative" or (errorHandler.buildDepError "optparse-applicative"))
+            (hsPkgs."directory" or (errorHandler.buildDepError "directory"))
+            (hsPkgs."http-types" or (errorHandler.buildDepError "http-types"))
+            (hsPkgs."warp" or (errorHandler.buildDepError "warp"))
+            (hsPkgs."wai" or (errorHandler.buildDepError "wai"))
+            (hsPkgs."wai-extra" or (errorHandler.buildDepError "wai-extra"))
+            (hsPkgs."wai-app-static" or (errorHandler.buildDepError "wai-app-static"))
+            (hsPkgs."wai-websockets" or (errorHandler.buildDepError "wai-websockets"))
+            (hsPkgs."websockets" or (errorHandler.buildDepError "websockets"))
+            (hsPkgs."webdriver" or (errorHandler.buildDepError "webdriver"))
+            (hsPkgs."lifted-base" or (errorHandler.buildDepError "lifted-base"))
+            ];
+          buildable = true;
+          modules = [ "Server" "Client" "Types" ];
+          hsSourceDirs = [ "test" ];
+          mainPath = [ "TestRunner.hs" ];
+          };
+        };
+      };
+    } // rec { src = (pkgs.lib).mkDefault ../.; }
--- a/materialized/ghcjs884/default.nix
+++ b/materialized/ghcjs884/default.nix
@ -0,0 +1,377 @@
+{
+  pkgs = hackage:
+    {
+      packages = {
+        "warp".revision = (((hackage."warp")."3.3.10").revisions).default;
+        "warp".flags.allow-sendfilefd = true;
+        "warp".flags.network-bytestring = false;
+        "warp".flags.warp-debug = false;
+        "test-framework-hunit".revision = (((hackage."test-framework-hunit")."0.3.0.2").revisions).default;
+        "test-framework-hunit".flags.base4 = true;
+        "test-framework-hunit".flags.base3 = false;
+        "http-client".revision = (((hackage."http-client")."0.6.4.1").revisions).default;
+        "http-client".flags.network-uri = true;
+        "wai-websockets".revision = (((hackage."wai-websockets")."3.0.1.2").revisions).default;
+        "wai-websockets".flags.example = true;
+        "cookie".revision = (((hackage."cookie")."0.4.5").revisions).default;
+        "void".revision = (((hackage."void")."0.7.3").revisions).default;
+        "void".flags.safe = false;
+        "semigroupoids".revision = (((hackage."semigroupoids")."5.3.4").revisions).default;
+        "semigroupoids".flags.comonad = true;
+        "semigroupoids".flags.doctests = true;
+        "semigroupoids".flags.unordered-containers = true;
+        "semigroupoids".flags.distributive = true;
+        "semigroupoids".flags.tagged = true;
+        "semigroupoids".flags.containers = true;
+        "semigroupoids".flags.contravariant = true;
+        "byteorder".revision = (((hackage."byteorder")."1.0.4").revisions).default;
+        "free".revision = (((hackage."free")."5.1.3").revisions).default;
+        "zip-archive".revision = (((hackage."zip-archive")."0.4.1").revisions).default;
+        "zip-archive".flags.executable = false;
+        "exceptions".revision = (((hackage."exceptions")."0.10.4").revisions).default;
+        "exceptions".flags.transformers-0-4 = true;
+        "ghc-paths".revision = (((hackage."ghc-paths")."0.1.0.12").revisions).default;
+        "binary".revision = (((hackage."binary")."0.8.7.0").revisions).default;
+        "ghc-boot".revision = (((hackage."ghc-boot")."8.8.4").revisions).default;
+        "wl-pprint-text".revision = (((hackage."wl-pprint-text")."1.2.0.1").revisions).default;
+        "tar".revision = (((hackage."tar")."0.5.1.1").revisions).default;
+        "tar".flags.old-time = false;
+        "tar".flags.old-bytestring = false;
+        "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;
+        "old-time".revision = (((hackage."old-time")."1.1.0.3").revisions).default;
+        "bifunctors".revision = (((hackage."bifunctors")."5.5.7").revisions).default;
+        "bifunctors".flags.semigroups = true;
+        "bifunctors".flags.tagged = true;
+        "split".revision = (((hackage."split")."0.2.3.4").revisions).default;
+        "stm".revision = (((hackage."stm")."2.5.0.0").revisions).default;
+        "unix-time".revision = (((hackage."unix-time")."0.4.7").revisions).default;
+        "http2".revision = (((hackage."http2")."2.0.4").revisions).default;
+        "http2".flags.devel = false;
+        "base-compat-batteries".revision = (((hackage."base-compat-batteries")."0.11.1").revisions).default;
+        "appar".revision = (((hackage."appar")."0.1.8").revisions).default;
+        "hourglass".revision = (((hackage."hourglass")."0.2.12").revisions).default;
+        "case-insensitive".revision = (((hackage."case-insensitive")."1.2.1.0").revisions).default;
+        "network-byte-order".revision = (((hackage."network-byte-order")."0.1.4.0").revisions).default;
+        "extensible-exceptions".revision = (((hackage."extensible-exceptions")."0.1.1.4").revisions).default;
+        "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;
+        "SHA".revision = (((hackage."SHA")."1.6.4.4").revisions).default;
+        "SHA".flags.exe = false;
+        "ghc-heap".revision = (((hackage."ghc-heap")."8.8.4").revisions).default;
+        "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;
+        "lifted-async".revision = (((hackage."lifted-async")."0.10.0.6").revisions).default;
+        "network-uri".revision = (((hackage."network-uri")."2.6.3.0").revisions).default;
+        "asn1-parse".revision = (((hackage."asn1-parse")."0.9.5").revisions).default;
+        "regex-base".revision = (((hackage."regex-base")."0.94.0.0").revisions).default;
+        "zlib".revision = (((hackage."zlib")."0.6.2.1").revisions).default;
+        "zlib".flags.non-blocking-ffi = false;
+        "zlib".flags.pkg-config = false;
+        "rts".revision = (((hackage."rts")."1.0").revisions).default;
+        "easy-file".revision = (((hackage."easy-file")."0.2.2").revisions).default;
+        "ghci".revision = (((hackage."ghci")."8.8.4").revisions).default;
+        "regex-posix".revision = (((hackage."regex-posix")."0.96.0.0").revisions).default;
+        "regex-posix".flags._regex-posix-clib = false;
+        "cryptonite".revision = (((hackage."cryptonite")."0.26").revisions).default;
+        "cryptonite".flags.support_sse = false;
+        "cryptonite".flags.integer-gmp = true;
+        "cryptonite".flags.support_rdrand = true;
+        "cryptonite".flags.support_aesni = true;
+        "cryptonite".flags.support_deepseq = true;
+        "cryptonite".flags.support_pclmuldq = false;
+        "cryptonite".flags.check_alignment = false;
+        "cryptonite".flags.old_toolchain_inliner = false;
+        "clock".revision = (((hackage."clock")."0.8").revisions).default;
+        "clock".flags.llvm = false;
+        "adjunctions".revision = (((hackage."adjunctions")."4.4").revisions).default;
+        "invariant".revision = (((hackage."invariant")."0.5.3").revisions).default;
+        "enclosed-exceptions".revision = (((hackage."enclosed-exceptions")."1.0.3").revisions).default;
+        "pem".revision = (((hackage."pem")."0.2.4").revisions).default;
+        "executable-path".revision = (((hackage."executable-path")."0.0.3.1").revisions).default;
+        "syb".revision = (((hackage."syb")."0.7.1").revisions).default;
+        "distributive".revision = (((hackage."distributive")."0.6.2").revisions).default;
+        "distributive".flags.semigroups = true;
+        "distributive".flags.tagged = true;
+        "asn1-encoding".revision = (((hackage."asn1-encoding")."0.9.6").revisions).default;
+        "bytestring-builder".revision = (((hackage."bytestring-builder")."0.10.8.2.0").revisions).default;
+        "bytestring-builder".flags.bytestring_has_builder = true;
+        "scientific".revision = (((hackage."scientific")."0.3.6.2").revisions).default;
+        "scientific".flags.integer-simple = false;
+        "scientific".flags.bytestring-builder = false;
+        "time-manager".revision = (((hackage."time-manager")."0.0.0").revisions).default;
+        "parallel".revision = (((hackage."parallel")."3.2.2.0").revisions).default;
+        "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;
+        "random".revision = (((hackage."random")."1.1").revisions).default;
+        "temporary".revision = (((hackage."temporary")."1.3").revisions).default;
+        "uuid-types".revision = (((hackage."uuid-types")."1.0.3").revisions).default;
+        "optparse-applicative".revision = (((hackage."optparse-applicative")."0.15.1.0").revisions).default;
+        "network".revision = (((hackage."network")."3.1.1.1").revisions).default;
+        "word8".revision = (((hackage."word8")."0.1.3").revisions).default;
+        "async".revision = (((hackage."async")."2.2.2").revisions).default;
+        "async".flags.bench = false;
+        "dlist".revision = (((hackage."dlist")."0.8.0.8").revisions).default;
+        "websockets".revision = (((hackage."websockets")."0.12.7.0").revisions).default;
+        "websockets".flags.example = false;
+        "conduit".revision = (((hackage."conduit")."1.3.2").revisions).default;
+        "constraints".revision = (((hackage."constraints")."0.12").revisions).default;
+        "ghc-compact".revision = (((hackage."ghc-compact")."0.1.0.0").revisions).default;
+        "semigroups".revision = (((hackage."semigroups")."0.19.1").revisions).default;
+        "semigroups".flags.bytestring = true;
+        "semigroups".flags.unordered-containers = true;
+        "semigroups".flags.text = true;
+        "semigroups".flags.tagged = true;
+        "semigroups".flags.containers = true;
+        "semigroups".flags.binary = true;
+        "semigroups".flags.hashable = true;
+        "semigroups".flags.transformers = true;
+        "semigroups".flags.deepseq = true;
+        "semigroups".flags.bytestring-builder = false;
+        "semigroups".flags.template-haskell = true;
+        "data-default".revision = (((hackage."data-default")."0.7.1.1").revisions).default;
+        "HUnit".revision = (((hackage."HUnit")."1.6.0.0").revisions).default;
+        "lifted-base".revision = (((hackage."lifted-base")."0.2.3.12").revisions).default;
+        "data-default-instances-old-locale".revision = (((hackage."data-default-instances-old-locale")."0.0.1").revisions).default;
+        "parsec".revision = (((hackage."parsec")."3.1.14.0").revisions).default;
+        "hsc2hs".revision = (((hackage."hsc2hs")."0.68.7").revisions).default;
+        "hsc2hs".flags.in-ghc-tree = false;
+        "directory".revision = (((hackage."directory")."1.3.6.0").revisions).default;
+        "yaml".revision = (((hackage."yaml")."0.11.3.0").revisions).default;
+        "yaml".flags.no-exe = true;
+        "yaml".flags.no-examples = true;
+        "transformers-compat".revision = (((hackage."transformers-compat")."0.6.5").revisions).default;
+        "transformers-compat".flags.five = false;
+        "transformers-compat".flags.generic-deriving = true;
+        "transformers-compat".flags.two = false;
+        "transformers-compat".flags.five-three = true;
+        "transformers-compat".flags.mtl = true;
+        "transformers-compat".flags.four = false;
+        "transformers-compat".flags.three = false;
+        "template-haskell".revision = (((hackage."template-haskell")."2.15.0.0").revisions).default;
+        "mono-traversable".revision = (((hackage."mono-traversable")."1.0.15.1").revisions).default;
+        "psqueues".revision = (((hackage."psqueues")."0.2.7.2").revisions).default;
+        "vector".revision = (((hackage."vector")."0.12.1.2").revisions).default;
+        "vector".flags.unsafechecks = false;
+        "vector".flags.internalchecks = false;
+        "vector".flags.wall = false;
+        "vector".flags.boundschecks = true;
+        "call-stack".revision = (((hackage."call-stack")."0.2.0").revisions).default;
+        "primitive".revision = (((hackage."primitive")."0.7.0.1").revisions).default;
+        "cryptohash".revision = (((hackage."cryptohash")."0.11.9").revisions).default;
+        "profunctors".revision = (((hackage."profunctors")."5.5.2").revisions).default;
+        "safe".revision = (((hackage."safe")."0.3.18").revisions).default;
+        "blaze-builder".revision = (((hackage."blaze-builder")."0.4.1.0").revisions).default;
+        "base-compat".revision = (((hackage."base-compat")."0.11.1").revisions).default;
+        "time-compat".revision = (((hackage."time-compat")."1.9.3").revisions).default;
+        "time-compat".flags.old-locale = false;
+        "ansi-terminal".revision = (((hackage."ansi-terminal")."0.10.3").revisions).default;
+        "ansi-terminal".flags.example = false;
+        "tagged".revision = (((hackage."tagged")."0.8.6").revisions).default;
+        "tagged".flags.transformers = true;
+        "tagged".flags.deepseq = true;
+        "x509".revision = (((hackage."x509")."1.7.5").revisions).default;
+        "lens".revision = (((hackage."lens")."4.18.1").revisions).default;
+        "lens".flags.j = false;
+        "lens".flags.test-properties = true;
+        "lens".flags.old-inline-pragmas = false;
+        "lens".flags.test-templates = true;
+        "lens".flags.trustworthy = true;
+        "lens".flags.test-doctests = true;
+        "lens".flags.benchmark-uniplate = false;
+        "lens".flags.inlining = true;
+        "lens".flags.dump-splices = false;
+        "lens".flags.test-hunit = true;
+        "lens".flags.safe = false;
+        "unliftio-core".revision = (((hackage."unliftio-core")."0.2.0.1").revisions).default;
+        "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;
+        "integer-logarithms".revision = (((hackage."integer-logarithms")."1.0.3").revisions).default;
+        "integer-logarithms".flags.check-bounds = false;
+        "integer-logarithms".flags.integer-gmp = true;
+        "reflection".revision = (((hackage."reflection")."2.1.5").revisions).default;
+        "reflection".flags.slow = false;
+        "reflection".flags.template-haskell = true;
+        "streaming-commons".revision = (((hackage."streaming-commons")."0.2.1.2").revisions).default;
+        "streaming-commons".flags.use-bytestring-builder = false;
+        "shelly".revision = (((hackage."shelly")."1.9.0").revisions).default;
+        "shelly".flags.build-examples = false;
+        "shelly".flags.lifted = false;
+        "bytestring".revision = (((hackage."bytestring")."0.10.10.1").revisions).default;
+        "ansi-wl-pprint".revision = (((hackage."ansi-wl-pprint")."0.6.9").revisions).default;
+        "ansi-wl-pprint".flags.example = false;
+        "wai".revision = (((hackage."wai")."3.2.2.1").revisions).default;
+        "basement".revision = (((hackage."basement")."0.0.11").revisions).default;
+        "test-framework".revision = (((hackage."test-framework")."0.8.2.0").revisions).default;
+        "hostname".revision = (((hackage."hostname")."1.0").revisions).default;
+        "old-locale".revision = (((hackage."old-locale")."1.0.0.7").revisions).default;
+        "directory-tree".revision = (((hackage."directory-tree")."0.12.1").revisions).default;
+        "StateVar".revision = (((hackage."StateVar")."1.2").revisions).default;
+        "vault".revision = (((hackage."vault")."0.3.1.4").revisions).default;
+        "vault".flags.useghc = true;
+        "mime-types".revision = (((hackage."mime-types")."0.1.0.9").revisions).default;
+        "contravariant".revision = (((hackage."contravariant")."1.5.2").revisions).default;
+        "contravariant".flags.semigroups = true;
+        "contravariant".flags.tagged = true;
+        "contravariant".flags.statevar = true;
+        "data-default-instances-dlist".revision = (((hackage."data-default-instances-dlist")."0.0.1").revisions).default;
+        "xhtml".revision = (((hackage."xhtml")."3000.2.2.1").revisions).default;
+        "type-equality".revision = (((hackage."type-equality")."1").revisions).default;
+        "blaze-markup".revision = (((hackage."blaze-markup")."0.8.2.5").revisions).default;
+        "text".revision = (((hackage."text")."1.2.4.0").revisions).default;
+        "Cabal".revision = (((hackage."Cabal")."3.0.2.0").revisions).default;
+        "Cabal".flags.bundled-binary-generic = false;
+        "unordered-containers".revision = (((hackage."unordered-containers")."0.2.10.0").revisions).default;
+        "unordered-containers".flags.debug = false;
+        "base64-bytestring".revision = (((hackage."base64-bytestring")."1.0.0.3").revisions).default;
+        "base".revision = (((hackage."base")."4.13.0.0").revisions).default;
+        "comonad".revision = (((hackage."comonad")."5.0.6").revisions).default;
+        "comonad".flags.distributive = true;
+        "comonad".flags.test-doctests = true;
+        "comonad".flags.containers = true;
+        "time".revision = (((hackage."time")."1.9.3").revisions).default;
+        "data-default-class".revision = (((hackage."data-default-class")."0.1.2.0").revisions).default;
+        "terminfo".revision = (((hackage."terminfo")."0.4.1.4").revisions).default;
+        "base16-bytestring".revision = (((hackage."base16-bytestring")."0.1.1.6").revisions).default;
+        "vector-algorithms".revision = (((hackage."vector-algorithms")."0.8.0.3").revisions).default;
+        "vector-algorithms".flags.unsafechecks = false;
+        "vector-algorithms".flags.internalchecks = false;
+        "vector-algorithms".flags.llvm = false;
+        "vector-algorithms".flags.boundschecks = true;
+        "vector-algorithms".flags.bench = true;
+        "vector-algorithms".flags.properties = true;
+        "iproute".revision = (((hackage."iproute")."1.7.9").revisions).default;
+        "transformers".revision = (((hackage."transformers")."0.5.6.2").revisions).default;
+        "hashable".revision = (((hackage."hashable")."1.3.0.0").revisions).default;
+        "hashable".flags.sse2 = true;
+        "hashable".flags.integer-gmp = true;
+        "hashable".flags.sse41 = false;
+        "hashable".flags.examples = false;
+        "wai-extra".revision = (((hackage."wai-extra")."3.0.29.1").revisions).default;
+        "wai-extra".flags.build-example = false;
+        "data-default-instances-containers".revision = (((hackage."data-default-instances-containers")."0.0.1").revisions).default;
+        "attoparsec".revision = (((hackage."attoparsec")."0.13.2.4").revisions).default;
+        "attoparsec".flags.developer = false;
+        "blaze-html".revision = (((hackage."blaze-html")."0.9.1.2").revisions).default;
+        "digest".revision = (((hackage."digest")."0.0.1.2").revisions).default;
+        "digest".flags.bytestring-in-base = false;
+        "colour".revision = (((hackage."colour")."2.3.5").revisions).default;
+        "transformers-base".revision = (((hackage."transformers-base")."0.4.5.2").revisions).default;
+        "transformers-base".flags.orphaninstances = true;
+        "happy".revision = (((hackage."happy")."1.19.12").revisions).default;
+        "happy".flags.small_base = true;
+        "file-embed".revision = (((hackage."file-embed")."0.0.11.2").revisions).default;
+        "byteable".revision = (((hackage."byteable")."0.1.1").revisions).default;
+        "hpc".revision = (((hackage."hpc")."0.6.0.3").revisions).default;
+        "entropy".revision = (((hackage."entropy")."0.4.1.6").revisions).default;
+        "entropy".flags.halvm = false;
+        "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;
+        "auto-update".revision = (((hackage."auto-update")."0.1.6").revisions).default;
+        "asn1-types".revision = (((hackage."asn1-types")."0.3.4").revisions).default;
+        "stringsearch".revision = (((hackage."stringsearch")."0.3.6.6").revisions).default;
+        "stringsearch".flags.base4 = true;
+        "stringsearch".flags.base3 = false;
+        "unix-compat".revision = (((hackage."unix-compat")."0.5.2").revisions).default;
+        "unix-compat".flags.old-time = false;
+        "monad-control".revision = (((hackage."monad-control")."1.0.2.3").revisions).default;
+        "process".revision = (((hackage."process")."1.6.9.0").revisions).default;
+        "kan-extensions".revision = (((hackage."kan-extensions")."5.2").revisions).default;
+        "wai-logger".revision = (((hackage."wai-logger")."2.3.6").revisions).default;
+        "libyaml".revision = (((hackage."libyaml")."0.1.2").revisions).default;
+        "libyaml".flags.system-libyaml = false;
+        "libyaml".flags.no-unicode = false;
+        "resourcet".revision = (((hackage."resourcet")."1.2.4").revisions).default;
+        "webdriver".revision = (((hackage."webdriver")."0.9.0.1").revisions).default;
+        "webdriver".flags.network-uri = true;
+        "webdriver".flags.developer = false;
+        "pretty".revision = (((hackage."pretty")."1.1.3.6").revisions).default;
+        "cabal-doctest".revision = (((hackage."cabal-doctest")."1.0.8").revisions).default;
+        "aeson".revision = (((hackage."aeson")."1.4.7.1").revisions).default;
+        "aeson".flags.cffi = false;
+        "aeson".flags.fast = false;
+        "aeson".flags.bytestring-builder = false;
+        "aeson".flags.developer = false;
+        "wai-app-static".revision = (((hackage."wai-app-static")."3.1.7.1").revisions).default;
+        "wai-app-static".flags.print = false;
+        "http-types".revision = (((hackage."http-types")."0.12.3").revisions).default;
+        "ghc-boot-th".revision = (((hackage."ghc-boot-th")."8.8.4").revisions).default;
+        "base-orphans".revision = (((hackage."base-orphans")."0.8.2").revisions).default;
+        "http-date".revision = (((hackage."http-date")."0.0.8").revisions).default;
+        "th-abstraction".revision = (((hackage."th-abstraction")."0.3.2.0").revisions).default;
+        "memory".revision = (((hackage."memory")."0.15.0").revisions).default;
+        "memory".flags.support_bytestring = true;
+        "memory".flags.support_basement = true;
+        "memory".flags.support_foundation = true;
+        "memory".flags.support_deepseq = true;
+        "fast-logger".revision = (((hackage."fast-logger")."3.0.1").revisions).default;
+        "bsb-http-chunked".revision = (((hackage."bsb-http-chunked")."0.0.0.4").revisions).default;
+        "array".revision = (((hackage."array")."0.5.4.0").revisions).default;
+        "xml".revision = (((hackage."xml")."1.3.14").revisions).default;
+        "simple-sendfile".revision = (((hackage."simple-sendfile")."0.2.30").revisions).default;
+        "simple-sendfile".flags.allow-bsd = true;
+        "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;
+        };
+      compiler = {
+        version = "8.8.4";
+        nix-name = "ghc884";
+        packages = {
+          "binary" = "0.8.7.0";
+          "ghc-boot" = "8.8.4";
+          "ghc-prim" = "0.5.3";
+          "stm" = "2.5.0.0";
+          "unix" = "2.7.2.2";
+          "ghc-heap" = "8.8.4";
+          "mtl" = "2.2.2";
+          "rts" = "1.0";
+          "ghci" = "8.8.4";
+          "deepseq" = "1.4.4.0";
+          "ghc-compact" = "0.1.0.0";
+          "parsec" = "3.1.14.0";
+          "directory" = "1.3.6.0";
+          "template-haskell" = "2.15.0.0";
+          "containers" = "0.6.2.1";
+          "bytestring" = "0.10.10.1";
+          "xhtml" = "3000.2.2.1";
+          "text" = "1.2.4.0";
+          "base" = "4.13.0.0";
+          "time" = "1.9.3";
+          "terminfo" = "0.4.1.4";
+          "transformers" = "0.5.6.2";
+          "hpc" = "0.6.0.3";
+          "filepath" = "1.4.2.1";
+          "process" = "1.6.9.0";
+          "pretty" = "1.1.3.6";
+          "ghc-boot-th" = "8.8.4";
+          "array" = "0.5.4.0";
+          "integer-gmp" = "1.0.2.0";
+          };
+        };
+      };
+  extras = hackage:
+    {
+      packages = {
+        ghcjs-th = ./.plan.nix/ghcjs-th.nix;
+        ghcjs = ./.plan.nix/ghcjs.nix;
+        };
+      };
+  modules = [
+    ({ lib, ... }:
+      {
+        packages = {
+          "ghcjs-th" = {
+            flags = { "use-host-template-haskell" = lib.mkOverride 900 false; };
+            };
+          "ghcjs" = {
+            flags = {
+              "compiler-only" = lib.mkOverride 900 false;
+              "stage1" = lib.mkOverride 900 false;
+              "runtime-assertions" = lib.mkOverride 900 false;
+              "no-wrapper-install" = lib.mkOverride 900 false;
+              "stage2" = lib.mkOverride 900 true;
+              "debug" = lib.mkOverride 900 false;
+              "stage3" = lib.mkOverride 900 false;
+              "use-host-template-haskell" = lib.mkOverride 900 true;
+              "disable-optimizer" = lib.mkOverride 900 false;
+              "ghci" = lib.mkOverride 900 true;
+              "terminfo" = lib.mkOverride 900 true;
+              };
+            };
+          };
+        })
+    ];
+  }
--- a/modules/component-driver.nix
+++ b/modules/component-driver.nix
@ -76,6 +76,7 @@ in
  config.bootPkgs =  [
      "rts" "ghc-boot-th"
      "ghc-heap" # since ghc 8.6.
+      "ghcjs-prim"
    ] ++ lib.optional (!config.reinstallableLibGhc) "ghc";

  options.hsPkgs = lib.mkOption {
@ -83,7 +84,7 @@ in
  };

  config.hsPkgs =
-    { inherit (builder) shellFor ghcWithPackages ghcWithHoogle;
+    { inherit (builder) shellFor makeConfigFiles ghcWithPackages ghcWithHoogle;
      buildPackages = buildModules.config.hsPkgs;
    } //
    lib.mapAttrs
--- a/overlays/bootstrap.nix
+++ b/overlays/bootstrap.nix
@ -394,7 +394,10 @@ in {
                ghc-patches = ghc-patches "8.10.2"
                 ++ [ ./patches/ghc/core-field.patch ];
            };
-        } // final.lib.optionalAttrs (final.targetPlatform.isGhcjs or false)
+        } // final.lib.optionalAttrs (final.targetPlatform.isGhcjs or false) (
+         if final.hostPlatform.isGhcjs
+           then throw "An attempt was made to build ghcjs with ghcjs (perhaps use `buildPackages` when refering to ghc)"
+           else
                # This will inject `exactDeps` and `envDeps`  into the ghcjs
                # compiler defined below.  This is crucial to build packages
                # with the current use of env and exact Deps.
@ -409,16 +412,13 @@ in {
                ghcjsSrcJson = ../compiler/ghcjs/ghcjs-src.json;
                ghcjsVersion =  "8.6.0.1";
                ghc = buildGHC;
-                cabal-install = final.buildPackages.haskell-nix.cabal-install;
-                # The alex from the bootstrap packages is apparently broken, and will fail with something like:
-                # > alex: /nix/store/f7b78rg9pmqgvxvsqfzh1przp7pxii5a-alex-3.2.4-exe-alex/share/x86_64-osx-ghc-8.4.4/alex-3.2.4-1pf5faR9dBuJ8mryql0DoA-alex/AlexTemplate-ghc-nopred: openFile: does not exist (No such file or directory)
-                # inherit (final.buildPackages.haskell-nix.bootstrap.packages) alex happy;
            }; in let targetPrefix = "js-unknown-ghcjs-"; in final.runCommand "${targetPrefix}ghc-8.6.5" {
                passthru = {
                    inherit targetPrefix;
                    version = "8.6.5";
                    isHaskellNixCompiler = true;
-                    inherit (ghcjs865) configured-src;
+                    enableShared = false;
+                    inherit (ghcjs865) configured-src bundled-ghcjs project;
                    inherit buildGHC;
                    extraConfigureFlags = [
                        "--ghcjs"
@ -440,7 +440,77 @@ in {
                cd lib
                cp -R ${ghcjs865}/lib/ghcjs-8.6.5 ${targetPrefix}ghc-8.6.5
            '' + installDeps targetPrefix);
-        })));
+            ghc883 = let buildGHC = final.buildPackages.haskell-nix.compiler.ghc883;
+                in let ghcjs883 = final.callPackage ../compiler/ghcjs/ghcjs.nix {
+                ghcjsSrcJson = ../compiler/ghcjs/ghcjs88-src.json;
+                ghcjsVersion =  "8.8.0.0.1";
+                ghc = buildGHC;
+                ghcVersion = "8.8.3";
+                compiler-nix-name = "ghc883";
+            }; in let targetPrefix = "js-unknown-ghcjs-"; in final.runCommand "${targetPrefix}ghc-8.8.3" {
+                passthru = {
+                    inherit targetPrefix;
+                    version = "8.8.3";
+                    isHaskellNixCompiler = true;
+                    enableShared = false;
+                    inherit (ghcjs883) configured-src bundled-ghcjs project;
+                    inherit buildGHC;
+                    extraConfigureFlags = [
+                        "--ghcjs"
+                        "--with-ghcjs=${targetPrefix}ghc" "--with-ghcjs-pkg=${targetPrefix}ghc-pkg"
+                        # setting gcc is stupid. non-emscripten ghcjs has no cc.
+                        # however cabal insists on compiling the c sources. m(
+                        "--with-gcc=${final.buildPackages.stdenv.cc}/bin/cc"
+                    ];
+                };
+                # note: we'll use the buildGHCs `hsc2hs`, ghcjss wrapper just horribly breaks in this nix setup.
+            } (''
+                mkdir -p $out/bin
+                cd $out/bin
+                ln -s ${ghcjs883}/bin/ghcjs ${targetPrefix}ghc
+                ln -s ${ghcjs883}/bin/ghcjs-pkg ${targetPrefix}ghc-pkg
+                ln -s ${buildGHC}/bin/hsc2hs ${targetPrefix}hsc2hs
+                cd ..
+                mkdir lib
+                cd lib
+                cp -R ${ghcjs883}/lib ${targetPrefix}ghc-8.8.3
+            '' + installDeps targetPrefix);
+            ghc884 = let buildGHC = final.buildPackages.haskell-nix.compiler.ghc884;
+                in let ghcjs884 = final.callPackage ../compiler/ghcjs/ghcjs.nix {
+                ghcjsSrcJson = ../compiler/ghcjs/ghcjs88-src.json;
+                ghcjsVersion =  "8.8.0.0.1";
+                ghc = buildGHC;
+                ghcVersion = "8.8.4";
+                compiler-nix-name = "ghc884";
+            }; in let targetPrefix = "js-unknown-ghcjs-"; in final.runCommand "${targetPrefix}ghc-8.8.4" {
+                passthru = {
+                    inherit targetPrefix;
+                    version = "8.8.4";
+                    isHaskellNixCompiler = true;
+                    enableShared = false;
+                    inherit (ghcjs884) configured-src bundled-ghcjs project;
+                    inherit buildGHC;
+                    extraConfigureFlags = [
+                        "--ghcjs"
+                        "--with-ghcjs=${targetPrefix}ghc" "--with-ghcjs-pkg=${targetPrefix}ghc-pkg"
+                        # setting gcc is stupid. non-emscripten ghcjs has no cc.
+                        # however cabal insists on compiling the c sources. m(
+                        "--with-gcc=${final.buildPackages.stdenv.cc}/bin/cc"
+                    ];
+                };
+                # note: we'll use the buildGHCs `hsc2hs`, ghcjss wrapper just horribly breaks in this nix setup.
+            } (''
+                mkdir -p $out/bin
+                cd $out/bin
+                ln -s ${ghcjs884}/bin/ghcjs ${targetPrefix}ghc
+                ln -s ${ghcjs884}/bin/ghcjs-pkg ${targetPrefix}ghc-pkg
+                ln -s ${buildGHC}/bin/hsc2hs ${targetPrefix}hsc2hs
+                cd ..
+                mkdir lib
+                cd lib
+                cp -R ${ghcjs884}/lib ${targetPrefix}ghc-8.8.4
+            '' + installDeps targetPrefix);
+        }))));

    # Both `cabal-install` and `nix-tools` are needed for `cabalProject`
    # to check materialized results.  We need to take care that when
--- a/overlays/default.nix
+++ b/overlays/default.nix
@ -20,6 +20,7 @@ let
    shims = import ./shims.nix;
    eval-on-current = import ./eval-on-current.nix;
    eval-on-build = import ./eval-on-build.nix;
+    ghcjs = import ./ghcjs.nix;
  };

  composeExtensions = f: g: final: prev:
@ -48,6 +49,7 @@ let
    tools
    emscripten
    nix-prefetch-git-minimal
+    ghcjs
    gobject-introspection
    shims
    # Restore nixpkgs haskell and haskellPackages
--- a/overlays/ghcjs.nix
+++ b/overlays/ghcjs.nix
@ -0,0 +1,60 @@
+final: prev:
+{
+  haskell-nix = prev.haskell-nix // ({
+    defaultModules = prev.haskell-nix.defaultModules ++ final.lib.optional final.stdenv.hostPlatform.isGhcjs (
+      ({ pkgs, buildModules, config, lib, ... }:
+        let
+          # Cabal project to build cabal for use in default setups 
+          cabal-project = final.buildPackages.haskell-nix.hackage-project {
+            name = "cabal-install";
+            version = "3.2.0.0";
+            compiler-nix-name = config.compiler.nix-name;
+            modules = [{
+              packages.Cabal.patches = [
+                ./patches/Cabal/Cabal-3.0.0.0-drop-pkg-db-check.diff
+                ./patches/Cabal/Cabal-3.0.0.0-no-final-checks.diff
+              ];
+              nonReinstallablePkgs = [ "array" "base" "binary" "bytestring" "containers" "deepseq"
+                                       "directory" "filepath" "ghc" "ghc-boot" "ghc-boot-th" "ghc-compact"
+                                       "ghc-heap" "ghc-prim" "ghci" "haskeline" "hpc" "integer-gmp"
+                                       "libiserv" "mtl" "parsec" "pretty" "process" "rts" "stm"
+                                       "template-haskell" "terminfo" "text" "time" "transformers" "unix"
+                                       "xhtml"
+                                     ];
+              }
+            ];
+          };
+        in {
+          # Override Cabal used for default setup
+          setup-depends = [ cabal-project.hsPkgs.Cabal ];
+          # Allow Cabal to be reinstalled so that custom setups will use a Cabal
+          # built with packages.Cabal.patches
+          nonReinstallablePkgs =
+            [ "rts" "ghc-heap" "ghc-prim" "integer-gmp" "integer-simple" "base"
+              "deepseq" "array" "ghc-boot-th" "pretty" "template-haskell"
+              "ghcjs-prim" "ghcjs-th"
+            ]
+            ++ lib.optionals (!config.reinstallableLibGhc) [
+              "ghc-boot"
+              "ghc" "Win32" "array" "binary" "bytestring" "containers"
+              "directory" "filepath" "ghc-boot" "ghc-compact" "ghc-prim"
+              "hpc"
+              "mtl" "parsec" "process" "text" "time" "transformers"
+              "unix" "xhtml" "terminfo"
+            ];
+          # Include patches for custom setups
+          packages.Cabal.patches = [
+            ./patches/Cabal/Cabal-3.0.0.0-drop-pkg-db-check.diff
+            ./patches/Cabal/Cabal-3.0.0.0-no-final-checks.diff
+          ];
+          testWrapper = [((final.writeScriptBin "node-wrapper" ''
+            set -euo pipefail
+            exe=$1
+            shift
+            ${final.buildPackages.nodejs}/bin/node $exe $@
+          '') + "/bin/node-wrapper")];
+        }
+      )
+    );
+  });
+}
--- a/overlays/haskell.nix
+++ b/overlays/haskell.nix
@ -165,8 +165,8 @@ final: prev: {
                patchesModule = ghcHackagePatches.${compiler-nix-name'} or {};
            in
              # Check that the GHC version of the selected compiler matches the one of the plan
-              assert (final.haskell-nix.compiler.${compiler-nix-name'}.version
-                   == final.haskell-nix.compiler.${(plan-pkgs.pkgs hackage).compiler.nix-name}.version);
+              assert (final.buildPackages.haskell-nix.compiler.${compiler-nix-name'}.version
+                   == final.buildPackages.haskell-nix.compiler.${(plan-pkgs.pkgs hackage).compiler.nix-name}.version);
              mkPkgSet {
                inherit pkg-def;
                pkg-def-extras = [ plan-pkgs.extras
@ -322,7 +322,7 @@ final: prev: {
                # pkgs.fetchgit doesn't have any way of fetching from a given
                # ref.
                assert isNull ref;
-                final.evalPackages.pkgs.fetchgit {
+                final.evalPackages.fetchgit {
                  url = url;
                  rev = rev;
                  sha256 = sha256;
@ -411,7 +411,7 @@ final: prev: {
                              final.buildPackages.lib.optionalAttrs (ref != null) { inherit ref; }
                            )
                        else
-                          final.evalPackages.pkgs.fetchgit { inherit url rev sha256; };
+                          final.evalPackages.fetchgit { inherit url rev sha256; };
                    } // final.buildPackages.lib.optionalAttrs (subdir != null) { postUnpack = "sourceRoot+=/${subdir}; echo source root reset to $sourceRoot"; };
                  };

@ -542,7 +542,7 @@ final: prev: {
                ) rawProject.hsPkgs
                // {
                  # These are functions not packages
-                  inherit (rawProject.hsPkgs) shellFor ghcWithHoogle ghcWithPackages;
+                  inherit (rawProject.hsPkgs) shellFor makeConfigFiles ghcWithHoogle ghcWithPackages;
              });

            projectCoverageReport = haskellLib.projectCoverageReport (map (pkg: pkg.coverageReport) (final.lib.attrValues (haskellLib.selectProjectPackages hsPkgs)));
@ -629,7 +629,7 @@ final: prev: {
        # for `cabalPackage` and `stackPackage`.
        project = args':
          let
-            args = { caller = "project'"; } // args';
+            args = { caller = "project"; } // args';
            p = project' args;
          in p.hsPkgs // {
              # Provide `nix-shell -A shells.ghc` for users migrating from the reflex-platform.
@ -686,6 +686,8 @@ final: prev: {
            # Things that require two levels of IFD to build (inputs should be in level 1)
            nix-tools = final.buildPackages.haskell-nix.nix-tools.${compiler-nix-name};
            cabal-install = final.buildPackages.haskell-nix.cabal-install.${compiler-nix-name};
+          } // final.lib.optionalAttrs (ifdLevel > 1 && !final.stdenv.hostPlatform.isGhcjs) {
+            # GHCJS builds its own template haskell runner.
            # These seem to be the only things we use from `ghc-extra-packages`
            # in haskell.nix itself.
            inherit (final.ghc-extra-packages."${compiler-nix-name}"
--- a/overlays/patches/Cabal/Cabal-3.0.0.0-drop-pkg-db-check.diff
+++ b/overlays/patches/Cabal/Cabal-3.0.0.0-drop-pkg-db-check.diff
@ -0,0 +1,20 @@
+diff --git a/Distribution/Simple/GHCJS.hs b/Distribution/Simple/GHCJS.hs
+index 46896c3..5381a3a 100644
+--- a/Distribution/Simple/GHCJS.hs
+++ b/Distribution/Simple/GHCJS.hs
+@@ -256,7 +256,6 @@ getInstalledPackages :: Verbosity -> PackageDBStack -> ProgramDb
+                      -> IO InstalledPackageIndex
+ getInstalledPackages verbosity packagedbs progdb = do
+   checkPackageDbEnvVar verbosity
+-  checkPackageDbStack verbosity packagedbs
+   pkgss <- getInstalledPackages' verbosity packagedbs progdb
+   index <- toPackageIndex verbosity pkgss progdb
+   return $! index
+@@ -732,7 +719,6 @@ startInterpreter verbosity progdb comp platform packageDBs = do
+         ghcOptMode       = toFlag GhcModeInteractive,
+         ghcOptPackageDBs = packageDBs
+         }
+-  checkPackageDbStack verbosity packageDBs
+   (ghcjsProg, _) <- requireProgram verbosity ghcjsProgram progdb
+   runGHC verbosity ghcjsProg comp platform replOpts
+ 
--- a/overlays/patches/Cabal/Cabal-3.0.0.0-no-final-checks.diff
+++ b/overlays/patches/Cabal/Cabal-3.0.0.0-no-final-checks.diff
@ -0,0 +1,24 @@
+diff --git a/Distribution/Simple.hs b/Distribution/Simple.hs
+index e632acc..534d0cc 100644
+--- a/Distribution/Simple.hs
+++ b/Distribution/Simple.hs
+@@ -623,7 +623,6 @@ simpleUserHooks :: UserHooks
+ simpleUserHooks =
+     emptyUserHooks {
+        confHook  = configure,
+-       postConf  = finalChecks,
+        buildHook = defaultBuildHook,
+        replHook  = defaultReplHook,
+        copyHook  = \desc lbi _ f -> install desc lbi f,
+@@ -638,11 +637,6 @@ simpleUserHooks =
+        regHook   = defaultRegHook,
+        unregHook = \p l _ f -> unregister p l f
+       }
+-  where
+-    finalChecks _args flags pkg_descr lbi =
+-      checkForeignDeps pkg_descr lbi (lessVerbose verbosity)
+-      where
+-        verbosity = fromFlag (configVerbosity flags)
+ 
+ -- | Basic autoconf 'UserHooks':
+ --
--- a/overlays/patches/config.sub
+++ b/overlays/patches/config.sub
--- a/test/cabal-22/default.nix
+++ b/test/cabal-22/default.nix
@ -19,7 +19,7 @@ in recurseIntoAttrs {
    name = "cabal-22-test";

    buildCommand = ''
-      exe="${packages.project.components.exes.project}/bin/project${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.project.components.exes.project.exePath}"

      size=$(command stat --format '%s' "$exe")
      printf "size of executable $exe is $size. \n" >& 2
--- a/test/cabal-hpack/default.nix
+++ b/test/cabal-hpack/default.nix
@ -29,7 +29,7 @@ in recurseIntoAttrs {
    name = "cabal-hpack-test";

    buildCommand = ''
-      exe="${packages.cabal-hpack.components.exes.cabal-hpack}/bin/cabal-hpack${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.cabal-hpack.components.exes.cabal-hpack.exePath}"

      size=$(command stat --format '%s' "$exe")
      printf "size of executable $exe is $size. \n" >& 2
--- a/test/cabal-simple-prof/default.nix
+++ b/test/cabal-simple-prof/default.nix
@ -31,7 +31,7 @@ in recurseIntoAttrs {
    name = "cabal-simple-prof-test";

    buildCommand = ''
-      exe="${packages.cabal-simple.components.exes.cabal-simple}/bin/cabal-simple${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.cabal-simple.components.exes.cabal-simple.exePath}"

      size=$(command stat --format '%s' "$exe")
      printf "size of executable $exe is $size. \n" >& 2
--- a/test/cabal-simple/default.nix
+++ b/test/cabal-simple/default.nix
@ -32,7 +32,7 @@ in recurseIntoAttrs {
    name = "cabal-simple-test";

    buildCommand = ''
-      exe="${packages.cabal-simple.components.exes.cabal-simple}/bin/cabal-simple${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.cabal-simple.components.exes.cabal-simple.exePath}"

      size=$(command stat --format '%s' "$exe")
      printf "size of executable $exe is $size. \n" >& 2
--- a/test/cabal-source-repo-comments/default.nix
+++ b/test/cabal-source-repo-comments/default.nix
@ -17,7 +17,7 @@ in recurseIntoAttrs {
    name = "call-cabal-project-to-nix-test";

    buildCommand = ''
-      exe="${packages.use-cabal-simple.components.exes.use-cabal-simple}/bin/use-cabal-simple${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.use-cabal-simple.components.exes.use-cabal-simple.exePath}"

      printf "checking whether executable runs... " >& 2
      cat ${haskellLib.check packages.use-cabal-simple.components.exes.use-cabal-simple}/test-stdout
--- a/test/cabal-source-repo/default.nix
+++ b/test/cabal-source-repo/default.nix
@ -17,7 +17,7 @@ in recurseIntoAttrs {
    name = "call-cabal-project-to-nix-test";

    buildCommand = ''
-      exe="${packages.use-cabal-simple.components.exes.use-cabal-simple}/bin/use-cabal-simple${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.use-cabal-simple.components.exes.use-cabal-simple.exePath}"

      printf "checking whether executable runs... " >& 2
      cat ${haskellLib.check packages.use-cabal-simple.components.exes.use-cabal-simple}/test-stdout
--- a/test/cabal-sublib/default.nix
+++ b/test/cabal-sublib/default.nix
@ -29,7 +29,7 @@ in recurseIntoAttrs {
    name = "cabal-sublib-test";

    buildCommand = ''
-      exe="${packages.cabal-sublib.components.exes.cabal-sublib}/bin/cabal-sublib${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.cabal-sublib.components.exes.cabal-sublib.exePath}"

      size=$(command stat --format '%s' "$exe")
      printf "size of executable $exe is $size. \n" >& 2
--- a/test/call-cabal-project-to-nix/default.nix
+++ b/test/call-cabal-project-to-nix/default.nix
@ -26,7 +26,7 @@ in recurseIntoAttrs {
    name = "call-cabal-project-to-nix-test";

    buildCommand = ''
-      exe="${packages.cabal-simple.components.exes.cabal-simple}/bin/cabal-simple${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.cabal-simple.components.exes.cabal-simple.exePath}"

      printf "checking whether executable runs... " >& 2
      cat ${haskellLib.check packages.cabal-simple.components.exes.cabal-simple}/test-stdout
--- a/test/call-stack-to-nix/default.nix
+++ b/test/call-stack-to-nix/default.nix
@ -21,7 +21,7 @@ in recurseIntoAttrs {
    name = "callStackToNix-test";

    buildCommand = ''
-      exe="${packages.stack-simple.components.exes.stack-simple-exe}/bin/stack-simple-exe${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.stack-simple.components.exes.stack-simple-exe.exePath}"

      printf "checking whether executable runs... " >& 2
      cat ${haskellLib.check packages.stack-simple.components.exes.stack-simple-exe}/test-stdout
--- a/test/compiler-nix-name/default.nix
+++ b/test/compiler-nix-name/default.nix
@ -21,9 +21,10 @@ in recurseIntoAttrs {
    name = "compiler-nix-name-test";

    buildCommand = ''
-      exe="${compiler-nix-name}/bin/compiler-nix-name${stdenv.hostPlatform.extensions.executable}"
-      if [[ "$(${toString compiler-nix-name.config.testWrapper} $exe)" != "808" ]]; then
-        echo "Unexpected GHC version" >& 2
+      exe="${compiler-nix-name.exePath}"
+      ver="$(${toString compiler-nix-name.config.testWrapper} $exe)"
+      if [[ "$ver" != "808" ]]; then
+        echo "Unexpected GHC version (expected 808, but got $ver)" >& 2
        false
      else
        touch $out
--- a/test/default.nix
+++ b/test/default.nix
@ -154,14 +154,11 @@ let
    cabal-simple = callTest ./cabal-simple { inherit util compiler-nix-name; };
    cabal-simple-prof = callTest ./cabal-simple-prof { inherit util compiler-nix-name; };
    cabal-sublib = callTest ./cabal-sublib { inherit util compiler-nix-name; };
-    cabal-22 = callTest ./cabal-22 { inherit util compiler-nix-name; };
    with-packages = callTest ./with-packages { inherit util; };
    builder-haddock = callTest ./builder-haddock {};
    stack-simple = callTest ./stack-simple {};
    stack-local-resolver = callTest ./stack-local-resolver {};
    stack-remote-resolver = callTest ./stack-remote-resolver {};
-    snapshots = callTest ./snapshots {};
-    shell-for = callTest ./shell-for {};
    shell-for-setup-deps = callTest ./shell-for-setup-deps { inherit compiler-nix-name; };
    setup-deps = import ./setup-deps { inherit pkgs compiler-nix-name; };
    callStackToNix = callTest ./call-stack-to-nix {};
@ -181,9 +178,21 @@ let
    hls-stack = callTest ./haskell-language-server/stack.nix { inherit compiler-nix-name; };
    cabal-hpack = callTest ./cabal-hpack { inherit util compiler-nix-name; };
    index-state = callTest ./index-state { inherit compiler-nix-name; };
-    coverage = callTest ./coverage { inherit compiler-nix-name; };

    unit = unitTests;
+  } // lib.optionalAttrs (!stdenv.hostPlatform.isGhcjs && !stdenv.hostPlatform.isWindows) {
+    # Does not work on ghcjs because it needs zlib.
+    # Does not work on windows because it needs mintty.
+    shell-for = callTest ./shell-for {};
+  } // lib.optionalAttrs (!stdenv.hostPlatform.isGhcjs || !stdenv.buildPlatform.isDarwin) {
+    # When using ghcjs on darwin this test fails with
+    # ReferenceError: h$hs_clock_darwin_gettime is not defined
+    # https://github.com/input-output-hk/haskell.nix/issues/925
+    cabal-22 = callTest ./cabal-22 { inherit util compiler-nix-name; };
+  } // lib.optionalAttrs (!stdenv.hostPlatform.isGhcjs) {
+    # These do not work on ghcjs because it needs zlib.
+    coverage = callTest ./coverage { inherit compiler-nix-name; };
+    snapshots = callTest ./snapshots {};
  } // lib.optionalAttrs (!stdenv.hostPlatform.isGhcjs && compiler-nix-name != "ghc8101" && compiler-nix-name != "ghc8102" && compiler-nix-name != "ghc8102-experimental" ) {
    # Pandoc does not build with ghcjs or ghc 8.10 yet (lookup-sha256 and fully-static build pandoc)
    lookup-sha256 = callTest ./lookup-sha256 { inherit compiler-nix-name; };
--- a/test/exe-only/default.nix
+++ b/test/exe-only/default.nix
@ -19,7 +19,7 @@ in recurseIntoAttrs {
    name = "exe-only-test";

    buildCommand = ''
-      exe="${packages.exe-only.components.exes.exe-only}/bin/exe-only${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.exe-only.components.exes.exe-only.exePath}"

      size=$(command stat --format '%s' "$exe")
      printf "size of executable $exe is $size. \n" >& 2
--- a/test/extra-hackage/default.nix
+++ b/test/extra-hackage/default.nix
@ -36,7 +36,7 @@ in recurseIntoAttrs {
    name = "external-hackage-test";

    buildCommand = ''
-      exe="${packages.external-package-user.components.exes.external-package-user}/bin/external-package-user${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.external-package-user.components.exes.external-package-user.exePath}"
      size=$(command stat --format '%s' "$exe")
      printf "size of executable $exe is $size. \n" >& 2
      # fixme: run on target platform when cross-compiled
--- a/test/fully-static/default.nix
+++ b/test/fully-static/default.nix
@ -40,7 +40,7 @@ in recurseIntoAttrs {
    buildCommand = flip concatMapStrings
      [ packagesGmp /* packagesIntegerSimple */ ]
      (packages: ''
-        exe="${packages.pandoc.components.exes.pandoc}/bin/pandoc${stdenv.hostPlatform.extensions.executable}"
+        exe="${packages.pandoc.components.exes.pandoc.exePath}"

        printf "checking whether executable runs... " >& 2
        ${toString packages.pandoc.components.exes.pandoc.config.testWrapper} $exe --version
--- a/test/haskell-language-server/stack.nix
+++ b/test/haskell-language-server/stack.nix
@ -8,8 +8,7 @@ let
      rev = "e390da54a90f2c6c02ce836a27f2d4c33a71f607";
      sha256 = "0s77r79zn6q42k3biylni81vhn1yr8r1mqn8pj9kgggh16xw229b";
    };
-    projectFileName = "stack-${haskell-nix.compiler.${compiler-nix-name}.version}.yaml";
-    modules = [{ config.compiler.nix-name = lib.mkForce compiler-nix-name; }];
+    projectFileName = "stack-${buildPackages.haskell-nix.compiler.${compiler-nix-name}.version}.yaml";
    sha256map = {
      "https://github.com/bubba/brittany.git"."c59655f10d5ad295c2481537fc8abf0a297d9d1c" = "1rkk09f8750qykrmkqfqbh44dbx1p8aq1caznxxlw8zqfvx39cxl";
    };
--- a/test/project-flags/cabal.nix
+++ b/test/project-flags/cabal.nix
@ -18,7 +18,7 @@ in recurseIntoAttrs {
    name = "call-cabal-project-to-nix-test";

    buildCommand = ''
-      exe="${packages.test-project-flags.components.exes.test-project-flags-exe}/bin/test-project-flags-exe${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.test-project-flags.components.exes.test-project-flags-exe.exePath}"

      printf "checking whether executable runs... " >& 2
      cat ${haskellLib.check packages.test-project-flags.components.exes.test-project-flags-exe}/test-stdout
--- a/test/project-flags/stack.nix
+++ b/test/project-flags/stack.nix
@ -16,7 +16,7 @@ in recurseIntoAttrs {
    name = "callStackToNix-test";

    buildCommand = ''
-      exe="${packages.test-project-flags.components.exes.test-project-flags-exe}/bin/test-project-flags-exe${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.test-project-flags.components.exes.test-project-flags-exe.exePath}"

      printf "checking whether executable runs... " >& 2
      cat ${haskellLib.check packages.test-project-flags.components.exes.test-project-flags-exe}/test-stdout
--- a/test/shell-for/default.nix
+++ b/test/shell-for/default.nix
@ -44,19 +44,7 @@ let
    tools = { cabal = "3.2.0.0"; };
  };

-in recurseIntoAttrs (if stdenv.hostPlatform.isWindows
- then
-    let skip = runCommand "skip-test-shell-for" {} ''
-      echo "Skipping shell-for test on windows as does not work yet" >& 2
-      touch $out
-    '';
-    in {
-      env = skip;
-      envPkga = skip;
-      envDefault = skip;
-      run = skip;
-    }
- else {
+in recurseIntoAttrs {
  inherit env envPkga envDefault;
  run = stdenv.mkDerivation {
    name = "shell-for-test";
@ -87,4 +75,4 @@ in recurseIntoAttrs (if stdenv.hostPlatform.isWindows
      inherit env envPkga envDefault;
    };
  };
-})
+}
--- a/test/snapshots/default.nix
+++ b/test/snapshots/default.nix
@ -6,27 +6,12 @@ let
  env = snapshots."lts-14.13".ghcWithHoogle
    (ps: with ps; [ conduit conduit-extra resourcet ]);

-in recurseIntoAttrs (if stdenv.hostPlatform.isWindows
- then
-    let skip = runCommand "skip-test-snapshot" {} ''
-      echo "Skipping snapshot test on windows as does not work yet" >& 2
-      touch $out
-    '';
-    in {
-      env = skip;
-      run = skip;
-    }
- else {
+in recurseIntoAttrs {
  inherit env;
  run = stdenv.mkDerivation {
    name = "shell-for-test";

-    buildCommand = if stdenv.hostPlatform.isWindows
-      then ''
-        printf "snapshot test is not working yet for windows. skipping. " >& 2
-        touch $out
-      ''
-      else ''
+    buildCommand = ''
      ########################################################################
      # test single component from haskellPackages

@ -41,7 +26,7 @@ in recurseIntoAttrs (if stdenv.hostPlatform.isWindows

    ''
    # Hoogle support is currently disabled in cross compiler shells
-    + (optionalString (!stdenv.hostPlatform.isAarch32 && !stdenv.hostPlatform.isAarch64) ''
+    + (optionalString (stdenv.buildPlatform == stdenv.hostPlatform) ''
        printf "checking that the ghcWithPackages env has a hoogle index...\n" >& 2
        ${env}/bin/hoogle search Conduit --count=100 | grep ConduitT
    '') +''
@ -54,4 +39,4 @@ in recurseIntoAttrs (if stdenv.hostPlatform.isWindows
      inherit env;
    };
  };
-})
+}
--- a/test/sublib-docs/default.nix
+++ b/test/sublib-docs/default.nix
@ -19,7 +19,7 @@ in recurseIntoAttrs {
    name = "sublib-docs-test";

    buildCommand = ''
-      exe="${packages.sublib-docs.components.exes.sublib-docs}/bin/sublib-docs${stdenv.hostPlatform.extensions.executable}"
+      exe="${packages.sublib-docs.components.exes.sublib-docs.exePath}"

      size=$(command stat --format '%s' "$exe")
      printf "size of executable $exe is $size. \n" >& 2
--- a/test/with-packages/default.nix
+++ b/test/with-packages/default.nix
@ -66,9 +66,9 @@ in recurseIntoAttrs {

      printf "checking that the 'library' with doExactConfig works... " >& 2
      echo ${decLibrary} >& 2
-    '' + (if stdenv.hostPlatform.isWindows
+    '' + (if stdenv.hostPlatform.isWindows || stdenv.hostPlatform.isGhcjs
      then ''
-        printf "runghc tests are not working yet for windows. skipping. " >& 2
+        printf "runghc tests are not working yet for windows or ghcjs. skipping. " >& 2
      ''
      else ''
        printf "checking that non doExactConfig liarary.env has the dependencies... " >& 2
				`@ -0,0 +1 @@`
				`GHCJS package manager version 8.8.1.20200101`