From 6582132c12a96dde52c973c04373ba4e8905fbb0 Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Sat, 21 Sep 2024 08:43:38 -0300
Subject: [PATCH 01/14] dotnet: format with nixfmt

---
 .../compilers/dotnet/build-dotnet.nix         | 178 ++---
 .../compilers/dotnet/combine-deps.nix         |  37 +-
 .../compilers/dotnet/combine-packages.nix     |  65 +-
 pkgs/development/compilers/dotnet/common.nix  | 425 ++++++------
 pkgs/development/compilers/dotnet/default.nix |  48 +-
 pkgs/development/compilers/dotnet/dotnet.nix  |  35 +-
 .../development/compilers/dotnet/packages.nix |  24 +-
 .../compilers/dotnet/patch-nupkgs.nix         | 165 ++---
 .../compilers/dotnet/sign-apphost.nix         |  10 +-
 pkgs/development/compilers/dotnet/sigtool.nix |  23 +-
 pkgs/development/compilers/dotnet/stage0.nix  | 213 +++---
 pkgs/development/compilers/dotnet/stage1.nix  |  36 +-
 pkgs/development/compilers/dotnet/update.nix  |  32 +-
 pkgs/development/compilers/dotnet/vmr.nix     | 612 +++++++++---------
 14 files changed, 1028 insertions(+), 875 deletions(-)

diff --git a/pkgs/development/compilers/dotnet/build-dotnet.nix b/pkgs/development/compilers/dotnet/build-dotnet.nix
index bba31fe394ca..3e2a21d20c5f 100644
--- a/pkgs/development/compilers/dotnet/build-dotnet.nix
+++ b/pkgs/development/compilers/dotnet/build-dotnet.nix
@@ -1,33 +1,39 @@
-{ type
-, version
-, srcs
-, packages ? null
+{
+  type,
+  version,
+  srcs,
+  packages ? null,
 }:
 
-assert builtins.elem type [ "aspnetcore" "runtime" "sdk" ];
+assert builtins.elem type [
+  "aspnetcore"
+  "runtime"
+  "sdk"
+];
 assert if type == "sdk" then packages != null else true;
 
-{ lib
-, stdenv
-, fetchurl
-, writeText
-, autoPatchelfHook
-, makeWrapper
-, libunwind
-, icu
-, libuuid
-, zlib
-, libkrb5
-, openssl
-, curl
-, lttng-ust_2_12
-, testers
-, runCommand
-, writeShellScript
-, mkNugetDeps
-, callPackage
-, dotnetCorePackages
-, xmlstarlet
+{
+  lib,
+  stdenv,
+  fetchurl,
+  writeText,
+  autoPatchelfHook,
+  makeWrapper,
+  libunwind,
+  icu,
+  libuuid,
+  zlib,
+  libkrb5,
+  openssl,
+  curl,
+  lttng-ust_2_12,
+  testers,
+  runCommand,
+  writeShellScript,
+  mkNugetDeps,
+  callPackage,
+  dotnetCorePackages,
+  xmlstarlet,
 }:
 
 let
@@ -45,40 +51,52 @@ let
     sdk = ".NET SDK ${version}";
   };
 
-  mkCommon = callPackage ./common.nix {};
+  mkCommon = callPackage ./common.nix { };
 
   targetRid = dotnetCorePackages.systemToDotnetRid stdenv.targetPlatform.system;
 
-  sigtool = callPackage ./sigtool.nix {};
-  signAppHost = callPackage ./sign-apphost.nix {};
+  sigtool = callPackage ./sigtool.nix { };
+  signAppHost = callPackage ./sign-apphost.nix { };
 
-  hasILCompiler =
-    lib.versionAtLeast version (if targetRid == "osx-arm64" then "8" else "7");
+  hasILCompiler = lib.versionAtLeast version (if targetRid == "osx-arm64" then "8" else "7");
 
-  extraTargets = writeText "extra.targets" (''
-    <Project>
-  '' + lib.optionalString hasILCompiler ''
+  extraTargets = writeText "extra.targets" (
+    ''
+      <Project>
+    ''
+    + lib.optionalString hasILCompiler ''
       <ItemGroup>
-        <CustomLinkerArg Include="-Wl,-rpath,'${lib.makeLibraryPath [ icu zlib openssl ]}'" />
+        <CustomLinkerArg Include="-Wl,-rpath,'${
+          lib.makeLibraryPath [
+            icu
+            zlib
+            openssl
+          ]
+        }'" />
       </ItemGroup>
-  '' + lib.optionalString stdenv.hostPlatform.isDarwin ''
+    ''
+    + lib.optionalString stdenv.hostPlatform.isDarwin ''
       <Import Project="${signAppHost}" />
-  '' + ''
-    </Project>
-  '');
+    ''
+    + ''
+      </Project>
+    ''
+  );
 
 in
 mkCommon type rec {
   inherit pname version;
 
   # Some of these dependencies are `dlopen()`ed.
-  nativeBuildInputs = [
-    makeWrapper
-  ] ++ lib.optional stdenv.hostPlatform.isLinux autoPatchelfHook
-  ++ lib.optionals (type == "sdk" && stdenv.hostPlatform.isDarwin) [
-    xmlstarlet
-    sigtool
-  ];
+  nativeBuildInputs =
+    [
+      makeWrapper
+    ]
+    ++ lib.optional stdenv.hostPlatform.isLinux autoPatchelfHook
+    ++ lib.optionals (type == "sdk" && stdenv.hostPlatform.isDarwin) [
+      xmlstarlet
+      sigtool
+    ];
 
   buildInputs = [
     stdenv.cc.cc
@@ -90,21 +108,28 @@ mkCommon type rec {
   ] ++ lib.optional stdenv.hostPlatform.isLinux lttng-ust_2_12;
 
   src = fetchurl (
-    srcs."${stdenv.hostPlatform.system}" or (throw
-      "Missing source (url and hash) for host system: ${stdenv.hostPlatform.system}")
+    srcs."${stdenv.hostPlatform.system}"
+      or (throw "Missing source (url and hash) for host system: ${stdenv.hostPlatform.system}")
   );
 
   sourceRoot = ".";
 
-  postPatch = if type == "sdk" then (''
-    xmlstarlet ed \
-      --inplace \
-      -s //_:Project -t elem -n Import \
-      -i \$prev -t attr -n Project -v "${extraTargets}" \
-      sdk/*/Sdks/Microsoft.NET.Sdk/targets/Microsoft.NET.Sdk.targets
-  '' + lib.optionalString stdenv.hostPlatform.isDarwin ''
-    codesign --remove-signature packs/Microsoft.NETCore.App.Host.osx-*/*/runtimes/osx-*/native/{apphost,singlefilehost}
-  '') else null;
+  postPatch =
+    if type == "sdk" then
+      (
+        ''
+          xmlstarlet ed \
+            --inplace \
+            -s //_:Project -t elem -n Import \
+            -i \$prev -t attr -n Project -v "${extraTargets}" \
+            sdk/*/Sdks/Microsoft.NET.Sdk/targets/Microsoft.NET.Sdk.targets
+        ''
+        + lib.optionalString stdenv.hostPlatform.isDarwin ''
+          codesign --remove-signature packs/Microsoft.NETCore.App.Host.osx-*/*/runtimes/osx-*/native/{apphost,singlefilehost}
+        ''
+      )
+    else
+      null;
 
   dontPatchELF = true;
   noDumpEnvVars = true;
@@ -151,29 +176,34 @@ mkCommon type rec {
                        (global-name "com.apple.system.opendirectoryd.membership"))
   '';
 
-  passthru = {
-    inherit icu hasILCompiler;
-  } // lib.optionalAttrs (type == "sdk") {
-    packages = mkNugetDeps {
-      name = "${pname}-${version}-deps";
-      nugetDeps = packages;
-    };
+  passthru =
+    {
+      inherit icu hasILCompiler;
+    }
+    // lib.optionalAttrs (type == "sdk") {
+      packages = mkNugetDeps {
+        name = "${pname}-${version}-deps";
+        nugetDeps = packages;
+      };
 
-    updateScript =
-      let
-        majorVersion = lib.concatStringsSep "." (lib.take 2 (lib.splitVersion version));
-      in
-      writeShellScript "update-dotnet-${majorVersion}" ''
-        pushd pkgs/development/compilers/dotnet
-        exec ${./update.sh} "${majorVersion}"
-      '';
-  };
+      updateScript =
+        let
+          majorVersion = lib.concatStringsSep "." (lib.take 2 (lib.splitVersion version));
+        in
+        writeShellScript "update-dotnet-${majorVersion}" ''
+          pushd pkgs/development/compilers/dotnet
+          exec ${./update.sh} "${majorVersion}"
+        '';
+    };
 
   meta = with lib; {
     description = builtins.getAttr type descriptions;
     homepage = "https://dotnet.github.io/";
     license = licenses.mit;
-    maintainers = with maintainers; [ kuznero mdarocha ];
+    maintainers = with maintainers; [
+      kuznero
+      mdarocha
+    ];
     mainProgram = "dotnet";
     platforms = attrNames srcs;
   };
diff --git a/pkgs/development/compilers/dotnet/combine-deps.nix b/pkgs/development/compilers/dotnet/combine-deps.nix
index af21c3aa248e..188c26cf27fa 100644
--- a/pkgs/development/compilers/dotnet/combine-deps.nix
+++ b/pkgs/development/compilers/dotnet/combine-deps.nix
@@ -2,7 +2,7 @@
   list,
   baseRid,
   otherRids,
-  pkgs ? import ../../../.. {}
+  pkgs ? import ../../../.. { },
 }:
 let
   inherit (pkgs) writeText;
@@ -20,31 +20,36 @@ let
 
   fns = map (file: import file) list;
 
-  packages = unique
-    (concatMap (fn: fn { fetchNuGet = package: package; }) fns);
+  packages = unique (concatMap (fn: fn { fetchNuGet = package: package; }) fns);
 
-  changePackageRid = package: rid:
-    let replace = replaceStrings [".${baseRid}"] [".${rid}"];
-    in rec {
+  changePackageRid =
+    package: rid:
+    let
+      replace = replaceStrings [ ".${baseRid}" ] [ ".${rid}" ];
+    in
+    rec {
       pname = replace package.pname;
       inherit (package) version;
       url = replace package.url;
       sha256 = builtins.hashFile "sha256" (builtins.fetchurl url);
     };
 
-  expandPackage = package:
-    [ package ] ++
-    optionals (strings.match ".*\\.${baseRid}(\\..*|$)" package.pname != null)
-    (map (changePackageRid package) otherRids);
+  expandPackage =
+    package:
+    [ package ]
+    ++ optionals (strings.match ".*\\.${baseRid}(\\..*|$)" package.pname != null) (
+      map (changePackageRid package) otherRids
+    );
 
-  allPackages =
-    sortOn (package: [ package.pname package.version ])
-    (concatMap expandPackage packages);
+  allPackages = sortOn (package: [
+    package.pname
+    package.version
+  ]) (concatMap expandPackage packages);
 
-  fetchExpr = package:
-    "  (fetchNuGet ${generators.toPretty { multiline = false; } package})";
+  fetchExpr = package: "  (fetchNuGet ${generators.toPretty { multiline = false; } package})";
 
-in writeText "deps.nix" ''
+in
+writeText "deps.nix" ''
   { fetchNuGet }: [
   ${concatMapStringsSep "\n" fetchExpr allPackages}
   ]
diff --git a/pkgs/development/compilers/dotnet/combine-packages.nix b/pkgs/development/compilers/dotnet/combine-packages.nix
index 303e5eaba847..165b9fbef97c 100644
--- a/pkgs/development/compilers/dotnet/combine-packages.nix
+++ b/pkgs/development/compilers/dotnet/combine-packages.nix
@@ -1,37 +1,50 @@
 dotnetPackages:
-{ buildEnv, makeWrapper, lib, symlinkJoin }:
+{
+  buildEnv,
+  makeWrapper,
+  lib,
+  symlinkJoin,
+}:
 # TODO: Rethink how we determine and/or get the CLI.
 #       Possible options raised in #187118:
 #         1. A separate argument for the CLI (as suggested by IvarWithoutBones
 #         2. Use the highest version SDK for the CLI (as suggested by GGG)
 #         3. Something else?
-let cli = builtins.head dotnetPackages;
+let
+  cli = builtins.head dotnetPackages;
 in
-assert lib.assertMsg ((builtins.length dotnetPackages) > 0)
-    ''You must include at least one package, e.g
-      `with dotnetCorePackages; combinePackages [
-          sdk_6_0 aspnetcore_7_0
-       ];`'' ;
-  buildEnv {
-    name = "dotnet-core-combined";
-    paths = dotnetPackages;
-    pathsToLink = [ "/host" "/packs" "/sdk" "/sdk-manifests" "/shared" "/templates" ];
-    ignoreCollisions = true;
-    postBuild = ''
-      cp -R ${cli}/{dotnet,share,nix-support} $out/
+assert lib.assertMsg ((builtins.length dotnetPackages) > 0) ''
+  You must include at least one package, e.g
+        `with dotnetCorePackages; combinePackages [
+            sdk_6_0 aspnetcore_7_0
+         ];`'';
+buildEnv {
+  name = "dotnet-core-combined";
+  paths = dotnetPackages;
+  pathsToLink = [
+    "/host"
+    "/packs"
+    "/sdk"
+    "/sdk-manifests"
+    "/shared"
+    "/templates"
+  ];
+  ignoreCollisions = true;
+  postBuild = ''
+    cp -R ${cli}/{dotnet,share,nix-support} $out/
 
-      mkdir $out/bin
-      ln -s $out/dotnet $out/bin/dotnet
-    '';
-    passthru = {
-      inherit (cli) icu;
+    mkdir $out/bin
+    ln -s $out/dotnet $out/bin/dotnet
+  '';
+  passthru = {
+    inherit (cli) icu;
 
-      versions = lib.catAttrs "version" dotnetPackages;
-      packages = symlinkJoin {
-        name = "combined-packages";
-        paths = lib.remove null (lib.catAttrs "packages" dotnetPackages);
-      };
+    versions = lib.catAttrs "version" dotnetPackages;
+    packages = symlinkJoin {
+      name = "combined-packages";
+      paths = lib.remove null (lib.catAttrs "packages" dotnetPackages);
     };
+  };
 
-    inherit (cli) meta;
-  }
+  inherit (cli) meta;
+}
diff --git a/pkgs/development/compilers/dotnet/common.nix b/pkgs/development/compilers/dotnet/common.nix
index b4891a83e41f..4858e99eaa71 100644
--- a/pkgs/development/compilers/dotnet/common.nix
+++ b/pkgs/development/compilers/dotnet/common.nix
@@ -1,204 +1,241 @@
 # TODO: switch to stdenvNoCC
-{ stdenv
-, stdenvNoCC
-, lib
-, writeText
-, testers
-, runCommand
-, runCommandWith
-, expect
-, curl
-, installShellFiles
-, callPackage
-, zlib
-, swiftPackages
-, darwin
-, icu
-, lndir
-, substituteAll
-, nugetPackageHook
-, xmlstarlet
-}: type: args: stdenv.mkDerivation (finalAttrs: args // {
-  doInstallCheck = true;
+{
+  stdenv,
+  stdenvNoCC,
+  lib,
+  writeText,
+  testers,
+  runCommand,
+  runCommandWith,
+  expect,
+  curl,
+  installShellFiles,
+  callPackage,
+  zlib,
+  swiftPackages,
+  darwin,
+  icu,
+  lndir,
+  substituteAll,
+  nugetPackageHook,
+  xmlstarlet,
+}:
+type: args:
+stdenv.mkDerivation (
+  finalAttrs:
+  args
+  // {
+    doInstallCheck = true;
 
-  # TODO: this should probably be postInstallCheck
-  # TODO: send output to /dev/null
-  installCheckPhase = args.installCheckPhase or "" + ''
-    $out/bin/dotnet --info
-  '';
-
-  setupHooks = args.setupHooks or [] ++ [
-    ./dotnet-setup-hook.sh
-  ] ++ lib.optional (type == "sdk") (substituteAll {
-    src = ./dotnet-sdk-setup-hook.sh;
-    inherit lndir xmlstarlet;
-  });
-
-  propagatedBuildInputs =
-    (args.propagatedBuildInputs or [ ])
-    ++ lib.optional (type == "sdk") nugetPackageHook;
-
-  nativeBuildInputs = (args.nativeBuildInputs or []) ++ [ installShellFiles ];
-
-  postInstall = ''
-    # completions snippets taken from https://learn.microsoft.com/en-us/dotnet/core/tools/enable-tab-autocomplete
-    installShellCompletion --cmd dotnet \
-      --bash ${./completions/dotnet.bash} \
-      --zsh ${./completions/dotnet.zsh} \
-      --fish ${./completions/dotnet.fish}
-  '';
-
-  passthru = {
-    tests = let
-      mkDotnetTest =
-        {
-          name,
-          stdenv ? stdenvNoCC,
-          template,
-          usePackageSource ? false,
-          build,
-          buildInputs ? [],
-          # TODO: use correct runtimes instead of sdk
-          runtime ? finalAttrs.finalPackage,
-          runInputs ? [],
-          run ? null,
-          runAllowNetworking ? false,
-        }:
-        let
-          sdk = finalAttrs.finalPackage;
-          built = stdenv.mkDerivation {
-            name = "dotnet-test-${name}";
-            buildInputs =
-              [ sdk ]
-              ++ buildInputs
-              ++ lib.optional (usePackageSource) sdk.packages;
-            # make sure ICU works in a sandbox
-            propagatedSandboxProfile = toString sdk.__propagatedSandboxProfile;
-            unpackPhase = ''
-              mkdir test
-              cd test
-              dotnet new ${template} -o .
-            '';
-            buildPhase = build;
-            dontPatchELF = true;
-          };
-        in
-          if run == null
-            then built
-          else
-            runCommand "${built.name}-run" ({
-              src = built;
-              nativeBuildInputs = [ built ] ++ runInputs;
-              passthru = { inherit built; };
-            } // lib.optionalAttrs (stdenv.hostPlatform.isDarwin && runAllowNetworking) {
-              sandboxProfile = ''
-                (allow network-inbound (local ip))
-                (allow mach-lookup (global-name "com.apple.FSEvents"))
-              '';
-              __darwinAllowLocalNetworking = true;
-            }) (lib.optionalString (runtime != null) ''
-              # TODO: use runtime here
-              export DOTNET_ROOT=${runtime}
-            '' + run);
-
-      # Setting LANG to something other than 'C' forces the runtime to search
-      # for ICU, which will be required in most user environments.
-      checkConsoleOutput = command: ''
-        output="$(LANG=C.UTF-8 ${command})"
-        # yes, older SDKs omit the comma
-        [[ "$output" =~ Hello,?\ World! ]] && touch "$out"
+    # TODO: this should probably be postInstallCheck
+    # TODO: send output to /dev/null
+    installCheckPhase =
+      args.installCheckPhase or ""
+      + ''
+        $out/bin/dotnet --info
       '';
-    in {
-      version = testers.testVersion ({
-        package = finalAttrs.finalPackage;
-      } // lib.optionalAttrs (type != "sdk") {
-        command = "dotnet --info";
+
+    setupHooks =
+      args.setupHooks or [ ]
+      ++ [
+        ./dotnet-setup-hook.sh
+      ]
+      ++ lib.optional (type == "sdk") (substituteAll {
+        src = ./dotnet-sdk-setup-hook.sh;
+        inherit lndir xmlstarlet;
       });
-    }
-    // lib.optionalAttrs (type == "sdk") ({
-      console = mkDotnetTest {
-        name = "console";
-        template = "console";
-        build = checkConsoleOutput "dotnet run";
-      };
 
-      publish = mkDotnetTest {
-        name = "publish";
-        template = "console";
-        build = "dotnet publish -o $out/bin";
-        run = checkConsoleOutput "$src/bin/test";
-      };
+    propagatedBuildInputs =
+      (args.propagatedBuildInputs or [ ])
+      ++ lib.optional (type == "sdk") nugetPackageHook;
 
-      self-contained = mkDotnetTest {
-        name = "self-contained";
-        template = "console";
-        usePackageSource = true;
-        build = "dotnet publish --use-current-runtime --sc -o $out";
-        runtime = null;
-        run = checkConsoleOutput "$src/test";
-      };
+    nativeBuildInputs = (args.nativeBuildInputs or [ ]) ++ [ installShellFiles ];
 
-      single-file = mkDotnetTest {
-        name = "single-file";
-        template = "console";
-        usePackageSource = true;
-        build = "dotnet publish --use-current-runtime -p:PublishSingleFile=true -o $out/bin";
-        runtime = null;
-        run = checkConsoleOutput "$src/bin/test";
-      };
+    postInstall = ''
+      # completions snippets taken from https://learn.microsoft.com/en-us/dotnet/core/tools/enable-tab-autocomplete
+      installShellCompletion --cmd dotnet \
+        --bash ${./completions/dotnet.bash} \
+        --zsh ${./completions/dotnet.zsh} \
+        --fish ${./completions/dotnet.fish}
+    '';
 
-      web = mkDotnetTest {
-        name = "web";
-        template = "web";
-        build = "dotnet publish -o $out/bin";
-        runInputs = [ expect curl ];
-        run = ''
-          expect <<"EOF"
-            set status 1
-            spawn $env(src)/bin/test
-            proc abort { } { exit 2 }
-            expect_before default abort
-            expect -re {Now listening on: ([^\r]+)\r} {
-              set url $expect_out(1,string)
+    passthru = {
+      tests =
+        let
+          mkDotnetTest =
+            {
+              name,
+              stdenv ? stdenvNoCC,
+              template,
+              usePackageSource ? false,
+              build,
+              buildInputs ? [ ],
+              # TODO: use correct runtimes instead of sdk
+              runtime ? finalAttrs.finalPackage,
+              runInputs ? [ ],
+              run ? null,
+              runAllowNetworking ? false,
+            }:
+            let
+              sdk = finalAttrs.finalPackage;
+              built = stdenv.mkDerivation {
+                name = "dotnet-test-${name}";
+                buildInputs = [ sdk ] ++ buildInputs ++ lib.optional (usePackageSource) sdk.packages;
+                # make sure ICU works in a sandbox
+                propagatedSandboxProfile = toString sdk.__propagatedSandboxProfile;
+                unpackPhase = ''
+                  mkdir test
+                  cd test
+                  dotnet new ${template} -o .
+                '';
+                buildPhase = build;
+                dontPatchELF = true;
+              };
+            in
+            if run == null then
+              built
+            else
+              runCommand "${built.name}-run"
+                (
+                  {
+                    src = built;
+                    nativeBuildInputs = [ built ] ++ runInputs;
+                    passthru = {
+                      inherit built;
+                    };
+                  }
+                  // lib.optionalAttrs (stdenv.hostPlatform.isDarwin && runAllowNetworking) {
+                    sandboxProfile = ''
+                      (allow network-inbound (local ip))
+                      (allow mach-lookup (global-name "com.apple.FSEvents"))
+                    '';
+                    __darwinAllowLocalNetworking = true;
+                  }
+                )
+                (
+                  lib.optionalString (runtime != null) ''
+                    # TODO: use runtime here
+                    export DOTNET_ROOT=${runtime}
+                  ''
+                  + run
+                );
+
+          # Setting LANG to something other than 'C' forces the runtime to search
+          # for ICU, which will be required in most user environments.
+          checkConsoleOutput = command: ''
+            output="$(LANG=C.UTF-8 ${command})"
+            # yes, older SDKs omit the comma
+            [[ "$output" =~ Hello,?\ World! ]] && touch "$out"
+          '';
+        in
+        {
+          version = testers.testVersion (
+            {
+              package = finalAttrs.finalPackage;
             }
-            expect "Application started. Press Ctrl+C to shut down."
-            set output [exec curl -sSf $url]
-            if {$output != "Hello World!"} {
-              send_error "Unexpected output: $output\n"
-              exit 1
+            // lib.optionalAttrs (type != "sdk") {
+              command = "dotnet --info";
             }
-            send \x03
-            expect_before timeout abort
-            expect eof
-            catch wait result
-            exit [lindex $result 3]
-          EOF
-          touch $out
-        '';
-        runAllowNetworking = true;
-      };
-    } // lib.optionalAttrs finalAttrs.finalPackage.hasILCompiler {
-      aot = mkDotnetTest {
-        name = "aot";
-        stdenv = if stdenv.hostPlatform.isDarwin then swiftPackages.stdenv else stdenv;
-        template = "console";
-        usePackageSource = true;
-        buildInputs =
-          [ zlib
-          ] ++ lib.optional stdenv.hostPlatform.isDarwin (with darwin; with apple_sdk.frameworks; [
-            swiftPackages.swift
-            Foundation
-            CryptoKit
-            GSS
-            ICU
-          ]);
-        build = ''
-          dotnet restore -p:PublishAot=true
-          dotnet publish -p:PublishAot=true -o $out/bin
-        '';
-        runtime = null;
-        run = checkConsoleOutput "$src/bin/test";
-      };
-    }) // args.passthru.tests or {};
-  } // args.passthru or {};
-})
+          );
+        }
+        // lib.optionalAttrs (type == "sdk") (
+          {
+            console = mkDotnetTest {
+              name = "console";
+              template = "console";
+              build = checkConsoleOutput "dotnet run";
+            };
+
+            publish = mkDotnetTest {
+              name = "publish";
+              template = "console";
+              build = "dotnet publish -o $out/bin";
+              run = checkConsoleOutput "$src/bin/test";
+            };
+
+            self-contained = mkDotnetTest {
+              name = "self-contained";
+              template = "console";
+              usePackageSource = true;
+              build = "dotnet publish --use-current-runtime --sc -o $out";
+              runtime = null;
+              run = checkConsoleOutput "$src/test";
+            };
+
+            single-file = mkDotnetTest {
+              name = "single-file";
+              template = "console";
+              usePackageSource = true;
+              build = "dotnet publish --use-current-runtime -p:PublishSingleFile=true -o $out/bin";
+              runtime = null;
+              run = checkConsoleOutput "$src/bin/test";
+            };
+
+            web = mkDotnetTest {
+              name = "web";
+              template = "web";
+              build = "dotnet publish -o $out/bin";
+              runInputs = [
+                expect
+                curl
+              ];
+              run = ''
+                expect <<"EOF"
+                  set status 1
+                  spawn $env(src)/bin/test
+                  proc abort { } { exit 2 }
+                  expect_before default abort
+                  expect -re {Now listening on: ([^\r]+)\r} {
+                    set url $expect_out(1,string)
+                  }
+                  expect "Application started. Press Ctrl+C to shut down."
+                  set output [exec curl -sSf $url]
+                  if {$output != "Hello World!"} {
+                    send_error "Unexpected output: $output\n"
+                    exit 1
+                  }
+                  send \x03
+                  expect_before timeout abort
+                  expect eof
+                  catch wait result
+                  exit [lindex $result 3]
+                EOF
+                touch $out
+              '';
+              runAllowNetworking = true;
+            };
+          }
+          // lib.optionalAttrs finalAttrs.finalPackage.hasILCompiler {
+            aot = mkDotnetTest {
+              name = "aot";
+              stdenv = if stdenv.hostPlatform.isDarwin then swiftPackages.stdenv else stdenv;
+              template = "console";
+              usePackageSource = true;
+              buildInputs =
+                [
+                  zlib
+                ]
+                ++ lib.optional stdenv.hostPlatform.isDarwin (
+                  with darwin;
+                  with apple_sdk.frameworks;
+                  [
+                    swiftPackages.swift
+                    Foundation
+                    CryptoKit
+                    GSS
+                    ICU
+                  ]
+                );
+              build = ''
+                dotnet restore -p:PublishAot=true
+                dotnet publish -p:PublishAot=true -o $out/bin
+              '';
+              runtime = null;
+              run = checkConsoleOutput "$src/bin/test";
+            };
+          }
+        )
+        // args.passthru.tests or { };
+    } // args.passthru or { };
+  }
+)
diff --git a/pkgs/development/compilers/dotnet/default.nix b/pkgs/development/compilers/dotnet/default.nix
index 0c6999471c48..91854ea02b81 100644
--- a/pkgs/development/compilers/dotnet/default.nix
+++ b/pkgs/development/compilers/dotnet/default.nix
@@ -1,24 +1,26 @@
 /*
-How to combine packages for use in development:
-dotnetCombined = with dotnetCorePackages; combinePackages [ sdk_6_0 aspnetcore_7_0 ];
+  How to combine packages for use in development:
+  dotnetCombined = with dotnetCorePackages; combinePackages [ sdk_6_0 aspnetcore_7_0 ];
 
-Hashes and urls are retrieved from:
-https://dotnet.microsoft.com/download/dotnet
+  Hashes and urls are retrieved from:
+  https://dotnet.microsoft.com/download/dotnet
 */
-{ lib
-, config
-, recurseIntoAttrs
-, generateSplicesForMkScope
-, makeScopeWithSplicing'
+{
+  lib,
+  config,
+  recurseIntoAttrs,
+  generateSplicesForMkScope,
+  makeScopeWithSplicing',
 }:
 
 makeScopeWithSplicing' {
   otherSplices = generateSplicesForMkScope "dotnetCorePackages";
-  f = (self:
+  f = (
+    self:
     let
       callPackage = self.callPackage;
 
-      buildDotnet = attrs: callPackage (import ./build-dotnet.nix attrs) {};
+      buildDotnet = attrs: callPackage (import ./build-dotnet.nix attrs) { };
       buildAttrs = {
         buildAspNetCore = attrs: buildDotnet (attrs // { type = "aspnetcore"; });
         buildNetRuntime = attrs: buildDotnet (attrs // { type = "runtime"; });
@@ -40,16 +42,18 @@ makeScopeWithSplicing' {
         "i686-windows" = "win-x86";
       };
 
-    in {
+    in
+    {
       inherit callPackage;
 
       # Convert a "stdenv.hostPlatform.system" to a dotnet RID
-      systemToDotnetRid = system: runtimeIdentifierMap.${system} or (throw "unsupported platform ${system}");
+      systemToDotnetRid =
+        system: runtimeIdentifierMap.${system} or (throw "unsupported platform ${system}");
 
-      combinePackages = attrs: callPackage (import ./combine-packages.nix attrs) {};
+      combinePackages = attrs: callPackage (import ./combine-packages.nix attrs) { };
 
-      patchNupkgs = callPackage ./patch-nupkgs.nix {};
-      nugetPackageHook = callPackage ./nuget-package-hook.nix {};
+      patchNupkgs = callPackage ./patch-nupkgs.nix { };
+      nugetPackageHook = callPackage ./nuget-package-hook.nix { };
 
       buildDotnetModule = callPackage ../../../build-support/dotnet/build-dotnet-module { };
       buildDotnetGlobalTool = callPackage ../../../build-support/dotnet/build-dotnet-global-tool { };
@@ -60,13 +64,19 @@ makeScopeWithSplicing' {
       fetchNupkg = callPackage ../../../build-support/dotnet/fetch-nupkg { };
 
       dotnet_8 = recurseIntoAttrs (callPackage ./8 { bootstrapSdk = dotnet_8_0.sdk_8_0_1xx; });
-      dotnet_9 = recurseIntoAttrs (callPackage ./9 {});
-    } // lib.optionalAttrs config.allowAliases {
+      dotnet_9 = recurseIntoAttrs (callPackage ./9 { });
+    }
+    // lib.optionalAttrs config.allowAliases {
       # EOL
       sdk_2_1 = throw "Dotnet SDK 2.1 is EOL, please use 6.0 (LTS) or 7.0 (Current)";
       sdk_2_2 = throw "Dotnet SDK 2.2 is EOL, please use 6.0 (LTS) or 7.0 (Current)";
       sdk_3_0 = throw "Dotnet SDK 3.0 is EOL, please use 6.0 (LTS) or 7.0 (Current)";
       sdk_3_1 = throw "Dotnet SDK 3.1 is EOL, please use 6.0 (LTS) or 7.0 (Current)";
       sdk_5_0 = throw "Dotnet SDK 5.0 is EOL, please use 6.0 (LTS) or 7.0 (Current)";
-    } // dotnet_6_0 // dotnet_7_0 // dotnet_8_0 // dotnet_9_0);
+    }
+    // dotnet_6_0
+    // dotnet_7_0
+    // dotnet_8_0
+    // dotnet_9_0
+  );
 }
diff --git a/pkgs/development/compilers/dotnet/dotnet.nix b/pkgs/development/compilers/dotnet/dotnet.nix
index 7e629383ab37..f353d51a4a37 100644
--- a/pkgs/development/compilers/dotnet/dotnet.nix
+++ b/pkgs/development/compilers/dotnet/dotnet.nix
@@ -1,11 +1,12 @@
-{ callPackage
-, lib
-, releaseManifestFile
-, releaseInfoFile
-, allowPrerelease ? false
-, depsFile
-, bootstrapSdk
-, pkgsBuildHost
+{
+  callPackage,
+  lib,
+  releaseManifestFile,
+  releaseInfoFile,
+  allowPrerelease ? false,
+  depsFile,
+  bootstrapSdk,
+  pkgsBuildHost,
 }:
 
 let
@@ -14,11 +15,13 @@ let
   pkgs = callPackage ./stage1.nix {
     inherit releaseManifestFile tarballHash depsFile;
     bootstrapSdk =
-      { stdenvNoCC
-      , dotnetCorePackages
-      , fetchurl
-      }: bootstrapSdk.overrideAttrs (old: {
-        passthru = old.passthru or {} // {
+      {
+        stdenvNoCC,
+        dotnetCorePackages,
+        fetchurl,
+      }:
+      bootstrapSdk.overrideAttrs (old: {
+        passthru = old.passthru or { } // {
           artifacts = stdenvNoCC.mkDerivation rec {
             name = lib.nameFromURL artifactsUrl ".tar.gz";
 
@@ -38,8 +41,10 @@ let
       });
   };
 
-in pkgs // {
-  vmr = pkgs.vmr.overrideAttrs(old: {
+in
+pkgs
+// {
+  vmr = pkgs.vmr.overrideAttrs (old: {
     passthru = old.passthru // {
       updateScript = pkgsBuildHost.callPackage ./update.nix {
         inherit releaseManifestFile releaseInfoFile allowPrerelease;
diff --git a/pkgs/development/compilers/dotnet/packages.nix b/pkgs/development/compilers/dotnet/packages.nix
index 801896f38625..7976223ab994 100644
--- a/pkgs/development/compilers/dotnet/packages.nix
+++ b/pkgs/development/compilers/dotnet/packages.nix
@@ -1,16 +1,18 @@
-{ stdenv
-, callPackage
-, vmr
-, xmlstarlet
-, strip-nondeterminism
-, zip
+{
+  stdenv,
+  callPackage,
+  vmr,
+  xmlstarlet,
+  strip-nondeterminism,
+  zip,
 }:
 
 let
-  mkCommon = callPackage ./common.nix {};
+  mkCommon = callPackage ./common.nix { };
   inherit (vmr) targetRid releaseManifest;
 
-in {
+in
+{
   inherit vmr;
   sdk = mkCommon "sdk" rec {
     pname = "dotnet-sdk";
@@ -25,7 +27,11 @@ in {
       zip
     ];
 
-    outputs = [ "out" "packages" "artifacts" ];
+    outputs = [
+      "out"
+      "packages"
+      "artifacts"
+    ];
 
     installPhase = ''
       runHook preInstall
diff --git a/pkgs/development/compilers/dotnet/patch-nupkgs.nix b/pkgs/development/compilers/dotnet/patch-nupkgs.nix
index 528b236239e4..6885d8df71f3 100644
--- a/pkgs/development/compilers/dotnet/patch-nupkgs.nix
+++ b/pkgs/development/compilers/dotnet/patch-nupkgs.nix
@@ -1,83 +1,92 @@
-{ stdenv
-, lib
-, zlib
-, curl
-, icu
-, libunwind
-, libuuid
-, openssl
-, lttng-ust_2_12
-, patchelf
-, writeShellScriptBin
+{
+  stdenv,
+  lib,
+  zlib,
+  curl,
+  icu,
+  libunwind,
+  libuuid,
+  openssl,
+  lttng-ust_2_12,
+  patchelf,
+  writeShellScriptBin,
 }:
 
 let
-  binaryRPath = lib.makeLibraryPath ([
-    stdenv.cc.cc
-    zlib
-    curl
-    icu
-    libunwind
-    libuuid
-    openssl
-  ] ++ lib.optional stdenv.hostPlatform.isLinux lttng-ust_2_12);
+  binaryRPath = lib.makeLibraryPath (
+    [
+      stdenv.cc.cc
+      zlib
+      curl
+      icu
+      libunwind
+      libuuid
+      openssl
+    ]
+    ++ lib.optional stdenv.hostPlatform.isLinux lttng-ust_2_12
+  );
 
-in writeShellScriptBin "patch-nupkgs" (''
-  set -euo pipefail
-  shopt -s nullglob
-  isELF() {
-      local fn="$1"
-      local fd
-      local magic
-      exec {fd}< "$fn"
-      read -r -n 4 -u "$fd" magic
-      exec {fd}<&-
-      if [ "$magic" = $'\177ELF' ]; then return 0; else return 1; fi
-  }
-  cd "$1"
-'' + lib.optionalString stdenv.hostPlatform.isLinux ''
-  for x in */* */*; do
-    # .nupkg.metadata is written last, so we know the packages is complete
-    [[ -d "$x" ]] && [[ -f "$x"/.nupkg.metadata ]] \
-      && [[ ! -f "$x"/.nix-patched ]] || continue
-    echo "Patching package $x"
-    find "$x" -type f -print0 | while IFS= read -rd "" p; do
-      if [[ "$p" != *.nix-patched ]] \
-        && isELF "$p" \
-        && ${patchelf}/bin/patchelf --print-interpreter "$p" &>/dev/null; then
-        tmp="$p".$$.nix-patched
-        # if this fails to copy then another process must have patched it
-        cp --reflink=auto "$p" "$tmp" || continue
-        echo "Patchelfing $p as $tmp"
-        ${patchelf}/bin/patchelf \
-          --set-interpreter "${stdenv.cc.bintools.dynamicLinker}" \
-          "$tmp" ||:
-        # This makes sure that if the binary requires some specific runtime dependencies, it can find it.
-        # This fixes dotnet-built binaries like crossgen2
-        ${patchelf}/bin/patchelf \
-          --add-needed libicui18n.so \
-          --add-needed libicuuc.so \
-          --add-needed libz.so \
-          --add-needed libssl.so \
-          "$tmp"
-        ${patchelf}/bin/patchelf \
-          --add-rpath "${binaryRPath}" \
-          "$tmp" ||:
-        mv "$tmp" "$p"
-      fi
+in
+writeShellScriptBin "patch-nupkgs" (
+  ''
+    set -euo pipefail
+    shopt -s nullglob
+    isELF() {
+        local fn="$1"
+        local fd
+        local magic
+        exec {fd}< "$fn"
+        read -r -n 4 -u "$fd" magic
+        exec {fd}<&-
+        if [ "$magic" = $'\177ELF' ]; then return 0; else return 1; fi
+    }
+    cd "$1"
+  ''
+  + lib.optionalString stdenv.hostPlatform.isLinux ''
+    for x in */* */*; do
+      # .nupkg.metadata is written last, so we know the packages is complete
+      [[ -d "$x" ]] && [[ -f "$x"/.nupkg.metadata ]] \
+        && [[ ! -f "$x"/.nix-patched ]] || continue
+      echo "Patching package $x"
+      find "$x" -type f -print0 | while IFS= read -rd "" p; do
+        if [[ "$p" != *.nix-patched ]] \
+          && isELF "$p" \
+          && ${patchelf}/bin/patchelf --print-interpreter "$p" &>/dev/null; then
+          tmp="$p".$$.nix-patched
+          # if this fails to copy then another process must have patched it
+          cp --reflink=auto "$p" "$tmp" || continue
+          echo "Patchelfing $p as $tmp"
+          ${patchelf}/bin/patchelf \
+            --set-interpreter "${stdenv.cc.bintools.dynamicLinker}" \
+            "$tmp" ||:
+          # This makes sure that if the binary requires some specific runtime dependencies, it can find it.
+          # This fixes dotnet-built binaries like crossgen2
+          ${patchelf}/bin/patchelf \
+            --add-needed libicui18n.so \
+            --add-needed libicuuc.so \
+            --add-needed libz.so \
+            --add-needed libssl.so \
+            "$tmp"
+          ${patchelf}/bin/patchelf \
+            --add-rpath "${binaryRPath}" \
+            "$tmp" ||:
+          mv "$tmp" "$p"
+        fi
+      done
+      touch "$x"/.nix-patched
     done
-    touch "$x"/.nix-patched
-  done
-'' + lib.optionalString stdenv.hostPlatform.isDarwin ''
-  for x in microsoft.dotnet.ilcompiler/*; do
-    # .nupkg.metadata is written last, so we know the packages is complete
-    [[ -d "$x" ]] && [[ -f "$x"/.nupkg.metadata ]] \
-      && [[ ! -f "$x"/.nix-patched-ilcompiler ]] || continue
-    echo "Patching package $x"
-    pushd "$x"
-    sed -i 's: -no_code_signature_warning::g' build/Microsoft.NETCore.Native.targets
-    sed -i 's:Include="-ld_classic"::g' build/Microsoft.NETCore.Native.Unix.targets
-    touch .nix-patched-ilcompiler
-    popd
-  done
-'')
+  ''
+  + lib.optionalString stdenv.hostPlatform.isDarwin ''
+    for x in microsoft.dotnet.ilcompiler/*; do
+      # .nupkg.metadata is written last, so we know the packages is complete
+      [[ -d "$x" ]] && [[ -f "$x"/.nupkg.metadata ]] \
+        && [[ ! -f "$x"/.nix-patched-ilcompiler ]] || continue
+      echo "Patching package $x"
+      pushd "$x"
+      sed -i 's: -no_code_signature_warning::g' build/Microsoft.NETCore.Native.targets
+      sed -i 's:Include="-ld_classic"::g' build/Microsoft.NETCore.Native.Unix.targets
+      touch .nix-patched-ilcompiler
+      popd
+    done
+  ''
+)
diff --git a/pkgs/development/compilers/dotnet/sign-apphost.nix b/pkgs/development/compilers/dotnet/sign-apphost.nix
index f804ab79d332..021d9ef61a90 100644
--- a/pkgs/development/compilers/dotnet/sign-apphost.nix
+++ b/pkgs/development/compilers/dotnet/sign-apphost.nix
@@ -1,10 +1,12 @@
-{ substituteAll
-, callPackage
+{
+  substituteAll,
+  callPackage,
 }:
 let
-  sigtool = callPackage ./sigtool.nix {};
+  sigtool = callPackage ./sigtool.nix { };
 
-in substituteAll {
+in
+substituteAll {
   src = ./sign-apphost.proj;
   codesign = "${sigtool}/bin/codesign";
 }
diff --git a/pkgs/development/compilers/dotnet/sigtool.nix b/pkgs/development/compilers/dotnet/sigtool.nix
index fe5d1ebc6879..04e0d5215098 100644
--- a/pkgs/development/compilers/dotnet/sigtool.nix
+++ b/pkgs/development/compilers/dotnet/sigtool.nix
@@ -1,7 +1,8 @@
-{ cctools
-, darwin
-, fetchFromGitHub
-, makeWrapper
+{
+  cctools,
+  darwin,
+  fetchFromGitHub,
+  makeWrapper,
 }:
 
 darwin.sigtool.overrideAttrs (old: {
@@ -14,13 +15,15 @@ darwin.sigtool.overrideAttrs (old: {
     sha256 = "sha256-EVM5ZG3sAHrIXuWrnqA9/4pDkJOpWCeBUl5fh0mkK4k=";
   };
 
-  nativeBuildInputs = old.nativeBuildInputs or [] ++ [
+  nativeBuildInputs = old.nativeBuildInputs or [ ] ++ [
     makeWrapper
   ];
 
-  postInstall = old.postInstall or "" + ''
-    wrapProgram $out/bin/codesign \
-      --set-default CODESIGN_ALLOCATE \
-        "${cctools}/bin/${cctools.targetPrefix}codesign_allocate"
-  '';
+  postInstall =
+    old.postInstall or ""
+    + ''
+      wrapProgram $out/bin/codesign \
+        --set-default CODESIGN_ALLOCATE \
+          "${cctools}/bin/${cctools.targetPrefix}codesign_allocate"
+    '';
 })
diff --git a/pkgs/development/compilers/dotnet/stage0.nix b/pkgs/development/compilers/dotnet/stage0.nix
index 7e2717aba1a1..17de17a71bc3 100644
--- a/pkgs/development/compilers/dotnet/stage0.nix
+++ b/pkgs/development/compilers/dotnet/stage0.nix
@@ -1,26 +1,27 @@
-{ stdenv
-, callPackage
-, lib
-, writeShellScript
-, mkNugetDeps
-, nix
-, cacert
-, nuget-to-nix
-, dotnetCorePackages
-, xmlstarlet
-, patchNupkgs
+{
+  stdenv,
+  callPackage,
+  lib,
+  writeShellScript,
+  mkNugetDeps,
+  nix,
+  cacert,
+  nuget-to-nix,
+  dotnetCorePackages,
+  xmlstarlet,
+  patchNupkgs,
 
-, releaseManifestFile
-, tarballHash
-, depsFile
-, bootstrapSdk
+  releaseManifestFile,
+  tarballHash,
+  depsFile,
+  bootstrapSdk,
 }:
 
 let
   mkPackages = callPackage ./packages.nix;
   mkVMR = callPackage ./vmr.nix;
 
-  dotnetSdk = callPackage bootstrapSdk {};
+  dotnetSdk = callPackage bootstrapSdk { };
 
   deps = mkNugetDeps {
     name = "dotnet-vmr-deps";
@@ -31,100 +32,110 @@ let
     installable = true;
   };
 
-  vmr = (mkVMR {
-    inherit releaseManifestFile tarballHash dotnetSdk;
-  }).overrideAttrs (old: rec {
-    prebuiltPackages = mkNugetDeps {
-      name = "dotnet-vmr-deps";
-      sourceFile = depsFile;
-      installable = true;
-    };
+  vmr =
+    (mkVMR {
+      inherit releaseManifestFile tarballHash dotnetSdk;
+    }).overrideAttrs
+      (old: rec {
+        prebuiltPackages = mkNugetDeps {
+          name = "dotnet-vmr-deps";
+          sourceFile = depsFile;
+          installable = true;
+        };
 
-    nativeBuildInputs =
-      old.nativeBuildInputs or []
-      ++ [ xmlstarlet patchNupkgs ];
+        nativeBuildInputs = old.nativeBuildInputs or [ ] ++ [
+          xmlstarlet
+          patchNupkgs
+        ];
 
-    postPatch = old.postPatch or "" + ''
-      xmlstarlet ed \
-        --inplace \
-        -s //Project -t elem -n Import \
-        -i \$prev -t attr -n Project -v "${./patch-restored-packages.proj}" \
-        src/*/Directory.Build.targets
-    '';
-
-    postConfigure = old.postConfigure or "" + ''
-      [[ ! -v prebuiltPackages ]] || \
-        ln -sf "$prebuiltPackages"/share/nuget/source/*/*/*.nupkg prereqs/packages/prebuilt/
-      ln -sf "${sdkPackages}"/share/nuget/source/*/*/*.nupkg prereqs/packages/prebuilt/
-    '';
-
-    buildFlags =
-      old.buildFlags
-      ++ lib.optionals (lib.versionAtLeast old.version "9") [
-        # We need to set this as long as we have something in deps.nix. Currently
-        # that's the portable ilasm/ildasm which aren't in the centos sourcebuilt
-        # artifacts.
-        "-p:SkipErrorOnPrebuilts=true"
-      ];
-
-    passthru = old.passthru or {} // { fetch-deps =
-      let
-        inherit (vmr) targetRid updateScript;
-        otherRids =
-          lib.remove targetRid (
-            map (system: dotnetCorePackages.systemToDotnetRid system)
-              vmr.meta.platforms);
-
-        pkg = vmr.overrideAttrs (old: {
-          nativeBuildInputs = old.nativeBuildInputs ++ [
-            nix
-            cacert
-            nuget-to-nix
-          ];
-          postPatch = old.postPatch or "" + ''
+        postPatch =
+          old.postPatch or ""
+          + ''
             xmlstarlet ed \
               --inplace \
               -s //Project -t elem -n Import \
-              -i \$prev -t attr -n Project -v "${./record-downloaded-packages.proj}" \
-              repo-projects/Directory.Build.targets
-            # make nuget-client use the standard arcade package-cache dir, which
-            # is where we scan for dependencies
-            xmlstarlet ed \
-              --inplace \
-              -s //Project -t elem -n ItemGroup \
-              -s \$prev -t elem -n EnvironmentVariables \
-              -i \$prev -t attr -n Include -v 'NUGET_PACKAGES=$(ProjectDirectory)artifacts/sb/package-cache/' \
-              repo-projects/nuget-client.proj
+              -i \$prev -t attr -n Project -v "${./patch-restored-packages.proj}" \
+              src/*/Directory.Build.targets
           '';
-          buildFlags = [ "--online" ] ++ old.buildFlags;
-          prebuiltPackages = null;
-        });
 
-        drv = builtins.unsafeDiscardOutputDependency pkg.drvPath;
-      in
-        writeShellScript "fetch-dotnet-sdk-deps" ''
-          ${nix}/bin/nix-shell --pure --run 'source /dev/stdin' "${drv}" << 'EOF'
-          set -e
+        postConfigure =
+          old.postConfigure or ""
+          + ''
+            [[ ! -v prebuiltPackages ]] || \
+              ln -sf "$prebuiltPackages"/share/nuget/source/*/*/*.nupkg prereqs/packages/prebuilt/
+            ln -sf "${sdkPackages}"/share/nuget/source/*/*/*.nupkg prereqs/packages/prebuilt/
+          '';
 
-          tmp=$(mktemp -d)
-          trap 'rm -fr "$tmp"' EXIT
+        buildFlags =
+          old.buildFlags
+          ++ lib.optionals (lib.versionAtLeast old.version "9") [
+            # We need to set this as long as we have something in deps.nix. Currently
+            # that's the portable ilasm/ildasm which aren't in the centos sourcebuilt
+            # artifacts.
+            "-p:SkipErrorOnPrebuilts=true"
+          ];
 
-          HOME=$tmp/.home
-          cd "$tmp"
+        passthru = old.passthru or { } // {
+          fetch-deps =
+            let
+              inherit (vmr) targetRid updateScript;
+              otherRids = lib.remove targetRid (
+                map (system: dotnetCorePackages.systemToDotnetRid system) vmr.meta.platforms
+              );
 
-          phases="''${prePhases[*]:-} unpackPhase patchPhase ''${preConfigurePhases[*]:-} \
-            configurePhase ''${preBuildPhases[*]:-} buildPhase checkPhase" \
-            genericBuild
+              pkg = vmr.overrideAttrs (old: {
+                nativeBuildInputs = old.nativeBuildInputs ++ [
+                  nix
+                  cacert
+                  nuget-to-nix
+                ];
+                postPatch =
+                  old.postPatch or ""
+                  + ''
+                    xmlstarlet ed \
+                      --inplace \
+                      -s //Project -t elem -n Import \
+                      -i \$prev -t attr -n Project -v "${./record-downloaded-packages.proj}" \
+                      repo-projects/Directory.Build.targets
+                    # make nuget-client use the standard arcade package-cache dir, which
+                    # is where we scan for dependencies
+                    xmlstarlet ed \
+                      --inplace \
+                      -s //Project -t elem -n ItemGroup \
+                      -s \$prev -t elem -n EnvironmentVariables \
+                      -i \$prev -t attr -n Include -v 'NUGET_PACKAGES=$(ProjectDirectory)artifacts/sb/package-cache/' \
+                      repo-projects/nuget-client.proj
+                  '';
+                buildFlags = [ "--online" ] ++ old.buildFlags;
+                prebuiltPackages = null;
+              });
 
-          depsFiles=(./src/*/deps.nix)
+              drv = builtins.unsafeDiscardOutputDependency pkg.drvPath;
+            in
+            writeShellScript "fetch-dotnet-sdk-deps" ''
+              ${nix}/bin/nix-shell --pure --run 'source /dev/stdin' "${drv}" << 'EOF'
+              set -e
 
-          cat $(nix-build ${toString ./combine-deps.nix} \
-            --arg list "[ ''${depsFiles[*]} ]" \
-            --argstr baseRid ${targetRid} \
-            --arg otherRids '${lib.generators.toPretty { multiline = false; } otherRids}' \
-            ) > "${toString prebuiltPackages.sourceFile}"
-          EOF
-        '';
-    };
-  });
-in mkPackages { inherit vmr; }
+              tmp=$(mktemp -d)
+              trap 'rm -fr "$tmp"' EXIT
+
+              HOME=$tmp/.home
+              cd "$tmp"
+
+              phases="''${prePhases[*]:-} unpackPhase patchPhase ''${preConfigurePhases[*]:-} \
+                configurePhase ''${preBuildPhases[*]:-} buildPhase checkPhase" \
+                genericBuild
+
+              depsFiles=(./src/*/deps.nix)
+
+              cat $(nix-build ${toString ./combine-deps.nix} \
+                --arg list "[ ''${depsFiles[*]} ]" \
+                --argstr baseRid ${targetRid} \
+                --arg otherRids '${lib.generators.toPretty { multiline = false; } otherRids}' \
+                ) > "${toString prebuiltPackages.sourceFile}"
+              EOF
+            '';
+        };
+      });
+in
+mkPackages { inherit vmr; }
diff --git a/pkgs/development/compilers/dotnet/stage1.nix b/pkgs/development/compilers/dotnet/stage1.nix
index 9014e60b4e90..bf1273c56cb2 100644
--- a/pkgs/development/compilers/dotnet/stage1.nix
+++ b/pkgs/development/compilers/dotnet/stage1.nix
@@ -1,11 +1,12 @@
-{ stdenv
-, lib
-, callPackage
+{
+  stdenv,
+  lib,
+  callPackage,
 
-, releaseManifestFile
-, tarballHash
-, depsFile
-, bootstrapSdk
+  releaseManifestFile,
+  tarballHash,
+  depsFile,
+  bootstrapSdk,
 }@args:
 
 let
@@ -14,13 +15,16 @@ let
 
   stage0 = callPackage ./stage0.nix args;
 
-  vmr = (mkVMR {
-    inherit releaseManifestFile tarballHash;
-    dotnetSdk = stage0.sdk;
-  }).overrideAttrs (old: {
-    passthru = old.passthru or {} // {
-      inherit (stage0.vmr) fetch-deps;
-    };
-  });
+  vmr =
+    (mkVMR {
+      inherit releaseManifestFile tarballHash;
+      dotnetSdk = stage0.sdk;
+    }).overrideAttrs
+      (old: {
+        passthru = old.passthru or { } // {
+          inherit (stage0.vmr) fetch-deps;
+        };
+      });
 
-in mkPackages { inherit vmr; } // { stage0 = lib.dontRecurseIntoAttrs stage0; }
+in
+mkPackages { inherit vmr; } // { stage0 = lib.dontRecurseIntoAttrs stage0; }
diff --git a/pkgs/development/compilers/dotnet/update.nix b/pkgs/development/compilers/dotnet/update.nix
index 58304188afa8..cb482d7658cf 100644
--- a/pkgs/development/compilers/dotnet/update.nix
+++ b/pkgs/development/compilers/dotnet/update.nix
@@ -1,18 +1,19 @@
-{ stdenvNoCC
-, lib
-, fetchurl
-, writeScript
-, nix
-, runtimeShell
-, curl
-, cacert
-, jq
-, yq
-, gnupg
+{
+  stdenvNoCC,
+  lib,
+  fetchurl,
+  writeScript,
+  nix,
+  runtimeShell,
+  curl,
+  cacert,
+  jq,
+  yq,
+  gnupg,
 
-, releaseManifestFile
-, releaseInfoFile
-, allowPrerelease
+  releaseManifestFile,
+  releaseInfoFile,
+  allowPrerelease,
 }:
 
 let
@@ -38,7 +39,8 @@ let
 
   drv = builtins.unsafeDiscardOutputDependency pkg.drvPath;
 
-in writeScript "update-dotnet-vmr.sh" ''
+in
+writeScript "update-dotnet-vmr.sh" ''
   #! ${nix}/bin/nix-shell
   #! nix-shell -i ${runtimeShell} --pure ${drv}
   set -euo pipefail
diff --git a/pkgs/development/compilers/dotnet/vmr.nix b/pkgs/development/compilers/dotnet/vmr.nix
index 41b0eac15734..e9124e115f98 100644
--- a/pkgs/development/compilers/dotnet/vmr.nix
+++ b/pkgs/development/compilers/dotnet/vmr.nix
@@ -1,46 +1,46 @@
-{ clangStdenv
-, lib
-, fetchurl
-, dotnetCorePackages
-, jq
-, curl
-, git
-, cmake
-, pkg-config
-, llvm
-, zlib
-, icu
-, lttng-ust_2_12
-, krb5
-, glibcLocales
-, ensureNewerSourcesForZipFilesHook
-, darwin
-, xcbuild
-, swiftPackages
-, openssl
-, getconf
-, python3
-, xmlstarlet
-, nodejs
-, callPackage
-, unzip
-, yq
+{
+  clangStdenv,
+  lib,
+  fetchurl,
+  dotnetCorePackages,
+  jq,
+  curl,
+  git,
+  cmake,
+  pkg-config,
+  llvm,
+  zlib,
+  icu,
+  lttng-ust_2_12,
+  krb5,
+  glibcLocales,
+  ensureNewerSourcesForZipFilesHook,
+  darwin,
+  xcbuild,
+  swiftPackages,
+  openssl,
+  getconf,
+  python3,
+  xmlstarlet,
+  nodejs,
+  callPackage,
+  unzip,
+  yq,
 
-, dotnetSdk
-, releaseManifestFile
-, tarballHash
+  dotnetSdk,
+  releaseManifestFile,
+  tarballHash,
 }:
 
 let
-  stdenv = if clangStdenv.hostPlatform.isDarwin
-    then swiftPackages.stdenv
-    else clangStdenv;
+  stdenv = if clangStdenv.hostPlatform.isDarwin then swiftPackages.stdenv else clangStdenv;
 
   inherit (stdenv)
     isLinux
     isDarwin
     buildPlatform
-    targetPlatform;
+    targetPlatform
+    ;
   inherit (swiftPackages) apple_sdk swift;
 
   releaseManifest = lib.importJSON releaseManifestFile;
@@ -50,11 +50,12 @@ let
   targetRid = dotnetCorePackages.systemToDotnetRid targetPlatform.system;
   targetArch = lib.elemAt (lib.splitString "-" targetRid) 1;
 
-  sigtool = callPackage ./sigtool.nix {};
+  sigtool = callPackage ./sigtool.nix { };
 
   _icu = if isDarwin then darwin.ICU else icu;
 
-in stdenv.mkDerivation rec {
+in
+stdenv.mkDerivation rec {
   pname = "dotnet-vmr";
   version = release;
 
@@ -69,53 +70,58 @@ in stdenv.mkDerivation rec {
     hash = tarballHash;
   };
 
-  nativeBuildInputs = [
-    ensureNewerSourcesForZipFilesHook
-    jq
-    curl.bin
-    git
-    cmake
-    pkg-config
-    python3
-    xmlstarlet
-    unzip
-    yq
-  ]
-  ++ lib.optionals (lib.versionAtLeast version "9") [
-    nodejs
-  ]
-  ++ lib.optionals isDarwin [
-    getconf
-  ];
+  nativeBuildInputs =
+    [
+      ensureNewerSourcesForZipFilesHook
+      jq
+      curl.bin
+      git
+      cmake
+      pkg-config
+      python3
+      xmlstarlet
+      unzip
+      yq
+    ]
+    ++ lib.optionals (lib.versionAtLeast version "9") [
+      nodejs
+    ]
+    ++ lib.optionals isDarwin [
+      getconf
+    ];
 
-  buildInputs = [
-    # this gets copied into the tree, but we still want the hooks to run
-    dotnetSdk
-    # the propagated build inputs in llvm.dev break swift compilation
-    llvm.out
-    zlib
-    _icu
-    openssl
-  ]
-  ++ lib.optionals isLinux [
-    krb5
-    lttng-ust_2_12
-  ]
-  ++ lib.optionals isDarwin (with apple_sdk.frameworks; [
-    xcbuild
-    swift
-    (krb5.overrideAttrs (old: {
-      # the propagated build inputs break swift compilation
-      buildInputs = old.buildInputs ++ old.propagatedBuildInputs;
-      propagatedBuildInputs = [];
-    }))
-    sigtool
-    Foundation
-    CoreFoundation
-    CryptoKit
-    System
-  ]
-  ++ lib.optional (lib.versionAtLeast version "9") GSS);
+  buildInputs =
+    [
+      # this gets copied into the tree, but we still want the hooks to run
+      dotnetSdk
+      # the propagated build inputs in llvm.dev break swift compilation
+      llvm.out
+      zlib
+      _icu
+      openssl
+    ]
+    ++ lib.optionals isLinux [
+      krb5
+      lttng-ust_2_12
+    ]
+    ++ lib.optionals isDarwin (
+      with apple_sdk.frameworks;
+      [
+        xcbuild
+        swift
+        (krb5.overrideAttrs (old: {
+          # the propagated build inputs break swift compilation
+          buildInputs = old.buildInputs ++ old.propagatedBuildInputs;
+          propagatedBuildInputs = [ ];
+        }))
+        sigtool
+        Foundation
+        CoreFoundation
+        CryptoKit
+        System
+      ]
+      ++ lib.optional (lib.versionAtLeast version "9") GSS
+    );
 
   # This is required to fix the error:
   # > CSSM_ModuleLoad(): One or more parameters passed to a function were not valid.
@@ -136,212 +142,217 @@ in stdenv.mkDerivation rec {
     ./fix-aspnetcore-portable-build.patch
   ];
 
-  postPatch = ''
-    # set the sdk version in global.json to match the bootstrap sdk
-    jq '(.tools.dotnet=$dotnet)' global.json --arg dotnet "$(${dotnetSdk}/bin/dotnet --version)" > global.json~
-    mv global.json{~,}
+  postPatch =
+    ''
+      # set the sdk version in global.json to match the bootstrap sdk
+      jq '(.tools.dotnet=$dotnet)' global.json --arg dotnet "$(${dotnetSdk}/bin/dotnet --version)" > global.json~
+      mv global.json{~,}
 
-    patchShebangs $(find -name \*.sh -type f -executable)
+      patchShebangs $(find -name \*.sh -type f -executable)
 
-    # I'm not sure why this is required, but these files seem to use the wrong
-    # property name.
-    # TODO: not needed in 9.0?
-    [[ ! -f src/xliff-tasks/eng/Versions.props ]] || \
-      sed -i 's:\bVersionBase\b:VersionPrefix:g' \
-        src/xliff-tasks/eng/Versions.props
+      # I'm not sure why this is required, but these files seem to use the wrong
+      # property name.
+      # TODO: not needed in 9.0?
+      [[ ! -f src/xliff-tasks/eng/Versions.props ]] || \
+        sed -i 's:\bVersionBase\b:VersionPrefix:g' \
+          src/xliff-tasks/eng/Versions.props
 
-    # at least in 9.0 preview 1, this package depends on a specific beta build
-    # of System.CommandLine
-    xmlstarlet ed \
-      --inplace \
-      -s //Project -t elem -n PropertyGroup \
-      -s \$prev -t elem -n NoWarn -v '$(NoWarn);NU1603' \
-      src/nuget-client/src/NuGet.Core/NuGet.CommandLine.XPlat/NuGet.CommandLine.XPlat.csproj
+      # at least in 9.0 preview 1, this package depends on a specific beta build
+      # of System.CommandLine
+      xmlstarlet ed \
+        --inplace \
+        -s //Project -t elem -n PropertyGroup \
+        -s \$prev -t elem -n NoWarn -v '$(NoWarn);NU1603' \
+        src/nuget-client/src/NuGet.Core/NuGet.CommandLine.XPlat/NuGet.CommandLine.XPlat.csproj
 
-    # AD0001 crashes intermittently in source-build-reference-packages with
-    # CSC : error AD0001: Analyzer 'Microsoft.NetCore.CSharp.Analyzers.Runtime.CSharpDetectPreviewFeatureAnalyzer' threw an exception of type 'System.NullReferenceException' with message 'Object reference not set to an instance of an object.'.
-    # possibly related to https://github.com/dotnet/runtime/issues/90356
-    xmlstarlet ed \
-      --inplace \
-      -s //Project -t elem -n PropertyGroup \
-      -s \$prev -t elem -n NoWarn -v '$(NoWarn);AD0001' \
-      src/source-build-reference-packages/src/referencePackages/Directory.Build.props
+      # AD0001 crashes intermittently in source-build-reference-packages with
+      # CSC : error AD0001: Analyzer 'Microsoft.NetCore.CSharp.Analyzers.Runtime.CSharpDetectPreviewFeatureAnalyzer' threw an exception of type 'System.NullReferenceException' with message 'Object reference not set to an instance of an object.'.
+      # possibly related to https://github.com/dotnet/runtime/issues/90356
+      xmlstarlet ed \
+        --inplace \
+        -s //Project -t elem -n PropertyGroup \
+        -s \$prev -t elem -n NoWarn -v '$(NoWarn);AD0001' \
+        src/source-build-reference-packages/src/referencePackages/Directory.Build.props
 
-    # https://github.com/microsoft/ApplicationInsights-dotnet/issues/2848
-    xmlstarlet ed \
-      --inplace \
-      -u //_:Project/_:PropertyGroup/_:BuildNumber -v 0 \
-      src/source-build-externals/src/application-insights/.props/_GlobalStaticVersion.props
+      # https://github.com/microsoft/ApplicationInsights-dotnet/issues/2848
+      xmlstarlet ed \
+        --inplace \
+        -u //_:Project/_:PropertyGroup/_:BuildNumber -v 0 \
+        src/source-build-externals/src/application-insights/.props/_GlobalStaticVersion.props
 
-    # this fixes compile errors with clang 15 (e.g. darwin)
-    substituteInPlace \
-      src/runtime/src/native/libs/CMakeLists.txt \
-      --replace-fail 'add_compile_options(-Weverything)' 'add_compile_options(-Wall)'
+      # this fixes compile errors with clang 15 (e.g. darwin)
+      substituteInPlace \
+        src/runtime/src/native/libs/CMakeLists.txt \
+        --replace-fail 'add_compile_options(-Weverything)' 'add_compile_options(-Wall)'
 
-    # strip native symbols in runtime
-    # see: https://github.com/dotnet/source-build/issues/2543
-    xmlstarlet ed \
-      --inplace \
-      -s //Project -t elem -n PropertyGroup \
-      -s \$prev -t elem -n KeepNativeSymbols -v false \
-      src/runtime/Directory.Build.props
-  ''
-  + lib.optionalString (lib.versionAtLeast version "9") ''
-    # repro.csproj fails to restore due to missing freebsd packages
-    xmlstarlet ed \
-      --inplace \
-      -s //Project -t elem -n PropertyGroup \
-      -s \$prev -t elem -n RuntimeIdentifiers -v ${targetRid} \
-      src/runtime/src/coreclr/tools/aot/ILCompiler/repro/repro.csproj
+      # strip native symbols in runtime
+      # see: https://github.com/dotnet/source-build/issues/2543
+      xmlstarlet ed \
+        --inplace \
+        -s //Project -t elem -n PropertyGroup \
+        -s \$prev -t elem -n KeepNativeSymbols -v false \
+        src/runtime/Directory.Build.props
+    ''
+    + lib.optionalString (lib.versionAtLeast version "9") ''
+      # repro.csproj fails to restore due to missing freebsd packages
+      xmlstarlet ed \
+        --inplace \
+        -s //Project -t elem -n PropertyGroup \
+        -s \$prev -t elem -n RuntimeIdentifiers -v ${targetRid} \
+        src/runtime/src/coreclr/tools/aot/ILCompiler/repro/repro.csproj
 
-    # https://github.com/dotnet/runtime/pull/98559#issuecomment-1965338627
-    xmlstarlet ed \
-      --inplace \
-      -s //Project -t elem -n PropertyGroup \
-      -s \$prev -t elem -n NoWarn -v '$(NoWarn);CS9216' \
-      src/runtime/Directory.Build.props
+      # https://github.com/dotnet/runtime/pull/98559#issuecomment-1965338627
+      xmlstarlet ed \
+        --inplace \
+        -s //Project -t elem -n PropertyGroup \
+        -s \$prev -t elem -n NoWarn -v '$(NoWarn);CS9216' \
+        src/runtime/Directory.Build.props
 
-    # patch packages installed from npm cache
-    xmlstarlet ed \
-      --inplace \
-      -s //Project -t elem -n Import \
-      -i \$prev -t attr -n Project -v "${./patch-npm-packages.proj}" \
-      src/aspnetcore/eng/DotNetBuild.props
-  ''
-  + lib.optionalString (lib.versionAtLeast version "9") ''
-    # https://github.com/dotnet/source-build/issues/3131#issuecomment-2030215805
-    substituteInPlace \
-      src/aspnetcore/eng/Dependencies.props \
-      --replace-fail \
-      "'\$(DotNetBuildSourceOnly)' == 'true'" \
-      "'\$(DotNetBuildSourceOnly)' == 'true' and \$(PortableBuild) == 'false'"
+      # patch packages installed from npm cache
+      xmlstarlet ed \
+        --inplace \
+        -s //Project -t elem -n Import \
+        -i \$prev -t attr -n Project -v "${./patch-npm-packages.proj}" \
+        src/aspnetcore/eng/DotNetBuild.props
+    ''
+    + lib.optionalString (lib.versionAtLeast version "9") ''
+      # https://github.com/dotnet/source-build/issues/3131#issuecomment-2030215805
+      substituteInPlace \
+        src/aspnetcore/eng/Dependencies.props \
+        --replace-fail \
+        "'\$(DotNetBuildSourceOnly)' == 'true'" \
+        "'\$(DotNetBuildSourceOnly)' == 'true' and \$(PortableBuild) == 'false'"
 
-    # https://github.com/dotnet/source-build/issues/4325
-    xmlstarlet ed \
-      --inplace \
-      -r '//Target[@Name="UnpackTarballs"]/Move' -v Copy \
-      eng/init-source-only.proj
+      # https://github.com/dotnet/source-build/issues/4325
+      xmlstarlet ed \
+        --inplace \
+        -r '//Target[@Name="UnpackTarballs"]/Move' -v Copy \
+        eng/init-source-only.proj
 
-    # error: _FORTIFY_SOURCE requires compiling with optimization (-O) [-Werror,-W#warnings]
-    substituteInPlace \
-      src/runtime/src/coreclr/ilasm/CMakeLists.txt \
-      --replace-fail 'set_source_files_properties( prebuilt/asmparse.cpp PROPERTIES COMPILE_FLAGS "-O0" )' ""
+      # error: _FORTIFY_SOURCE requires compiling with optimization (-O) [-Werror,-W#warnings]
+      substituteInPlace \
+        src/runtime/src/coreclr/ilasm/CMakeLists.txt \
+        --replace-fail 'set_source_files_properties( prebuilt/asmparse.cpp PROPERTIES COMPILE_FLAGS "-O0" )' ""
 
-    # https://github.com/dotnet/source-build/issues/4444
-    xmlstarlet ed \
-      --inplace \
-      -s '//Project/Target/MSBuild[@Targets="Restore"]' \
-      -t attr -n Properties -v "NUGET_PACKAGES='\$(CurrentRepoSourceBuildPackageCache)'" \
-      src/aspnetcore/eng/Tools.props
-  ''
-  + lib.optionalString isLinux (''
-    substituteInPlace \
-      src/runtime/src/native/libs/System.Security.Cryptography.Native/opensslshim.c \
-      --replace-fail '"libssl.so"' '"${openssl.out}/lib/libssl.so"'
+      # https://github.com/dotnet/source-build/issues/4444
+      xmlstarlet ed \
+        --inplace \
+        -s '//Project/Target/MSBuild[@Targets="Restore"]' \
+        -t attr -n Properties -v "NUGET_PACKAGES='\$(CurrentRepoSourceBuildPackageCache)'" \
+        src/aspnetcore/eng/Tools.props
+    ''
+    + lib.optionalString isLinux (
+      ''
+        substituteInPlace \
+          src/runtime/src/native/libs/System.Security.Cryptography.Native/opensslshim.c \
+          --replace-fail '"libssl.so"' '"${openssl.out}/lib/libssl.so"'
 
-    substituteInPlace \
-      src/runtime/src/native/libs/System.Net.Security.Native/pal_gssapi.c \
-      --replace-fail '"libgssapi_krb5.so.2"' '"${lib.getLib krb5}/lib/libgssapi_krb5.so.2"'
+        substituteInPlace \
+          src/runtime/src/native/libs/System.Net.Security.Native/pal_gssapi.c \
+          --replace-fail '"libgssapi_krb5.so.2"' '"${lib.getLib krb5}/lib/libgssapi_krb5.so.2"'
 
-    substituteInPlace \
-      src/runtime/src/native/libs/System.Globalization.Native/pal_icushim.c \
-      --replace-fail '"libicui18n.so"' '"${icu}/lib/libicui18n.so"' \
-      --replace-fail '"libicuuc.so"' '"${icu}/lib/libicuuc.so"'
-  ''
-  + lib.optionalString (lib.versionAtLeast version "9") ''
-    substituteInPlace \
-      src/runtime/src/native/libs/System.Globalization.Native/pal_icushim.c \
-      --replace-fail '#define VERSIONED_LIB_NAME_LEN 64' '#define VERSIONED_LIB_NAME_LEN 256'
-  ''
-  + lib.optionalString (lib.versionOlder version "9") ''
-    substituteInPlace \
-      src/runtime/src/native/libs/System.Globalization.Native/pal_icushim.c \
-      --replace-warn 'libicuucName[64]' 'libicuucName[256]' \
-      --replace-warn 'libicui18nName[64]' 'libicui18nName[256]'
-  '')
-  + lib.optionalString isDarwin (''
-    substituteInPlace \
-      src/runtime/src/native/libs/System.Globalization.Native/CMakeLists.txt \
-      --replace-fail '/usr/lib/libicucore.dylib' '${darwin.ICU}/lib/libicucore.dylib'
+        substituteInPlace \
+          src/runtime/src/native/libs/System.Globalization.Native/pal_icushim.c \
+          --replace-fail '"libicui18n.so"' '"${icu}/lib/libicui18n.so"' \
+          --replace-fail '"libicuuc.so"' '"${icu}/lib/libicuuc.so"'
+      ''
+      + lib.optionalString (lib.versionAtLeast version "9") ''
+        substituteInPlace \
+          src/runtime/src/native/libs/System.Globalization.Native/pal_icushim.c \
+          --replace-fail '#define VERSIONED_LIB_NAME_LEN 64' '#define VERSIONED_LIB_NAME_LEN 256'
+      ''
+      + lib.optionalString (lib.versionOlder version "9") ''
+        substituteInPlace \
+          src/runtime/src/native/libs/System.Globalization.Native/pal_icushim.c \
+          --replace-warn 'libicuucName[64]' 'libicuucName[256]' \
+          --replace-warn 'libicui18nName[64]' 'libicui18nName[256]'
+      ''
+    )
+    + lib.optionalString isDarwin (
+      ''
+        substituteInPlace \
+          src/runtime/src/native/libs/System.Globalization.Native/CMakeLists.txt \
+          --replace-fail '/usr/lib/libicucore.dylib' '${darwin.ICU}/lib/libicucore.dylib'
 
-    substituteInPlace \
-      src/runtime/src/installer/managed/Microsoft.NET.HostModel/HostModelUtils.cs \
-      src/sdk/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.targets \
-      --replace-fail '/usr/bin/codesign' '${sigtool}/bin/codesign'
+        substituteInPlace \
+          src/runtime/src/installer/managed/Microsoft.NET.HostModel/HostModelUtils.cs \
+          src/sdk/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.targets \
+          --replace-fail '/usr/bin/codesign' '${sigtool}/bin/codesign'
 
-    # fix: strip: error: unknown argument '-n'
-    substituteInPlace \
-      src/runtime/eng/native/functions.cmake \
-      --replace-fail ' -no_code_signature_warning' ""
+        # fix: strip: error: unknown argument '-n'
+        substituteInPlace \
+          src/runtime/eng/native/functions.cmake \
+          --replace-fail ' -no_code_signature_warning' ""
 
-    # [...]/installer.singlerid.targets(434,5): error MSB3073: The command "pkgbuild [...]" exited with code 127
-    xmlstarlet ed \
-      --inplace \
-      -s //Project -t elem -n PropertyGroup \
-      -s \$prev -t elem -n SkipInstallerBuild -v true \
-      src/runtime/Directory.Build.props
+        # [...]/installer.singlerid.targets(434,5): error MSB3073: The command "pkgbuild [...]" exited with code 127
+        xmlstarlet ed \
+          --inplace \
+          -s //Project -t elem -n PropertyGroup \
+          -s \$prev -t elem -n SkipInstallerBuild -v true \
+          src/runtime/Directory.Build.props
 
-    # stop passing -sdk without a path
-    # stop using xcrun
-    # add -module-cache-path to fix swift errors, see sandboxProfile
-    # <unknown>:0: error: unable to open output file '/var/folders/[...]/C/clang/ModuleCache/[...]/SwiftShims-[...].pcm': 'Operation not permitted'
-    # <unknown>:0: error: could not build Objective-C module 'SwiftShims'
-    substituteInPlace \
-      src/runtime/src/native/libs/System.Security.Cryptography.Native.Apple/CMakeLists.txt \
-      --replace-fail ' -sdk ''${CMAKE_OSX_SYSROOT}' "" \
-      --replace-fail 'xcrun swiftc' 'swiftc -module-cache-path "$ENV{HOME}/.cache/module-cache"'
-  ''
-  + lib.optionalString (lib.versionAtLeast version "9") ''
-    # fix: strip: error: unknown argument '-n'
-    substituteInPlace \
-      src/runtime/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets \
-      src/runtime/src/native/managed/native-library.targets \
-      --replace-fail ' -no_code_signature_warning' ""
+        # stop passing -sdk without a path
+        # stop using xcrun
+        # add -module-cache-path to fix swift errors, see sandboxProfile
+        # <unknown>:0: error: unable to open output file '/var/folders/[...]/C/clang/ModuleCache/[...]/SwiftShims-[...].pcm': 'Operation not permitted'
+        # <unknown>:0: error: could not build Objective-C module 'SwiftShims'
+        substituteInPlace \
+          src/runtime/src/native/libs/System.Security.Cryptography.Native.Apple/CMakeLists.txt \
+          --replace-fail ' -sdk ''${CMAKE_OSX_SYSROOT}' "" \
+          --replace-fail 'xcrun swiftc' 'swiftc -module-cache-path "$ENV{HOME}/.cache/module-cache"'
+      ''
+      + lib.optionalString (lib.versionAtLeast version "9") ''
+        # fix: strip: error: unknown argument '-n'
+        substituteInPlace \
+          src/runtime/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets \
+          src/runtime/src/native/managed/native-library.targets \
+          --replace-fail ' -no_code_signature_warning' ""
 
-    # ld: library not found for -ld_classic
-    substituteInPlace \
-      src/runtime/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets \
-      src/runtime/src/coreclr/tools/aot/ILCompiler/ILCompiler.csproj \
-      --replace-fail 'Include="-ld_classic"' ""
-  ''
-  + lib.optionalString (lib.versionOlder version "9") ''
-    # [...]/build.proj(123,5): error : Did not find PDBs for the following SDK files:
-    # [...]/build.proj(123,5): error : sdk/8.0.102/System.Resources.Extensions.dll
-    # [...]/build.proj(123,5): error : sdk/8.0.102/System.CodeDom.dll
-    # [...]/build.proj(123,5): error : sdk/8.0.102/FSharp/System.Resources.Extensions.dll
-    # [...]/build.proj(123,5): error : sdk/8.0.102/FSharp/System.CodeDom.dll
-    substituteInPlace \
-      build.proj \
-      --replace-fail 'FailOnMissingPDBs="true"' 'FailOnMissingPDBs="false"'
+        # ld: library not found for -ld_classic
+        substituteInPlace \
+          src/runtime/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets \
+          src/runtime/src/coreclr/tools/aot/ILCompiler/ILCompiler.csproj \
+          --replace-fail 'Include="-ld_classic"' ""
+      ''
+      + lib.optionalString (lib.versionOlder version "9") ''
+        # [...]/build.proj(123,5): error : Did not find PDBs for the following SDK files:
+        # [...]/build.proj(123,5): error : sdk/8.0.102/System.Resources.Extensions.dll
+        # [...]/build.proj(123,5): error : sdk/8.0.102/System.CodeDom.dll
+        # [...]/build.proj(123,5): error : sdk/8.0.102/FSharp/System.Resources.Extensions.dll
+        # [...]/build.proj(123,5): error : sdk/8.0.102/FSharp/System.CodeDom.dll
+        substituteInPlace \
+          build.proj \
+          --replace-fail 'FailOnMissingPDBs="true"' 'FailOnMissingPDBs="false"'
 
-    substituteInPlace \
-      src/runtime/src/mono/CMakeLists.txt \
-      --replace-fail '/usr/lib/libicucore.dylib' '${darwin.ICU}/lib/libicucore.dylib'
-  '');
+        substituteInPlace \
+          src/runtime/src/mono/CMakeLists.txt \
+          --replace-fail '/usr/lib/libicucore.dylib' '${darwin.ICU}/lib/libicucore.dylib'
+      ''
+    );
 
   prepFlags = [
     "--no-artifacts"
     "--no-prebuilts"
-    "--with-packages" dotnetSdk.artifacts
+    "--with-packages"
+    dotnetSdk.artifacts
   ];
 
-  configurePhase = let
-    prepScript =
-      if (lib.versionAtLeast version "9")
-      then "./prep-source-build.sh"
-      else "./prep.sh";
-  in ''
-    runHook preConfigure
+  configurePhase =
+    let
+      prepScript = if (lib.versionAtLeast version "9") then "./prep-source-build.sh" else "./prep.sh";
+    in
+    ''
+      runHook preConfigure
 
-    # The build process tries to overwrite some things in the sdk (e.g.
-    # SourceBuild.MSBuildSdkResolver.dll), so it needs to be mutable.
-    cp -Tr ${dotnetSdk} .dotnet
-    chmod -R +w .dotnet
+      # The build process tries to overwrite some things in the sdk (e.g.
+      # SourceBuild.MSBuildSdkResolver.dll), so it needs to be mutable.
+      cp -Tr ${dotnetSdk} .dotnet
+      chmod -R +w .dotnet
 
-    ${prepScript} $prepFlags
+      ${prepScript} $prepFlags
 
-    runHook postConfigure
-  '';
+      runHook postConfigure
+    '';
 
   postConfigure = lib.optionalString (lib.versionAtLeast version "9") ''
     # see patch-npm-packages.proj
@@ -353,21 +364,24 @@ in stdenv.mkDerivation rec {
 
   # https://github.com/NixOS/nixpkgs/issues/38991
   # bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)
-  LOCALE_ARCHIVE = lib.optionalString isLinux
-    "${glibcLocales}/lib/locale/locale-archive";
+  LOCALE_ARCHIVE = lib.optionalString isLinux "${glibcLocales}/lib/locale/locale-archive";
 
-  buildFlags = [
-    "--with-packages" dotnetSdk.artifacts
-    "--clean-while-building"
-    "--release-manifest" releaseManifestFile
-  ]
-  ++ lib.optionals (lib.versionAtLeast version "9") [
-    "--source-build"
-  ]
-  ++ [
-    "--"
-    "-p:PortableBuild=true"
-  ] ++ lib.optional (targetRid != buildRid) "-p:TargetRid=${targetRid}";
+  buildFlags =
+    [
+      "--with-packages"
+      dotnetSdk.artifacts
+      "--clean-while-building"
+      "--release-manifest"
+      releaseManifestFile
+    ]
+    ++ lib.optionals (lib.versionAtLeast version "9") [
+      "--source-build"
+    ]
+    ++ [
+      "--"
+      "-p:PortableBuild=true"
+    ]
+    ++ lib.optional (targetRid != buildRid) "-p:TargetRid=${targetRid}";
 
   buildPhase = ''
     runHook preBuild
@@ -389,35 +403,37 @@ in stdenv.mkDerivation rec {
     runHook postBuild
   '';
 
-  installPhase = let
-    assets = if (lib.versionAtLeast version "9") then "assets" else targetArch;
-  in ''
-    runHook preInstall
+  installPhase =
+    let
+      assets = if (lib.versionAtLeast version "9") then "assets" else targetArch;
+    in
+    ''
+      runHook preInstall
 
-    mkdir "$out"
+      mkdir "$out"
 
-    pushd "artifacts/${assets}/Release"
-    find . -name \*.tar.gz | while read archive; do
-      target=$out/$(basename "$archive" .tar.gz)
-      # dotnet 9 currently has two copies of the sdk tarball
-      [[ ! -e "$target" ]] || continue
-      mkdir "$target"
-      tar -C "$target" -xzf "$PWD/$archive"
-    done
-    popd
+      pushd "artifacts/${assets}/Release"
+      find . -name \*.tar.gz | while read archive; do
+        target=$out/$(basename "$archive" .tar.gz)
+        # dotnet 9 currently has two copies of the sdk tarball
+        [[ ! -e "$target" ]] || continue
+        mkdir "$target"
+        tar -C "$target" -xzf "$PWD/$archive"
+      done
+      popd
 
-    local -r unpacked="$PWD/.unpacked"
-    for nupkg in $out/Private.SourceBuilt.Artifacts.*.${targetRid}/{,SourceBuildReferencePackages/}*.nupkg; do
-        rm -rf "$unpacked"
-        unzip -qd "$unpacked" "$nupkg"
-        chmod -R +rw "$unpacked"
-        rm "$nupkg"
-        mv "$unpacked" "$nupkg"
-        # TODO: should we fix executable flags here? see dotnetInstallHook
-    done
+      local -r unpacked="$PWD/.unpacked"
+      for nupkg in $out/Private.SourceBuilt.Artifacts.*.${targetRid}/{,SourceBuildReferencePackages/}*.nupkg; do
+          rm -rf "$unpacked"
+          unzip -qd "$unpacked" "$nupkg"
+          chmod -R +rw "$unpacked"
+          rm "$nupkg"
+          mv "$unpacked" "$nupkg"
+          # TODO: should we fix executable flags here? see dotnetInstallHook
+      done
 
-    runHook postInstall
-  '';
+      runHook postInstall
+    '';
 
   # dotnet cli is in the root, so we need to strip from there
   # TODO: should we install in $out/share/dotnet?

From e40ed3a6973519d744ee14651b50168aa3c39964 Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Sun, 22 Sep 2024 23:27:32 -0300
Subject: [PATCH 02/14] sonarr: set RuntimeIdentifier

---
 pkgs/by-name/so/sonarr/package.nix | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/pkgs/by-name/so/sonarr/package.nix b/pkgs/by-name/so/sonarr/package.nix
index f5967bbb9010..915599971ba4 100644
--- a/pkgs/by-name/so/sonarr/package.nix
+++ b/pkgs/by-name/so/sonarr/package.nix
@@ -1,4 +1,5 @@
 { lib
+, stdenvNoCC
 , fetchFromGitHub
 , buildDotnetModule
 , dotnetCorePackages
@@ -24,6 +25,7 @@ let
     rev = "v${version}";
     hash = "sha256-RDhJUf8P2STTug69EGozW0q87qDE40jf5G7n7pezWeY=";
   };
+  rid = dotnetCorePackages.systemToDotnetRid stdenvNoCC.hostPlatform.system;
 in
 buildDotnetModule {
   pname = "sonarr";
@@ -100,6 +102,7 @@ buildDotnetModule {
     "--property:Copyright=Copyright 2014-2024 sonarr.tv (GNU General Public v3)"
     "--property:AssemblyVersion=${version}"
     "--property:AssemblyConfiguration=main"
+    "--property:RuntimeIdentifier=${rid}"
   ];
 
   # Skip manual, integration, automation and platform-dependent tests.

From 876e81c09dca0f05d0c8b6a25fe316e8708ca6a0 Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Sat, 21 Sep 2024 21:07:04 -0300
Subject: [PATCH 03/14] ArchiSteamFarm: restore/build for current runtime only

---
 .../misc/ArchiSteamFarm/default.nix           | 20 ++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/pkgs/applications/misc/ArchiSteamFarm/default.nix b/pkgs/applications/misc/ArchiSteamFarm/default.nix
index a218ef04c56b..efeb82110cf0 100644
--- a/pkgs/applications/misc/ArchiSteamFarm/default.nix
+++ b/pkgs/applications/misc/ArchiSteamFarm/default.nix
@@ -27,22 +27,28 @@ buildDotnetModule rec {
 
   projectFile = "ArchiSteamFarm.sln";
   executable = "ArchiSteamFarm";
+
+  enableParallelBuilding = false;
+
+  useAppHost = false;
   dotnetFlags = [
+    # useAppHost doesn't explicitly disable this
     "-p:UseAppHost=false"
-  ];
-  dotnetInstallFlags = [
+    "-p:RuntimeIdentifiers="
+  ]
+  ;
+  dotnetBuildFlags = [
     "--framework=net8.0"
   ];
+  dotnetInstallFlags = dotnetBuildFlags;
 
   runtimeDeps = [ libkrb5 zlib openssl ];
 
   doCheck = true;
 
-  preBuild = ''
-    dotnetProjectFiles=(ArchiSteamFarm)
-  '';
-
   preInstall = ''
+    dotnetProjectFiles=(ArchiSteamFarm)
+
     # A mutable path, with this directory tree must be set. By default, this would point at the nix store causing errors.
     makeWrapperArgs+=(
       --run 'mkdir -p ~/.config/archisteamfarm/{config,logs,plugins}'
@@ -55,7 +61,7 @@ buildDotnetModule rec {
       echo "Publishing plugin $1"
       dotnet publish $1 -p:ContinuousIntegrationBuild=true -p:Deterministic=true \
         --output $out/lib/ArchiSteamFarm/plugins/$1 --configuration Release \
-        -p:UseAppHost=false
+        $dotnetFlags $dotnetInstallFlags
     }
 
     buildPlugin ArchiSteamFarm.OfficialPlugins.ItemsMatcher

From 894e9265c5f7d273646671f1cdfd1da21b1551c7 Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Sun, 22 Sep 2024 12:58:11 -0300
Subject: [PATCH 04/14] libation: restore/build for current runtime only

---
 pkgs/by-name/li/libation/deps.nix    | 2 --
 pkgs/by-name/li/libation/package.nix | 6 +++++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/pkgs/by-name/li/libation/deps.nix b/pkgs/by-name/li/libation/deps.nix
index e537d6e43bd8..2792c1f90ca4 100644
--- a/pkgs/by-name/li/libation/deps.nix
+++ b/pkgs/by-name/li/libation/deps.nix
@@ -125,8 +125,6 @@
   (fetchNuGet { pname = "runtime.unix.System.Diagnostics.Debug"; version = "4.3.0"; hash = "sha256-ReoazscfbGH+R6s6jkg5sIEHWNEvjEoHtIsMbpc7+tI="; })
   (fetchNuGet { pname = "runtime.unix.System.Private.Uri"; version = "4.3.0"; hash = "sha256-c5tXWhE/fYbJVl9rXs0uHh3pTsg44YD1dJvyOA0WoMs="; })
   (fetchNuGet { pname = "runtime.unix.System.Runtime.Extensions"; version = "4.3.0"; hash = "sha256-l8S9gt6dk3qYG6HYonHtdlYtBKyPb29uQ6NDjmrt3V4="; })
-  (fetchNuGet { pname = "runtime.win.System.Diagnostics.Debug"; version = "4.3.0"; hash = "sha256-DpU+PGIUCtaK6gQEl/OWSO/JKg/TA9yeD01Zzxaxy5k="; })
-  (fetchNuGet { pname = "runtime.win.System.Runtime.Extensions"; version = "4.3.0"; hash = "sha256-+TMflNyjP+Lf5bge0xVN5AKxMAk4/caWY6zZrqtyAJw="; })
   (fetchNuGet { pname = "Serilog"; version = "2.10.0"; hash = "sha256-+8wilkt+VVvW+KFWuLryj7cSFpz9D+sz92KYWICAcSE="; })
   (fetchNuGet { pname = "Serilog"; version = "2.8.0"; hash = "sha256-MBL9AWGV8UthhiHXnqH3EsfIyXnxdLWqAdFa6QvQ2To="; })
   (fetchNuGet { pname = "Serilog"; version = "3.1.0"; hash = "sha256-1CDAp+AjfFjQqoLvKYp/j6pKTUfNOGfKVlWyqCGHo7k="; })
diff --git a/pkgs/by-name/li/libation/package.nix b/pkgs/by-name/li/libation/package.nix
index b84469c716fb..c11629382743 100644
--- a/pkgs/by-name/li/libation/package.nix
+++ b/pkgs/by-name/li/libation/package.nix
@@ -28,7 +28,11 @@ buildDotnetModule rec {
 
   nugetDeps = ./deps.nix;
 
-  dotnetFlags = [ "-p:PublishReadyToRun=false" ];
+  dotnetFlags = [
+    "-p:PublishReadyToRun=false"
+    # for some reason this is set to win-x64 in the project files
+    "-p:RuntimeIdentifier="
+  ];
 
   projectFile = [
     "LibationAvalonia/LibationAvalonia.csproj"

From b372a9cae1397d1e96aeae926266f45cbce8f61b Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Sun, 22 Sep 2024 13:07:50 -0300
Subject: [PATCH 05/14] roslyn-ls: format with nixfmt

---
 pkgs/by-name/ro/roslyn-ls/package.nix | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/pkgs/by-name/ro/roslyn-ls/package.nix b/pkgs/by-name/ro/roslyn-ls/package.nix
index 5fb77607ed47..3d69bc864e87 100644
--- a/pkgs/by-name/ro/roslyn-ls/package.nix
+++ b/pkgs/by-name/ro/roslyn-ls/package.nix
@@ -1,7 +1,23 @@
-{ lib, fetchFromGitHub, buildDotnetModule, dotnetCorePackages, stdenvNoCC, testers, roslyn-ls, jq }:
+{
+  lib,
+  fetchFromGitHub,
+  buildDotnetModule,
+  dotnetCorePackages,
+  stdenvNoCC,
+  testers,
+  roslyn-ls,
+  jq,
+}:
 let
   pname = "roslyn-ls";
-  dotnet-sdk = with dotnetCorePackages; combinePackages [ sdk_6_0 sdk_7_0 sdk_8_0 sdk_9_0 ];
+  dotnet-sdk =
+    with dotnetCorePackages;
+    combinePackages [
+      sdk_6_0
+      sdk_7_0
+      sdk_8_0
+      sdk_9_0
+    ];
   # need sdk on runtime as well
   dotnet-runtime = dotnetCorePackages.sdk_9_0;
 

From 592860143608d20cd4cf4a7612d23ddb3458bfd4 Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Sun, 22 Sep 2024 13:11:02 -0300
Subject: [PATCH 06/14] roslyn-ls: restore/build for current runtime only

---
 pkgs/by-name/ro/roslyn-ls/deps.nix    | 28 ----------------
 pkgs/by-name/ro/roslyn-ls/package.nix | 46 ++++++++++++---------------
 2 files changed, 20 insertions(+), 54 deletions(-)

diff --git a/pkgs/by-name/ro/roslyn-ls/deps.nix b/pkgs/by-name/ro/roslyn-ls/deps.nix
index 01497b5e73e0..1fb2f6ef9bbd 100644
--- a/pkgs/by-name/ro/roslyn-ls/deps.nix
+++ b/pkgs/by-name/ro/roslyn-ls/deps.nix
@@ -7,16 +7,6 @@
   (fetchNuGet { pname = "ICSharpCode.Decompiler"; version = "8.1.1.7464"; hash = "sha256-71/e9zuQIfqRXOiWxZkUFW/tMAj63nE8tg/sR7bGzuM="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/icsharpcode.decompiler/8.1.1.7464/icsharpcode.decompiler.8.1.1.7464.nupkg"; })
   (fetchNuGet { pname = "MessagePack"; version = "2.5.108"; hash = "sha256-+vMXyEbfutY5WOFuFnNF24uLcKJTTdntVrVlSJH4yjI="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/messagepack/2.5.108/messagepack.2.5.108.nupkg"; })
   (fetchNuGet { pname = "MessagePack.Annotations"; version = "2.5.108"; hash = "sha256-u3Qu8UftNIz3oIzQUMa7Z0G6VzmDLcAnAeNQ3lB3YVk="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/messagepack.annotations/2.5.108/messagepack.annotations.2.5.108.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Ref"; version = "6.0.32"; hash = "sha256-1mQTxwruzhm20YdlZefrYuy7xrBs17pH4Vo0K3Tl7Fc="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.aspnetcore.app.ref/6.0.32/microsoft.aspnetcore.app.ref.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Ref"; version = "8.0.7"; hash = "sha256-4jkbKvnRim+1K1KMDzHzzjZk9ALU2lYJVY1Fzr8Cmqs="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.aspnetcore.app.ref/8.0.7/microsoft.aspnetcore.app.ref.8.0.7.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "6.0.32"; hash = "sha256-cIe0F+7rgwYSmh0VuFuQsUI9iEW5hn2KCD2H8Cs/k2g="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.aspnetcore.app.runtime.linux-arm64/6.0.32/microsoft.aspnetcore.app.runtime.linux-arm64.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "8.0.7"; hash = "sha256-YiBHc3PC2qms/39IvJkaLfe/Eug9W97bz78XKKkqax8="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.aspnetcore.app.runtime.linux-arm64/8.0.7/microsoft.aspnetcore.app.runtime.linux-arm64.8.0.7.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "6.0.32"; hash = "sha256-TkYv7h9NBr3I+FIaXeLU4MawJtgT2RWhs35ewGRDKx8="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.aspnetcore.app.runtime.linux-x64/6.0.32/microsoft.aspnetcore.app.runtime.linux-x64.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "8.0.7"; hash = "sha256-s6pb37BjE7TMBO2lQexUoJ+m+uhPB3unTR/BGYG+mVI="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.aspnetcore.app.runtime.linux-x64/8.0.7/microsoft.aspnetcore.app.runtime.linux-x64.8.0.7.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64"; version = "6.0.32"; hash = "sha256-RaC37ZQcJn7ykXJrtV7ibxh0GcalRyPKncxlqOLou+I="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.aspnetcore.app.runtime.osx-arm64/6.0.32/microsoft.aspnetcore.app.runtime.osx-arm64.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64"; version = "8.0.7"; hash = "sha256-zMBpSXV8dlGI/3ZB9Lx4qQnAHFNCwsjuEAuQzxHWDJU="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.aspnetcore.app.runtime.osx-arm64/8.0.7/microsoft.aspnetcore.app.runtime.osx-arm64.8.0.7.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-x64"; version = "6.0.32"; hash = "sha256-vh/e46xM/HbhbBvL5eP5/DCHwCP2Bg7WoMS28nBXWV0="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.aspnetcore.app.runtime.osx-x64/6.0.32/microsoft.aspnetcore.app.runtime.osx-x64.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-x64"; version = "8.0.7"; hash = "sha256-TWXhiLxVkTem4aoBfWpVEhbWvfECfqJQqFP4X8BMhCY="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.aspnetcore.app.runtime.osx-x64/8.0.7/microsoft.aspnetcore.app.runtime.osx-x64.8.0.7.nupkg"; })
   (fetchNuGet { pname = "Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace"; version = "9.0.0-preview.24366.2"; hash = "sha256-SUZfSiONzmTwDQsaTd7VTkE6IrzSu80giAPwrjvuY7M="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.aspnetcore.razor.externalaccess.roslynworkspace/9.0.0-preview.24366.2/microsoft.aspnetcore.razor.externalaccess.roslynworkspace.9.0.0-preview.24366.2.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Bcl.AsyncInterfaces"; version = "8.0.0"; hash = "sha256-9aWmiwMJKrKr9ohD1KSuol37y+jdDxPGJct3m2/Bknw="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.bcl.asyncinterfaces/8.0.0/microsoft.bcl.asyncinterfaces.8.0.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Build"; version = "17.10.4"; hash = "sha256-yaElGdmgcELCXR5fIe5/ingMx2qS/PM3tZGTPNHHjXo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.build/17.10.4/microsoft.build.17.10.4.nupkg"; })
@@ -62,24 +52,6 @@
   (fetchNuGet { pname = "Microsoft.NET.StringTools"; version = "17.3.4"; hash = "sha256-xLPrrL8iS3gNMIa/C/Wv0fBfHIehUHeQ4Y+F+gbqkhk="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.net.stringtools/17.3.4/microsoft.net.stringtools.17.3.4.nupkg"; })
   (fetchNuGet { pname = "Microsoft.NET.StringTools"; version = "17.4.0"; hash = "sha256-+9uBaUDZ3roUJwyYJUL30Mz+3C6LE16FzfQKgS0Yveo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.net.stringtools/17.4.0/microsoft.net.stringtools.17.4.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.NET.StringTools"; version = "17.7.2"; hash = "sha256-hQE07TCgcQuyu9ZHVq2gPDb0+xe8ECJUdrgh17bJP4o="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.net.stringtools/17.7.2/microsoft.net.stringtools.17.7.2.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "6.0.32"; hash = "sha256-yDOkSHEGuGG6u+rB5u+IC3rc2tQwvbjdqmgHcl7Gkn4="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.host.linux-arm64/6.0.32/microsoft.netcore.app.host.linux-arm64.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "8.0.7"; hash = "sha256-ffTw2G+T5Jk7v57tx3C2DWOXbD0lCu4IJf7v61hNnu8="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.host.linux-arm64/8.0.7/microsoft.netcore.app.host.linux-arm64.8.0.7.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "6.0.32"; hash = "sha256-2aDGkn0QqXXHUUSAwtQQbjKl5I6S0fcQWPciqPnOiM4="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.host.linux-x64/6.0.32/microsoft.netcore.app.host.linux-x64.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "8.0.7"; hash = "sha256-Hi/PhR7YDn7kKLcOGymy90BX+a9jOTmheLetKlOuhW0="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.host.linux-x64/8.0.7/microsoft.netcore.app.host.linux-x64.8.0.7.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-arm64"; version = "6.0.32"; hash = "sha256-n6hks4j88TRelq1O6SCeUH5GmxoSm5BWXGwnpnYJibI="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.host.osx-arm64/6.0.32/microsoft.netcore.app.host.osx-arm64.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-arm64"; version = "8.0.7"; hash = "sha256-cNQHG7xlOgB6o3u0h2+n6uA4M8abci2YbYXwYaXnnbs="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.host.osx-arm64/8.0.7/microsoft.netcore.app.host.osx-arm64.8.0.7.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-x64"; version = "6.0.32"; hash = "sha256-nBBq4RYAgimBYOn/bN6JTFvJFYaqYXMHae2pmCzRaS8="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.host.osx-x64/6.0.32/microsoft.netcore.app.host.osx-x64.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-x64"; version = "8.0.7"; hash = "sha256-jlJIQtWuE/CqRuwCam4ucYq1OROQzicouDeM3brpNTI="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.host.osx-x64/8.0.7/microsoft.netcore.app.host.osx-x64.8.0.7.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Ref"; version = "6.0.32"; hash = "sha256-Fm3RUZNcro434rIu3c7unGviGeGBjXj2dGnr2mmrM2g="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.ref/6.0.32/microsoft.netcore.app.ref.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Ref"; version = "8.0.7"; hash = "sha256-q35Ye0w5YqX12JOMXeAXp7ce4nvZQlv0K4GN6hSCz5g="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.ref/8.0.7/microsoft.netcore.app.ref.8.0.7.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "6.0.32"; hash = "sha256-kdj8ia/2du2oKGg4MJdO2XytpT3gQ9UOiHVCyfiX2V8="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.runtime.linux-arm64/6.0.32/microsoft.netcore.app.runtime.linux-arm64.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "8.0.7"; hash = "sha256-cQfBGSoZfnuBu+G5dWWxdxy8MzChoIpxWDvkkN98Z8M="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.runtime.linux-arm64/8.0.7/microsoft.netcore.app.runtime.linux-arm64.8.0.7.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "6.0.32"; hash = "sha256-/Hti30Ba12NDJQcG8pFTg6REVUDIrxZ/hRtEZNDlgxE="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.runtime.linux-x64/6.0.32/microsoft.netcore.app.runtime.linux-x64.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "8.0.7"; hash = "sha256-c3ekBpJZOS/2JD5KkktVQRVesPxTJmzpm05ROVR0mxo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.runtime.linux-x64/8.0.7/microsoft.netcore.app.runtime.linux-x64.8.0.7.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-arm64"; version = "6.0.32"; hash = "sha256-A8MFGOMXFROH1QGUE7xzq5b5EskDyIQCQt7SLfGdSbU="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.runtime.osx-arm64/6.0.32/microsoft.netcore.app.runtime.osx-arm64.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-arm64"; version = "8.0.7"; hash = "sha256-RNzRuZH5j1socRsKmzxRLDdQZ/V9FRrT7jdbxtbOSI8="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.runtime.osx-arm64/8.0.7/microsoft.netcore.app.runtime.osx-arm64.8.0.7.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-x64"; version = "6.0.32"; hash = "sha256-y5YB62WlMrK10bR/+nNpI8luVRlD9W9ZG3GsX7AXzUM="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.runtime.osx-x64/6.0.32/microsoft.netcore.app.runtime.osx-x64.6.0.32.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-x64"; version = "8.0.7"; hash = "sha256-SN4fTW9O3m2uHQf0B15UXT5Cdxf23SJ03rQ4ye6FR4Y="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.runtime.osx-x64/8.0.7/microsoft.netcore.app.runtime.osx-x64.8.0.7.nupkg"; })
   (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "5.0.0"; hash = "sha256-LIcg1StDcQLPOABp4JRXIs837d7z0ia6+++3SF3jl1c="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.platforms/5.0.0/microsoft.netcore.platforms.5.0.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.0"; hash = "sha256-0AqQ2gMS8iNlYkrD+BxtIg7cXMnr9xZHtKAuN4bjfaQ="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.targets/1.1.0/microsoft.netcore.targets.1.1.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.3"; hash = "sha256-WLsf1NuUfRWyr7C7Rl9jiua9jximnVvzy6nk2D2bVRc="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.targets/1.1.3/microsoft.netcore.targets.1.1.3.nupkg"; })
diff --git a/pkgs/by-name/ro/roslyn-ls/package.nix b/pkgs/by-name/ro/roslyn-ls/package.nix
index 3d69bc864e87..df3eb2e3071f 100644
--- a/pkgs/by-name/ro/roslyn-ls/package.nix
+++ b/pkgs/by-name/ro/roslyn-ls/package.nix
@@ -20,6 +20,7 @@ let
     ];
   # need sdk on runtime as well
   dotnet-runtime = dotnetCorePackages.sdk_9_0;
+  rid = dotnetCorePackages.systemToDotnetRid stdenvNoCC.targetPlatform.system;
 
   project = "Microsoft.CodeAnalysis.LanguageServer";
 in
@@ -48,11 +49,6 @@ buildDotnetModule rec {
     # Upstream uses rollForward = latestPatch, which pins to an *exact* .NET SDK version.
     jq '.sdk.rollForward = "latestMinor"' < global.json > global.json.tmp
     mv global.json.tmp global.json
-
-    substituteInPlace $dotnetProjectFiles \
-      --replace-fail \
-        '>win-x64;win-arm64;linux-x64;linux-arm64;linux-musl-x64;linux-musl-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>' \
-        '>linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>'
   '';
 
   dotnetFlags = [
@@ -61,35 +57,33 @@ buildDotnetModule rec {
     # see this comment: https://github.com/NixOS/nixpkgs/pull/318497#issuecomment-2256096471
     # we can remove below line after https://github.com/dotnet/roslyn/issues/73439 is fixed
     "-p:UsingToolMicrosoftNetCompilers=false"
+    "-p:TargetRid=${rid}"
   ];
 
   # two problems solved here:
   # 1. --no-build removed -> BuildHost project within roslyn is running Build target during publish
   # 2. missing crossgen2 7.* in local nuget directory when PublishReadyToRun=true
   # the latter should be fixable here but unsure how
-  installPhase =
-    let
-      rid = dotnetCorePackages.systemToDotnetRid stdenvNoCC.targetPlatform.system;
-    in
-    ''
-      runHook preInstall
+  installPhase = ''
+    runHook preInstall
 
-      env dotnet publish $dotnetProjectFiles \
-          -p:ContinuousIntegrationBuild=true \
-          -p:Deterministic=true \
-          -p:InformationalVersion=$version \
-          -p:UseAppHost=true \
-          -p:PublishTrimmed=false \
-          -p:PublishReadyToRun=false \
-          --configuration Release \
-          --no-self-contained \
-          --output "$out/lib/$pname" \
-          --runtime ${rid} \
-          ''${dotnetInstallFlags[@]}  \
-          ''${dotnetFlags[@]}
+    env dotnet publish $dotnetProjectFiles \
+        -p:ContinuousIntegrationBuild=true \
+        -p:Deterministic=true \
+        -p:InformationalVersion=$version \
+        -p:UseAppHost=true \
+        -p:PublishTrimmed=false \
+        -p:PublishReadyToRun=false \
+        --configuration Release \
+        --no-self-contained \
+        --output "$out/lib/$pname" \
+        --no-restore \
+        --runtime ${rid} \
+        ''${dotnetInstallFlags[@]}  \
+        ''${dotnetFlags[@]}
 
-      runHook postInstall
-    '';
+    runHook postInstall
+  '';
 
   passthru = {
     tests.version = testers.testVersion { package = roslyn-ls; };

From 4f47ddf1d781e902441bc642ae018f39b3b3117a Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Fri, 20 Sep 2024 22:12:41 -0300
Subject: [PATCH 07/14] dotnet: set sourceProvenance on binary runtime/sdk

---
 pkgs/development/compilers/dotnet/build-dotnet.nix | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/pkgs/development/compilers/dotnet/build-dotnet.nix b/pkgs/development/compilers/dotnet/build-dotnet.nix
index 3e2a21d20c5f..1624199de026 100644
--- a/pkgs/development/compilers/dotnet/build-dotnet.nix
+++ b/pkgs/development/compilers/dotnet/build-dotnet.nix
@@ -206,5 +206,9 @@ mkCommon type rec {
     ];
     mainProgram = "dotnet";
     platforms = attrNames srcs;
+    sourceProvenance = with lib.sourceTypes; [
+      binaryBytecode
+      binaryNativeCode
+    ];
   };
 }

From 2c97d67f62326476785189e226bfa7bdb27bfd7b Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Fri, 20 Sep 2024 22:08:12 -0300
Subject: [PATCH 08/14] dotnet: split sdk packages by platform

---
 .../dotnet/build-dotnet-module/default.nix    |  23 +-
 .../dotnet/fetch-nupkg/default.nix            | 144 +++---
 pkgs/by-name/av/avalonia/package.nix          |   7 +-
 .../compilers/dotnet/build-dotnet.nix         |  40 +-
 .../compilers/dotnet/combine-packages.nix     |   8 +-
 pkgs/development/compilers/dotnet/default.nix |   6 +-
 pkgs/development/compilers/dotnet/dotnet.nix  |  40 +-
 .../development/compilers/dotnet/packages.nix | 130 +++--
 pkgs/development/compilers/dotnet/stage0.nix  |  20 +-
 pkgs/development/compilers/dotnet/stage1.nix  |  10 +-
 pkgs/development/compilers/dotnet/update.sh   | 427 ++++++---------
 .../compilers/dotnet/versions/6.0.nix         | 428 +++++++++------
 .../compilers/dotnet/versions/7.0.nix         | 486 +++++++++++-------
 .../compilers/dotnet/versions/8.0.nix         | 482 ++++++++++-------
 .../compilers/dotnet/versions/9.0.nix         | 310 +++++++----
 pkgs/development/compilers/dotnet/vmr.nix     |  12 +-
 .../python-modules/clr-loader/default.nix     |   4 +-
 17 files changed, 1517 insertions(+), 1060 deletions(-)

diff --git a/pkgs/build-support/dotnet/build-dotnet-module/default.nix b/pkgs/build-support/dotnet/build-dotnet-module/default.nix
index b9f7a2ff724b..bffdcd6e1315 100644
--- a/pkgs/build-support/dotnet/build-dotnet-module/default.nix
+++ b/pkgs/build-support/dotnet/build-dotnet-module/default.nix
@@ -135,6 +135,7 @@ let
         useDotnetFromEnv
         nugetDeps
         runtimeId
+        dotnet-sdk
         ;
 
       nativeBuildInputs = args.nativeBuildInputs or [ ] ++ [
@@ -149,12 +150,7 @@ let
         dotnet-sdk
       ];
 
-      buildInputs =
-        args.buildInputs or [ ]
-        ++ [
-          dotnet-sdk.packages
-        ]
-        ++ projectReferences;
+      buildInputs = args.buildInputs or [ ] ++ dotnet-sdk.packages ++ projectReferences;
 
       # Parse the version attr into a format acceptable for the Version msbuild property
       # The actual version attr is saved in InformationalVersion, which accepts an arbitrary string
@@ -206,7 +202,12 @@ stdenvNoCC.mkDerivation (
   let
     args = if lib.isFunction fnOrAttrs then fnOrAttrs (args' // finalAttrs) else fnOrAttrs;
     args' = transformArgs finalAttrs args;
-    inherit (args') nugetDeps runtimeId meta;
+    inherit (args')
+      nugetDeps
+      runtimeId
+      meta
+      dotnet-sdk
+      ;
     args'' = removeAttrs args' [
       "nugetDeps"
       "runtimeId"
@@ -222,15 +223,19 @@ stdenvNoCC.mkDerivation (
       "selfContainedBuild"
       "useDotnet"
       "useAppHost"
+      "dotnet-sdk"
     ];
   in
   if nugetDeps != null then
     addNuGetDeps {
       inherit nugetDeps;
       overrideFetchAttrs =
-        a:
-        lib.optionalAttrs ((args'.runtimeId or null) == null) {
+        old:
+        lib.optionalAttrs ((args'.runtimeId or null) == null) rec {
           dotnetRuntimeIds = map (system: dotnetCorePackages.systemToDotnetRid system) meta.platforms;
+          buildInputs =
+            old.buildInputs
+            ++ lib.concatLists (lib.attrValues (lib.getAttrs dotnetRuntimeIds dotnet-sdk.targetPackages));
         };
     } args'' finalAttrs
   else
diff --git a/pkgs/build-support/dotnet/fetch-nupkg/default.nix b/pkgs/build-support/dotnet/fetch-nupkg/default.nix
index 517afde5c828..e653bbb0376c 100644
--- a/pkgs/build-support/dotnet/fetch-nupkg/default.nix
+++ b/pkgs/build-support/dotnet/fetch-nupkg/default.nix
@@ -9,78 +9,80 @@
   callPackage,
   overrides ? callPackage ./overrides.nix { },
 }:
-{
-  pname,
-  version,
-  sha256 ? "",
-  hash ? "",
-  url ? "https://www.nuget.org/api/v2/package/${pname}/${version}",
-  installable ? false,
-}:
-let
-  package = stdenvNoCC.mkDerivation rec {
-    inherit pname version;
+lib.makeOverridable (
+  {
+    pname,
+    version,
+    sha256 ? "",
+    hash ? "",
+    url ? "https://www.nuget.org/api/v2/package/${pname}/${version}",
+    installable ? false,
+  }:
+  let
+    package = stdenvNoCC.mkDerivation rec {
+      inherit pname version;
 
-    src = fetchurl {
-      name = "${pname}.${version}.nupkg";
-      # There is no need to verify whether both sha256 and hash are
-      # valid here, because nuget-to-nix does not generate a deps.nix
-      # containing both.
-      inherit
-        url
-        sha256
-        hash
-        version
-        ;
-    };
+      src = fetchurl {
+        name = "${pname}.${version}.nupkg";
+        # There is no need to verify whether both sha256 and hash are
+        # valid here, because nuget-to-nix does not generate a deps.nix
+        # containing both.
+        inherit
+          url
+          sha256
+          hash
+          version
+          ;
+      };
 
-    nativeBuildInputs = [
-      unzip
-      patchNupkgs
-      nugetPackageHook
-    ];
-
-    unpackPhase = ''
-      runHook preUnpack
-
-      unpackNupkg "$src" source
-      cd source
-
-      runHook postUnpack
-    '';
-
-    prePatch = ''
-      shopt -s nullglob
-      local dir
-      for dir in tools runtimes/*/native; do
-        [[ ! -d "$dir" ]] || chmod -R +x "$dir"
-      done
-      rm -rf .signature.p7s
-    '';
-
-    installPhase = ''
-      runHook preInstall
-
-      dir=$out/share/nuget/packages/${lib.toLower pname}/${lib.toLower version}
-      mkdir -p $dir
-      cp -r . $dir
-      echo {} > "$dir"/.nupkg.metadata
-
-      runHook postInstall
-    '';
-
-    preFixup = ''
-      patch-nupkgs $out/share/nuget/packages
-    '';
-
-    createInstallableNugetSource = installable;
-
-    meta = {
-      sourceProvenance = with lib.sourceTypes; [
-        binaryBytecode
-        binaryNativeCode
+      nativeBuildInputs = [
+        unzip
+        patchNupkgs
+        nugetPackageHook
       ];
+
+      unpackPhase = ''
+        runHook preUnpack
+
+        unpackNupkg "$src" source
+        cd source
+
+        runHook postUnpack
+      '';
+
+      prePatch = ''
+        shopt -s nullglob
+        local dir
+        for dir in tools runtimes/*/native; do
+          [[ ! -d "$dir" ]] || chmod -R +x "$dir"
+        done
+        rm -rf .signature.p7s
+      '';
+
+      installPhase = ''
+        runHook preInstall
+
+        dir=$out/share/nuget/packages/${lib.toLower pname}/${lib.toLower version}
+        mkdir -p $dir
+        cp -r . $dir
+        echo {} > "$dir"/.nupkg.metadata
+
+        runHook postInstall
+      '';
+
+      preFixup = ''
+        patch-nupkgs $out/share/nuget/packages
+      '';
+
+      createInstallableNugetSource = installable;
+
+      meta = {
+        sourceProvenance = with lib.sourceTypes; [
+          binaryBytecode
+          binaryNativeCode
+        ];
+      };
     };
-  };
-in
-overrides.${pname} or lib.id package
+  in
+  overrides.${pname} or lib.id package
+)
diff --git a/pkgs/by-name/av/avalonia/package.nix b/pkgs/by-name/av/avalonia/package.nix
index 7b828cdf5c67..ebcbc3a9e62f 100644
--- a/pkgs/by-name/av/avalonia/package.nix
+++ b/pkgs/by-name/av/avalonia/package.nix
@@ -38,8 +38,11 @@ stdenvNoCC.mkDerivation (
   dotnetCorePackages.addNuGetDeps
     {
       nugetDeps = ./deps.nix;
-      overrideFetchAttrs = old: {
+      overrideFetchAttrs = old: rec {
         runtimeIds = map (system: dotnetCorePackages.systemToDotnetRid system) old.meta.platforms;
+        buildInputs =
+          old.buildInputs
+          ++ lib.concatLists (lib.attrValues (lib.getAttrs runtimeIds dotnet-sdk.targetPackages));
       };
     }
     rec {
@@ -159,7 +162,7 @@ stdenvNoCC.mkDerivation (
         nodejs
         dotnet-sdk
       ];
-      buildInputs = [ dotnet-sdk.packages ];
+      buildInputs = dotnet-sdk.packages;
 
       buildTarget = "Package";
 
diff --git a/pkgs/development/compilers/dotnet/build-dotnet.nix b/pkgs/development/compilers/dotnet/build-dotnet.nix
index 1624199de026..e9ae30070de7 100644
--- a/pkgs/development/compilers/dotnet/build-dotnet.nix
+++ b/pkgs/development/compilers/dotnet/build-dotnet.nix
@@ -2,7 +2,9 @@
   type,
   version,
   srcs,
-  packages ? null,
+  commonPackages ? null,
+  hostPackages ? null,
+  targetPackages ? null,
 }:
 
 assert builtins.elem type [
@@ -10,7 +12,11 @@ assert builtins.elem type [
   "runtime"
   "sdk"
 ];
-assert if type == "sdk" then packages != null else true;
+assert
+  if type == "sdk" then
+    commonPackages != null && hostPackages != null && targetPackages != null
+  else
+    true;
 
 {
   lib,
@@ -32,7 +38,7 @@ assert if type == "sdk" then packages != null else true;
   writeShellScript,
   mkNugetDeps,
   callPackage,
-  dotnetCorePackages,
+  systemToDotnetRid,
   xmlstarlet,
 }:
 
@@ -53,12 +59,13 @@ let
 
   mkCommon = callPackage ./common.nix { };
 
-  targetRid = dotnetCorePackages.systemToDotnetRid stdenv.targetPlatform.system;
+  hostRid = systemToDotnetRid stdenv.hostPlatform.system;
+  targetRid = systemToDotnetRid stdenv.targetPlatform.system;
 
   sigtool = callPackage ./sigtool.nix { };
   signAppHost = callPackage ./sign-apphost.nix { };
 
-  hasILCompiler = lib.versionAtLeast version (if targetRid == "osx-arm64" then "8" else "7");
+  hasILCompiler = lib.versionAtLeast version (if hostRid == "osx-arm64" then "8" else "7");
 
   extraTargets = writeText "extra.targets" (
     ''
@@ -108,8 +115,7 @@ mkCommon type rec {
   ] ++ lib.optional stdenv.hostPlatform.isLinux lttng-ust_2_12;
 
   src = fetchurl (
-    srcs."${stdenv.hostPlatform.system}"
-      or (throw "Missing source (url and hash) for host system: ${stdenv.hostPlatform.system}")
+    srcs.${hostRid} or (throw "Missing source (url and hash) for host RID: ${hostRid}")
   );
 
   sourceRoot = ".";
@@ -157,15 +163,15 @@ mkCommon type rec {
       --add-needed libicuuc.so \
       $out/shared/Microsoft.NETCore.App/*/libcoreclr.so \
       $out/shared/Microsoft.NETCore.App/*/*System.Globalization.Native.so \
-      $out/packs/Microsoft.NETCore.App.Host.${targetRid}/*/runtimes/${targetRid}/native/*host
+      $out/packs/Microsoft.NETCore.App.Host.${hostRid}/*/runtimes/${hostRid}/native/*host
     patchelf \
       --add-needed libgssapi_krb5.so \
       $out/shared/Microsoft.NETCore.App/*/*System.Net.Security.Native.so \
-      $out/packs/Microsoft.NETCore.App.Host.${targetRid}/*/runtimes/${targetRid}/native/*host
+      $out/packs/Microsoft.NETCore.App.Host.${hostRid}/*/runtimes/${hostRid}/native/*host
     patchelf \
       --add-needed libssl.so \
       $out/shared/Microsoft.NETCore.App/*/*System.Security.Cryptography.Native.OpenSsl.so \
-      $out/packs/Microsoft.NETCore.App.Host.${targetRid}/*/runtimes/${targetRid}/native/*host
+      $out/packs/Microsoft.NETCore.App.Host.${hostRid}/*/runtimes/${hostRid}/native/*host
   '';
 
   # fixes: Could not load ICU data. UErrorCode: 2
@@ -181,10 +187,8 @@ mkCommon type rec {
       inherit icu hasILCompiler;
     }
     // lib.optionalAttrs (type == "sdk") {
-      packages = mkNugetDeps {
-        name = "${pname}-${version}-deps";
-        nugetDeps = packages;
-      };
+      packages = commonPackages ++ hostPackages.${hostRid} ++ targetPackages.${targetRid};
+      inherit targetPackages;
 
       updateScript =
         let
@@ -205,7 +209,13 @@ mkCommon type rec {
       mdarocha
     ];
     mainProgram = "dotnet";
-    platforms = attrNames srcs;
+    platforms = lib.filter (
+      platform:
+      let
+        e = builtins.tryEval (systemToDotnetRid platform);
+      in
+      e.success && srcs ? "${e.value}"
+    ) lib.platforms.all;
     sourceProvenance = with lib.sourceTypes; [
       binaryBytecode
       binaryNativeCode
diff --git a/pkgs/development/compilers/dotnet/combine-packages.nix b/pkgs/development/compilers/dotnet/combine-packages.nix
index 165b9fbef97c..661f9c482a12 100644
--- a/pkgs/development/compilers/dotnet/combine-packages.nix
+++ b/pkgs/development/compilers/dotnet/combine-packages.nix
@@ -40,10 +40,10 @@ buildEnv {
     inherit (cli) icu;
 
     versions = lib.catAttrs "version" dotnetPackages;
-    packages = symlinkJoin {
-      name = "combined-packages";
-      paths = lib.remove null (lib.catAttrs "packages" dotnetPackages);
-    };
+    packages = lib.concatLists (lib.catAttrs "packages" dotnetPackages);
+    targetPackages = lib.zipAttrsWith (_: lib.concatLists) (
+      lib.catAttrs "targetPackages" dotnetPackages
+    );
   };
 
   inherit (cli) meta;
diff --git a/pkgs/development/compilers/dotnet/default.nix b/pkgs/development/compilers/dotnet/default.nix
index 91854ea02b81..69cd17ec6244 100644
--- a/pkgs/development/compilers/dotnet/default.nix
+++ b/pkgs/development/compilers/dotnet/default.nix
@@ -20,8 +20,11 @@ makeScopeWithSplicing' {
     let
       callPackage = self.callPackage;
 
+      fetchNupkg = callPackage ../../../build-support/dotnet/fetch-nupkg { };
+
       buildDotnet = attrs: callPackage (import ./build-dotnet.nix attrs) { };
       buildAttrs = {
+        inherit fetchNupkg;
         buildAspNetCore = attrs: buildDotnet (attrs // { type = "aspnetcore"; });
         buildNetRuntime = attrs: buildDotnet (attrs // { type = "runtime"; });
         buildNetSdk = attrs: buildDotnet (attrs // { type = "sdk"; });
@@ -44,7 +47,7 @@ makeScopeWithSplicing' {
 
     in
     {
-      inherit callPackage;
+      inherit callPackage fetchNupkg;
 
       # Convert a "stdenv.hostPlatform.system" to a dotnet RID
       systemToDotnetRid =
@@ -61,7 +64,6 @@ makeScopeWithSplicing' {
       mkNugetSource = callPackage ../../../build-support/dotnet/make-nuget-source { };
       mkNugetDeps = callPackage ../../../build-support/dotnet/make-nuget-deps { };
       addNuGetDeps = callPackage ../../../build-support/dotnet/add-nuget-deps { };
-      fetchNupkg = callPackage ../../../build-support/dotnet/fetch-nupkg { };
 
       dotnet_8 = recurseIntoAttrs (callPackage ./8 { bootstrapSdk = dotnet_8_0.sdk_8_0_1xx; });
       dotnet_9 = recurseIntoAttrs (callPackage ./9 { });
diff --git a/pkgs/development/compilers/dotnet/dotnet.nix b/pkgs/development/compilers/dotnet/dotnet.nix
index f353d51a4a37..7e94f3432f77 100644
--- a/pkgs/development/compilers/dotnet/dotnet.nix
+++ b/pkgs/development/compilers/dotnet/dotnet.nix
@@ -1,6 +1,8 @@
 {
+  stdenvNoCC,
   callPackage,
   lib,
+  fetchurl,
   releaseManifestFile,
   releaseInfoFile,
   allowPrerelease ? false,
@@ -14,31 +16,25 @@ let
 
   pkgs = callPackage ./stage1.nix {
     inherit releaseManifestFile tarballHash depsFile;
-    bootstrapSdk =
-      {
-        stdenvNoCC,
-        dotnetCorePackages,
-        fetchurl,
-      }:
-      bootstrapSdk.overrideAttrs (old: {
-        passthru = old.passthru or { } // {
-          artifacts = stdenvNoCC.mkDerivation rec {
-            name = lib.nameFromURL artifactsUrl ".tar.gz";
+    bootstrapSdk = bootstrapSdk.overrideAttrs (old: {
+      passthru = old.passthru or { } // {
+        artifacts = stdenvNoCC.mkDerivation rec {
+          name = lib.nameFromURL artifactsUrl ".tar.gz";
 
-            src = fetchurl {
-              url = artifactsUrl;
-              hash = artifactsHash;
-            };
-
-            sourceRoot = ".";
-
-            installPhase = ''
-              mkdir -p $out
-              cp -r * $out/
-            '';
+          src = fetchurl {
+            url = artifactsUrl;
+            hash = artifactsHash;
           };
+
+          sourceRoot = ".";
+
+          installPhase = ''
+            mkdir -p $out
+            cp -r * $out/
+          '';
         };
-      });
+      };
+    });
   };
 
 in
diff --git a/pkgs/development/compilers/dotnet/packages.nix b/pkgs/development/compilers/dotnet/packages.nix
index 7976223ab994..f9a5190d1588 100644
--- a/pkgs/development/compilers/dotnet/packages.nix
+++ b/pkgs/development/compilers/dotnet/packages.nix
@@ -1,19 +1,97 @@
 {
-  stdenv,
+  stdenvNoCC,
+  lib,
   callPackage,
   vmr,
   xmlstarlet,
   strip-nondeterminism,
   zip,
+  nugetPackageHook,
+  fallbackTargetPackages ? { },
 }:
 
 let
   mkCommon = callPackage ./common.nix { };
   inherit (vmr) targetRid releaseManifest;
 
-in
-{
-  inherit vmr;
+  # TODO: do this properly
+  hostRid = targetRid;
+
+  mkPackage =
+    pname: version:
+    stdenvNoCC.mkDerivation {
+      inherit pname version;
+
+      src = vmr;
+      dontUnpack = true;
+
+      nativeBuildInputs = [
+        xmlstarlet
+        nugetPackageHook
+      ];
+
+      installPhase = ''
+        runHook preInstall
+
+        mkdir -p "$out"
+
+        pushd "$src"/Private.SourceBuilt.Artifacts.*.${targetRid}
+        pushd ${pname}.${version}.nupkg
+
+        xmlstarlet \
+          sel -t \
+          -m /_:package/_:metadata \
+          -v _:id -nl \
+          -v _:version -nl \
+          *.nuspec | (
+          read id
+          read version
+          id=''${id,,}
+          version=''${version,,}
+          mkdir -p "$out"/share/nuget/packages/"$id"
+          cp -r . "$out"/share/nuget/packages/"$id"/"$version"
+          chmod +w "$out"/share/nuget/packages/"$id"/"$version"
+          echo {} > "$out"/share/nuget/packages/"$id"/"$version"/.nupkg.metadata
+        )
+
+        popd
+        popd
+
+        runHook postInstall
+      '';
+    };
+
+  packages =
+    [
+      (mkPackage "Microsoft.AspNetCore.App.Ref" aspnetcore.version)
+      (mkPackage "Microsoft.NETCore.DotNetAppHost" runtime.version)
+      (mkPackage "Microsoft.NETCore.App.Ref" runtime.version)
+      (mkPackage "Microsoft.DotNet.ILCompiler" runtime.version)
+      (mkPackage "Microsoft.NET.ILLink.Tasks" runtime.version)
+      (mkPackage "Microsoft.NETCore.App.Crossgen2.${hostRid}" runtime.version)
+      (mkPackage "runtime.${hostRid}.Microsoft.DotNet.ILCompiler" runtime.version)
+    ]
+    ++ lib.optionals (lib.versionOlder runtime.version "9") [
+      (mkPackage "Microsoft.NETCore.DotNetHost" runtime.version)
+      (mkPackage "Microsoft.NETCore.DotNetHostPolicy" runtime.version)
+      (mkPackage "Microsoft.NETCore.DotNetHostResolver" runtime.version)
+    ];
+
+  targetPackages = fallbackTargetPackages // {
+    ${targetRid} =
+      [
+        (mkPackage "Microsoft.AspNetCore.App.Runtime.${targetRid}" aspnetcore.version)
+        (mkPackage "Microsoft.NETCore.App.Host.${targetRid}" runtime.version)
+        (mkPackage "Microsoft.NETCore.App.Runtime.${targetRid}" runtime.version)
+        (mkPackage "runtime.${targetRid}.Microsoft.NETCore.DotNetAppHost" runtime.version)
+      ]
+      ++ lib.optionals (lib.versionOlder runtime.version "9") [
+        (mkPackage "runtime.${targetRid}.Microsoft.NETCore.DotNetHost" runtime.version)
+        (mkPackage "runtime.${targetRid}.Microsoft.NETCore.DotNetHostPolicy" runtime.version)
+        (mkPackage "runtime.${targetRid}.Microsoft.NETCore.DotNetHostResolver" runtime.version)
+      ];
+  };
+
   sdk = mkCommon "sdk" rec {
     pname = "dotnet-sdk";
     version = releaseManifest.sdkVersion;
@@ -29,7 +107,6 @@ in
 
     outputs = [
       "out"
-      "packages"
       "artifacts"
     ];
 
@@ -41,42 +118,12 @@ in
       mkdir "$out"/bin
       ln -s "$out"/dotnet "$out"/bin/dotnet
 
-      mkdir -p "$packages" "$artifacts"
+      mkdir -p "$artifacts"
       cp -r "$src"/Private.SourceBuilt.Artifacts.*.${targetRid}/* "$artifacts"/
       chmod +w -R "$artifacts"
 
       local package
 
-      for package in "$artifacts"/*.nupkg; do
-        local copy
-        case "$(basename "$package")" in
-          *Microsoft.NET.* | \
-          *Microsoft.ILLink.* | \
-          *Microsoft.Tasks.* | \
-          *Microsoft.NETCore.* | \
-          *Microsoft.DotNet.* | \
-          *Microsoft.AspNetCore.*) copy=1 ;;
-          *) copy= ;;
-        esac
-        if [[ -n $copy ]]; then
-          echo copying "$package" to packages
-          xmlstarlet \
-            sel -t \
-            -m /_:package/_:metadata \
-            -v _:id -nl \
-            -v _:version -nl \
-            "$package"/*.nuspec | (
-            read id
-            read version
-            id=''${id,,}
-            version=''${version,,}
-            mkdir -p "$packages"/share/nuget/packages/"$id"
-            cp -r "$package" "$packages"/share/nuget/packages/"$id"/"$version"
-            echo {} > "$packages"/share/nuget/packages/"$id"/"$version"/.nupkg.metadata
-          )
-        fi
-      done
-
       for package in "$artifacts"/{,SourceBuildReferencePackages/}*.nupkg; do
         echo packing "$package" to artifacts
         (cd "$package" && zip -rq0 "$package.tmp" .)
@@ -90,6 +137,8 @@ in
 
     passthru = {
       inherit (vmr) icu targetRid hasILCompiler;
+
+      inherit packages targetPackages;
     };
 
     meta = vmr.meta // {
@@ -149,4 +198,13 @@ in
       mainProgram = "dotnet";
     };
   };
+in
+{
+  inherit
+    vmr
+    sdk
+    runtime
+    aspnetcore
+    ;
+
 }
diff --git a/pkgs/development/compilers/dotnet/stage0.nix b/pkgs/development/compilers/dotnet/stage0.nix
index 17de17a71bc3..b10f0ac2cc32 100644
--- a/pkgs/development/compilers/dotnet/stage0.nix
+++ b/pkgs/development/compilers/dotnet/stage0.nix
@@ -10,6 +10,7 @@
   dotnetCorePackages,
   xmlstarlet,
   patchNupkgs,
+  symlinkJoin,
 
   releaseManifestFile,
   tarballHash,
@@ -21,20 +22,19 @@ let
   mkPackages = callPackage ./packages.nix;
   mkVMR = callPackage ./vmr.nix;
 
-  dotnetSdk = callPackage bootstrapSdk { };
-
-  deps = mkNugetDeps {
-    name = "dotnet-vmr-deps";
-    sourceFile = depsFile;
-  };
-
-  sdkPackages = dotnetSdk.packages.override {
-    installable = true;
+  sdkPackages = symlinkJoin {
+    name = "${bootstrapSdk.name}-packages";
+    paths = map (
+      p:
+      p.override {
+        installable = true;
+      }
+    ) bootstrapSdk.packages;
   };
 
   vmr =
     (mkVMR {
-      inherit releaseManifestFile tarballHash dotnetSdk;
+      inherit releaseManifestFile tarballHash bootstrapSdk;
     }).overrideAttrs
       (old: rec {
         prebuiltPackages = mkNugetDeps {
diff --git a/pkgs/development/compilers/dotnet/stage1.nix b/pkgs/development/compilers/dotnet/stage1.nix
index bf1273c56cb2..94fb0fa24c70 100644
--- a/pkgs/development/compilers/dotnet/stage1.nix
+++ b/pkgs/development/compilers/dotnet/stage1.nix
@@ -18,7 +18,7 @@ let
   vmr =
     (mkVMR {
       inherit releaseManifestFile tarballHash;
-      dotnetSdk = stage0.sdk;
+      bootstrapSdk = stage0.sdk;
     }).overrideAttrs
       (old: {
         passthru = old.passthru or { } // {
@@ -27,4 +27,10 @@ let
       });
 
 in
-mkPackages { inherit vmr; } // { stage0 = lib.dontRecurseIntoAttrs stage0; }
+mkPackages {
+  inherit vmr;
+  fallbackTargetPackages = bootstrapSdk.targetPackages;
+}
+// {
+  stage0 = lib.dontRecurseIntoAttrs stage0;
+}
diff --git a/pkgs/development/compilers/dotnet/update.sh b/pkgs/development/compilers/dotnet/update.sh
index 3c5f29d8f046..58c307c0a469 100755
--- a/pkgs/development/compilers/dotnet/update.sh
+++ b/pkgs/development/compilers/dotnet/update.sh
@@ -6,6 +6,8 @@ set -Eeuo pipefail
 
 cd "$(dirname "${BASH_SOURCE[0]}")"
 
+rids=({linux-{,musl-}{arm,arm64,x64},osx-{arm64,x64},win-{arm64,x64,x86}})
+
 release () {
     local content="$1"
     local version="$2"
@@ -30,285 +32,171 @@ release_platform_attr () {
 
 platform_sources () {
     local release_files="$1"
-    local platforms=(
-        "x86_64-linux   linux-x64"
-        "aarch64-linux  linux-arm64"
-        "x86_64-darwin  osx-x64"
-        "aarch64-darwin osx-arm64"
-    )
 
     echo "srcs = {"
-    local kv
-    for kv in "${platforms[@]}"; do
-        local nix_platform=${kv%% *}
-        local ms_platform=${kv##* }
+    for rid in "${rids[@]}"; do
         local url hash
 
-        url=$(release_platform_attr "$release_files" "$ms_platform" url)
-        hash=$(release_platform_attr "$release_files" "$ms_platform" hash)
+        url=$(release_platform_attr "$release_files" "$rid" url)
+        hash=$(release_platform_attr "$release_files" "$rid" hash)
 
         [[ -z "$url" || -z "$hash" ]] && continue
-        echo "      $nix_platform = {
-        url     = \"$url\";
-        sha512  = \"$hash\";
+
+        hash=$(nix-hash --to-sri --type sha512 "$hash")
+
+        echo "      $rid = {
+        url = \"$url\";
+        hash = \"$hash\";
       };"
     done
     echo "    };"
 }
 
-generate_package_list() {
-    local version="$1"
-    shift
-    local pkgs=( "$@" ) nuget_url pkg url hash
+nuget_url="$(curl -f "https://api.nuget.org/v3/index.json" | jq --raw-output '.resources[] | select(."@type" == "PackageBaseAddress/3.0.0")."@id"')"
 
-    nuget_url="$(curl -f "https://api.nuget.org/v3/index.json" | jq --raw-output '.resources[] | select(."@type" == "PackageBaseAddress/3.0.0")."@id"')"
+generate_package_list() {
+    local version="$1" indent="$2"
+    shift 2
+    local pkgs=( "$@" ) pkg url hash
 
     for pkg in "${pkgs[@]}"; do
-        url="${nuget_url}${pkg,,}/${version,,}/${pkg,,}.${version,,}.nupkg"
-        hash="$(nix-prefetch-url "$url")"
-        if [[ -z "$hash" ]]; then
+        url=${nuget_url}${pkg,,}/${version,,}/${pkg,,}.${version,,}.nupkg
+        if ! hash=$(nix-prefetch-url "$url"); then
             echo "Failed to fetch hash for $url" >&2
             exit 1
         fi
+        hash=$(nix-hash --to-sri --type sha256 "$hash")
 
-        echo "      (fetchNuGet { pname = \"${pkg}\"; version = \"${version}\"; sha256 = \"${hash}\"; })"
+        echo "$indent(fetchNupkg { pname = \"${pkg}\"; version = \"${version}\"; hash = \"${hash}\"; })"
     done
 }
 
-version_older () {
-    local cur_version=$1
-    local max_version=$2
-    local result
-
-    result=$(nix-instantiate -I ../../../../. \
-        --eval -E "(import ../../../../. {}).lib.versionOlder \"$cur_version\" \"$max_version\"")
-    if [[ "$result" == "true" ]]; then
-        return 0
-    else
-        return 1
-    fi
+versionAtLeast () {
+    local cur_version=$1 min_version=$2
+    printf "%s\0%s" "$min_version" "$cur_version" | sort -zVC
 }
 
+# These packages are implicitly references by the build process,
+# based on the specific project configurations (RIDs, used features, etc.)
+# They are always referenced with the same version as the SDK used for building.
+# Since we lock nuget dependencies, when these packages are included in the generated
+# lock files (deps.nix), every update of SDK required those lock files to be
+# updated to reflect the new versions of these packages - otherwise, the build
+# would fail due to missing dependencies.
+#
+# Moving them to a separate list stored alongside the SDK package definitions,
+# and implicitly including them along in buildDotnetModule allows us
+# to make updating .NET SDK packages a lot easier - we now just update
+# the versions of these packages in one place, and all packages that
+# use buildDotnetModule continue building with the new .NET version without changes.
+#
+# Keep in mind that there is no canonical list of these implicitly
+# referenced packages - this list was created based on looking into
+# the deps.nix files of existing packages, and which dependencies required
+# updating after a SDK version bump.
+#
+# Due to this, make sure to check if new SDK versions introduce any new packages.
+# This should not happend in minor or bugfix updates, but probably happens
+# with every new major .NET release.
 aspnetcore_packages () {
     local version=$1
-    # These packages are implicitly references by the build process,
-    # based on the specific project configurations (RIDs, used features, etc.)
-    # They are always referenced with the same version as the SDK used for building.
-    # Since we lock nuget dependencies, when these packages are included in the generated
-    # lock files (deps.nix), every update of SDK required those lock files to be
-    # updated to reflect the new versions of these packages - otherwise, the build
-    # would fail due to missing dependencies.
-    #
-    # Moving them to a separate list stored alongside the SDK package definitions,
-    # and implicitly including them along in buildDotnetModule allows us
-    # to make updating .NET SDK packages a lot easier - we now just update
-    # the versions of these packages in one place, and all packages that
-    # use buildDotnetModule continue building with the new .NET version without changes.
-    #
-    # Keep in mind that there is no canonical list of these implicitly
-    # referenced packages - this list was created based on looking into
-    # the deps.nix files of existing packages, and which dependencies required
-    # updating after a SDK version bump.
-    #
-    # Due to this, make sure to check if new SDK versions introduce any new packages.
-    # This should not happend in minor or bugfix updates, but probably happens
-    # with every new major .NET release.
     local pkgs=(
-        "Microsoft.AspNetCore.App.Runtime.linux-arm"
-        "Microsoft.AspNetCore.App.Runtime.linux-arm64"
-        "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64"
-        "Microsoft.AspNetCore.App.Runtime.linux-musl-x64"
-        "Microsoft.AspNetCore.App.Runtime.linux-x64"
-        "Microsoft.AspNetCore.App.Runtime.osx-x64"
-        "Microsoft.AspNetCore.App.Runtime.win-arm64"
-        "Microsoft.AspNetCore.App.Runtime.win-x64"
-        "Microsoft.AspNetCore.App.Runtime.win-x86"
+        Microsoft.AspNetCore.App.Ref
     )
 
-    # These packages are currently broken on .NET 8
-    if version_older "$version" "8"; then
-        pkgs+=(
-            "Microsoft.AspNetCore.App.Runtime.win-arm"
-        )
-    fi
-
-    # Packages that only apply to .NET 6 and up
-    if ! version_older "$version" "6"; then
-        pkgs+=(
-            "Microsoft.AspNetCore.App.Ref"
-            "Microsoft.AspNetCore.App.Runtime.linux-musl-arm"
-            "Microsoft.AspNetCore.App.Runtime.osx-arm64"
-        )
-    fi
-
-
-    generate_package_list "$version" "${pkgs[@]}"
+    generate_package_list "$version" '    ' "${pkgs[@]}"
 }
 
-sdk_packages () {
+aspnetcore_target_packages () {
     local version=$1
-    # These packages are implicitly references by the build process,
-    # based on the specific project configurations (RIDs, used features, etc.)
-    # They are always referenced with the same version as the SDK used for building.
-    # Since we lock nuget dependencies, when these packages are included in the generated
-    # lock files (deps.nix), every update of SDK required those lock files to be
-    # updated to reflect the new versions of these packages - otherwise, the build
-    # would fail due to missing dependencies.
-    #
-    # Moving them to a separate list stored alongside the SDK package definitions,
-    # and implicitly including them along in buildDotnetModule allows us
-    # to make updating .NET SDK packages a lot easier - we now just update
-    # the versions of these packages in one place, and all packages that
-    # use buildDotnetModule continue building with the new .NET version without changes.
-    #
-    # Keep in mind that there is no canonical list of these implicitly
-    # referenced packages - this list was created based on looking into
-    # the deps.nix files of existing packages, and which dependencies required
-    # updating after a SDK version bump.
-    #
-    # Due to this, make sure to check if new SDK versions introduce any new packages.
-    # This should not happend in minor or bugfix updates, but probably happens
-    # with every new major .NET release.
+    local rid=$2
     local pkgs=(
-        "Microsoft.NETCore.App.Host.linux-arm"
-        "Microsoft.NETCore.App.Host.linux-arm64"
-        "Microsoft.NETCore.App.Host.linux-musl-arm64"
-        "Microsoft.NETCore.App.Host.linux-musl-x64"
-        "Microsoft.NETCore.App.Host.linux-x64"
-        "Microsoft.NETCore.App.Host.osx-x64"
-        "Microsoft.NETCore.App.Host.win-arm64"
-        "Microsoft.NETCore.App.Host.win-x64"
-        "Microsoft.NETCore.App.Host.win-x86"
-        "Microsoft.NETCore.App.Runtime.linux-arm"
-        "Microsoft.NETCore.App.Runtime.linux-arm64"
-        "Microsoft.NETCore.App.Runtime.linux-musl-arm64"
-        "Microsoft.NETCore.App.Runtime.linux-musl-x64"
-        "Microsoft.NETCore.App.Runtime.linux-x64"
-        "Microsoft.NETCore.App.Runtime.osx-x64"
-        "Microsoft.NETCore.App.Runtime.win-arm64"
-        "Microsoft.NETCore.App.Runtime.win-x64"
-        "Microsoft.NETCore.App.Runtime.win-x86"
-        "Microsoft.NETCore.DotNetAppHost"
-        "Microsoft.NETCore.DotNetHost"
-        "Microsoft.NETCore.DotNetHostPolicy"
-        "Microsoft.NETCore.DotNetHostResolver"
-        "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost"
-        "runtime.linux-arm64.Microsoft.NETCore.DotNetHost"
-        "runtime.linux-arm64.Microsoft.NETCore.DotNetHostPolicy"
-        "runtime.linux-arm64.Microsoft.NETCore.DotNetHostResolver"
-        "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost"
-        "runtime.linux-arm.Microsoft.NETCore.DotNetHost"
-        "runtime.linux-arm.Microsoft.NETCore.DotNetHostPolicy"
-        "runtime.linux-arm.Microsoft.NETCore.DotNetHostResolver"
-        "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost"
-        "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHost"
-        "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostPolicy"
-        "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostResolver"
-        "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost"
-        "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHost"
-        "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostPolicy"
-        "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostResolver"
-        "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost"
-        "runtime.linux-x64.Microsoft.NETCore.DotNetHost"
-        "runtime.linux-x64.Microsoft.NETCore.DotNetHostPolicy"
-        "runtime.linux-x64.Microsoft.NETCore.DotNetHostResolver"
-        "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost"
-        "runtime.osx-x64.Microsoft.NETCore.DotNetHost"
-        "runtime.osx-x64.Microsoft.NETCore.DotNetHostPolicy"
-        "runtime.osx-x64.Microsoft.NETCore.DotNetHostResolver"
-        "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost"
-        "runtime.win-arm64.Microsoft.NETCore.DotNetHost"
-        "runtime.win-arm64.Microsoft.NETCore.DotNetHostPolicy"
-        "runtime.win-arm64.Microsoft.NETCore.DotNetHostResolver"
-        "runtime.win-x64.Microsoft.NETCore.DotNetAppHost"
-        "runtime.win-x64.Microsoft.NETCore.DotNetHost"
-        "runtime.win-x64.Microsoft.NETCore.DotNetHostPolicy"
-        "runtime.win-x64.Microsoft.NETCore.DotNetHostResolver"
-        "runtime.win-x86.Microsoft.NETCore.DotNetAppHost"
-        "runtime.win-x86.Microsoft.NETCore.DotNetHost"
-        "runtime.win-x86.Microsoft.NETCore.DotNetHostPolicy"
-        "runtime.win-x86.Microsoft.NETCore.DotNetHostResolver"
-        "Microsoft.NETCore.App.Host.linux-musl-arm"
-        "Microsoft.NETCore.App.Host.osx-arm64"
-        "Microsoft.NETCore.App.Runtime.linux-musl-arm"
-        "Microsoft.NETCore.App.Runtime.osx-arm64"
-        "Microsoft.NETCore.App.Ref"
-        "Microsoft.NETCore.App.Runtime.Mono.linux-arm"
-        "Microsoft.NETCore.App.Runtime.Mono.linux-arm64"
-        "Microsoft.NETCore.App.Runtime.Mono.linux-musl-x64"
-        "Microsoft.NETCore.App.Runtime.Mono.linux-x64"
-        "Microsoft.NETCore.App.Runtime.Mono.osx-arm64"
-        "Microsoft.NETCore.App.Runtime.Mono.osx-x64"
-        "Microsoft.NETCore.App.Runtime.Mono.win-x64"
-        "Microsoft.NETCore.App.Runtime.Mono.win-x86"
-        "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost"
-        "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHost"
-        "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostPolicy"
-        "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostResolver"
-        "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost"
-        "runtime.osx-arm64.Microsoft.NETCore.DotNetHost"
-        "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy"
-        "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver"
-        "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"
-        "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"
-        "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"
-        "Microsoft.NETCore.App.Crossgen2.linux-arm"
-        "Microsoft.NETCore.App.Crossgen2.linux-arm64"
-        "Microsoft.NETCore.App.Crossgen2.linux-x64"
-        "Microsoft.NETCore.App.Crossgen2.osx-x64"
-        "Microsoft.NETCore.App.Crossgen2.osx-arm64"
+        "Microsoft.AspNetCore.App.Runtime.$rid"
     )
 
-    # These packages were removed on .NET 9
-    if ! version_older "$version" "9"; then
-        local newpkgs=()
-        local pkg
-        for pkg in "${pkgs[@]}"; do
-            case "$pkg" in
-                *Microsoft.NETCore.DotNetHost*);;
-                Microsoft.NETCore.App.Runtime.Mono.*);;
-                *) newpkgs+=("$pkg");;
-            esac
-        done
-        pkgs=("${newpkgs[@]}")
-    fi
+    generate_package_list "$version" '      ' "${pkgs[@]}"
+}
 
-    # These packages were removed on .NET 8
-    if version_older "$version" "8"; then
+netcore_packages () {
+    local version=$1
+    local pkgs=(
+        Microsoft.NETCore.DotNetAppHost
+        Microsoft.NETCore.App.Ref
+    )
+
+    if ! versionAtLeast "$version" 9; then
         pkgs+=(
-            "Microsoft.NETCore.App.Host.win-arm"
-            "Microsoft.NETCore.App.Runtime.win-arm"
-            "runtime.win-arm.Microsoft.NETCore.DotNetAppHost"
-            "runtime.win-arm.Microsoft.NETCore.DotNetHost"
-            "runtime.win-arm.Microsoft.NETCore.DotNetHostPolicy"
-            "runtime.win-arm.Microsoft.NETCore.DotNetHostResolver"
-            "Microsoft.NETCore.App.Composite"
+            Microsoft.NETCore.DotNetHost
+            Microsoft.NETCore.DotNetHostPolicy
+            Microsoft.NETCore.DotNetHostResolver
         )
     fi
 
-    # Packages that only apply to .NET 7 and up
-    if ! version_older "$version" "7"; then
+    if versionAtLeast "$version" 7; then
         pkgs+=(
-            "Microsoft.DotNet.ILCompiler"
-            "runtime.linux-arm64.Microsoft.DotNet.ILCompiler"
-            "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler"
-            "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler"
-            "runtime.linux-x64.Microsoft.DotNet.ILCompiler"
-            "runtime.osx-x64.Microsoft.DotNet.ILCompiler"
-            "runtime.win-arm64.Microsoft.DotNet.ILCompiler"
-            "runtime.win-x64.Microsoft.DotNet.ILCompiler"
+            Microsoft.DotNet.ILCompiler
         )
     fi
 
-    # These packges were added on .NET 8
-    if ! version_older "$version" "8"; then
+    if versionAtLeast "$version" 8; then
         pkgs+=(
-            "Microsoft.NET.ILLink.Tasks"
-            "runtime.osx-arm64.Microsoft.DotNet.ILCompiler"
+            Microsoft.NET.ILLink.Tasks
         )
     fi
 
-    generate_package_list "$version" "${pkgs[@]}"
+    generate_package_list "$version" '    ' "${pkgs[@]}"
+}
+
+netcore_host_packages () {
+    local version=$1
+    local rid=$2
+    local pkgs=(
+        "Microsoft.NETCore.App.Crossgen2.$rid"
+    )
+
+    local min_ilcompiler=
+    case "$rid" in
+        linux-musl-arm) ;;
+        linux-arm) ;;
+        win-x86) ;;
+        osx-arm64) min_ilcompiler=8 ;;
+        *) min_ilcompiler=7 ;;
+    esac
+
+    if [[ -n "$min_ilcompiler" ]] && versionAtLeast "$version" "$min_ilcompiler"; then
+        pkgs+=(
+            "runtime.$rid.Microsoft.DotNet.ILCompiler"
+        )
+    fi
+
+    generate_package_list "$version" '      ' "${pkgs[@]}"
+}
+
+netcore_target_packages () {
+    local version=$1
+    local rid=$2
+    local pkgs=(
+        "Microsoft.NETCore.App.Host.$rid"
+        "Microsoft.NETCore.App.Runtime.$rid"
+        "runtime.$rid.Microsoft.NETCore.DotNetAppHost"
+    )
+
+    if ! versionAtLeast "$version" 9; then
+        pkgs+=(
+            "runtime.$rid.Microsoft.NETCore.DotNetHost"
+            "runtime.$rid.Microsoft.NETCore.DotNetHostPolicy"
+            "runtime.$rid.Microsoft.NETCore.DotNetHostResolver"
+        )
+        case "$rid" in
+            linux-musl-arm*) ;;
+            win-arm64) ;;
+            *) pkgs+=(
+                     "Microsoft.NETCore.App.Runtime.Mono.$rid"
+                 ) ;;
+        esac
+    fi
+
+    generate_package_list "$version" '      ' "${pkgs[@]}"
 }
 
 main () {
@@ -361,6 +249,7 @@ Examples:
             buildAspNetCore = { ... }: {}; \
             buildNetSdk = { ... }: {}; \
             buildNetRuntime = { ... }: {}; \
+            fetchNupkg = { ... }: {}; \
             }).release_${major_minor_underscore}" | jq -r)
 
             if [[ "$current_version" == "$major_minor_patch" ]]; then
@@ -381,22 +270,37 @@ Examples:
         aspnetcore_sources="$(platform_sources "$aspnetcore_files")"
         runtime_sources="$(platform_sources "$runtime_files")"
 
-        local sdk_packages aspnetcore_packages
-        sdk_packages="$(sdk_packages "${runtime_version}")"
-        aspnetcore_packages="$(aspnetcore_packages "${aspnetcore_version}")"
-
         result=$(mktemp)
         trap "rm -f $result" TERM INT EXIT
 
-        echo "{ buildAspNetCore, buildNetRuntime, buildNetSdk }:
+        (
+            echo "{ buildAspNetCore, buildNetRuntime, buildNetSdk, fetchNupkg }:
 
 # v$channel_version ($support_phase)
 
 let
-  packages = { fetchNuGet }: [
-$aspnetcore_packages
-$sdk_packages
-  ];
+  commonPackages = ["
+            aspnetcore_packages "${aspnetcore_version}"
+            netcore_packages "${runtime_version}"
+            echo "  ];
+
+  hostPackages = {"
+            for rid in "${rids[@]}"; do
+                echo "    $rid = ["
+                netcore_host_packages "${runtime_version}" "$rid"
+                echo "    ];"
+            done
+            echo "  };
+
+  targetPackages = {"
+            for rid in "${rids[@]}"; do
+                echo "    $rid = ["
+                aspnetcore_target_packages "${aspnetcore_version}" "$rid"
+                netcore_target_packages "${runtime_version}" "$rid"
+                echo "    ];"
+            done
+            echo "  };
+
 in rec {
   release_$major_minor_underscore = \"$major_minor_patch\";
 
@@ -408,34 +312,35 @@ in rec {
   runtime_$major_minor_underscore = buildNetRuntime {
     version = \"${runtime_version}\";
     $runtime_sources
-  };" > "${result}"
+  };"
 
-        local -A feature_bands
-        unset latest_sdk
+            local -A feature_bands
+            unset latest_sdk
 
-        for sdk_version in "${sdk_versions[@]}"; do
-            local sdk_base_version=${sdk_version%-*}
-            local feature_band=${sdk_base_version:0:-2}xx
-            # sometimes one release has e.g. both 8.0.202 and 8.0.203
-            [[ ! ${feature_bands[$feature_band]+true} ]] || continue
-            feature_bands[$feature_band]=$sdk_version
-            local sdk_files sdk_sources
-            sdk_files="$(release_files "$release_content" ".sdks[] | select(.version == \"$sdk_version\")")"
-            sdk_sources="$(platform_sources "$sdk_files")"
-            local sdk_attrname=sdk_${feature_band//./_}
-            [[ -v latest_sdk ]] || local latest_sdk=$sdk_attrname
+            for sdk_version in "${sdk_versions[@]}"; do
+                local sdk_base_version=${sdk_version%-*}
+                local feature_band=${sdk_base_version:0:-2}xx
+                # sometimes one release has e.g. both 8.0.202 and 8.0.203
+                [[ ! ${feature_bands[$feature_band]+true} ]] || continue
+                feature_bands[$feature_band]=$sdk_version
+                local sdk_files sdk_sources
+                sdk_files="$(release_files "$release_content" ".sdks[] | select(.version == \"$sdk_version\")")"
+                sdk_sources="$(platform_sources "$sdk_files")"
+                local sdk_attrname=sdk_${feature_band//./_}
+                [[ -v latest_sdk ]] || local latest_sdk=$sdk_attrname
 
-            echo "
+                echo "
   $sdk_attrname = buildNetSdk {
     version = \"${sdk_version}\";
     $sdk_sources
-    inherit packages;
-  };" >> "${result}"
-        done
+    inherit commonPackages hostPackages targetPackages;
+  };"
+            done
 
-        echo "
+            echo "
   sdk_$major_minor_underscore = $latest_sdk;
-}" >> "${result}"
+}"
+        )> "${result}"
 
         cp "${result}" "./versions/${sem_version}.nix"
         echo "Generated ./versions/${sem_version}.nix"
diff --git a/pkgs/development/compilers/dotnet/versions/6.0.nix b/pkgs/development/compilers/dotnet/versions/6.0.nix
index e2a792457994..401879088263 100644
--- a/pkgs/development/compilers/dotnet/versions/6.0.nix
+++ b/pkgs/development/compilers/dotnet/versions/6.0.nix
@@ -1,138 +1,200 @@
-{ buildAspNetCore, buildNetRuntime, buildNetSdk }:
+{ buildAspNetCore, buildNetRuntime, buildNetSdk, fetchNupkg }:
 
 # v6.0 (maintenance)
 
 let
-  packages = { fetchNuGet }: [
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm"; version = "6.0.33"; sha256 = "0xpki5wnl629zcih2d70vr1cgrhwr10mf4r89dyfm4hmwfpjz0pl"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "6.0.33"; sha256 = "0d26nch9v7aaxb6m8xjbwbbag88j8r7igbg512p242g7a03xp743"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64"; version = "6.0.33"; sha256 = "06mdbp3z8pvj6q15agzdgxiqdvk057k0ld0q6q2bcy5i39x9744m"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-x64"; version = "6.0.33"; sha256 = "1gyxvfaigp8i7x7yf24xzk4z5p638zxfa0pmahcyly0afl8s0i2v"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "6.0.33"; sha256 = "1q5aigywyx1jcm0ws2gql8y2ns6lrs9q6h85k3l8kamrbjls51jf"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-x64"; version = "6.0.33"; sha256 = "1m1qac3mpnhdz3xpjn3a659nis10v687aacjrgrlbmjffibh0wz7"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-arm64"; version = "6.0.33"; sha256 = "0rks3lj4vwxlv1w6bk2v0z7lm5i22hzf46qcmc3qxndwmlp1frr3"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-x64"; version = "6.0.33"; sha256 = "101ibi2xfy9wnll7qbm257ifsmn4plqfa5649i331481m6hjscjj"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-x86"; version = "6.0.33"; sha256 = "14fgl7m0r9q3j0ab2v2g0jkby28d6c7386n0dx4zd1j516kcrzpg"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-arm"; version = "6.0.33"; sha256 = "00ky4jnrpq5zcpmrkjny74j2k466kw7sj4sbh361wql3q0ma9nm2"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Ref"; version = "6.0.33"; sha256 = "0fx2zh5266inw8c2a353gl6sfcssnc4l952sc83rpl48x0xy5hqr"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm"; version = "6.0.33"; sha256 = "0iwxzkdlmhd4ks6ivrfp5hgwgxmr2cbx8jvz7vzj01v3zbv8m8hd"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64"; version = "6.0.33"; sha256 = "0r1knq9hzvx4qibrlvq8809r6pf3j3inq6aiw94dyrrkl1vfz3rr"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm"; version = "6.0.33"; sha256 = "03rxxv7vlaf7pbdcbyv2q93f5d0w7v9mhi2qy2nyiwscx1b1rrj5"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "6.0.33"; sha256 = "1qazlv2aczbrzv5l4l0p94ix7q321i3j3jn6fcw0yxlgznjqw1dg"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-arm64"; version = "6.0.33"; sha256 = "01kqcqjp2f5bx7nwx7ma90r7pjnc9vdb16k3fs1v3lvdb83mlwjn"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-x64"; version = "6.0.33"; sha256 = "04vrmd5blrqv2immaw4xlwcc8krlpnckdlxl5jg9mr7azq657z9d"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "6.0.33"; sha256 = "15ki8y9607dw4ldixy041v3s6ld36j7r8gdhn31y6ffp0ij0s9p6"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-x64"; version = "6.0.33"; sha256 = "153hdch33nxbs4lwd799rvbac8kvbg1jbkkq440fmmy7001zdvmn"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-arm64"; version = "6.0.33"; sha256 = "0v86zfpln81b7r5yxjf676xx372kmwn0fcciwnnx6xks3i9qdzy0"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-x64"; version = "6.0.33"; sha256 = "0rcg68qj84584v6vij6kqk2jrmgci26rc40cmf9ibc2h65cm3hjx"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-x86"; version = "6.0.33"; sha256 = "1605avj9l3f6vxghkwzvqhyx5n2ipyb9y7d0n32777pg0kjc29iv"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm"; version = "6.0.33"; sha256 = "0f92sp9120a4bqcws53migvpbv6iixfqb43jp38s3sgdv0dx3i1l"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "6.0.33"; sha256 = "0xn1ckjg0zha3wib7pin29i0b3390xmanfrivm29x98mj644md51"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm64"; version = "6.0.33"; sha256 = "0yn9cczgh2clmxl92jca176dkvqn33jc4jyl25s41z9y58gbc9nz"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-x64"; version = "6.0.33"; sha256 = "18b8pf3dkbgav63yb2szdi96v6s1brn6yhbragzsw9iiwhvqxw8n"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "6.0.33"; sha256 = "1c4j03a7dcxvb0lajllnkyi7jdjzvvfd739mnhpcy5dcfaz625yv"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-x64"; version = "6.0.33"; sha256 = "09hbn47rn8yn5646p12xzw60ijhshrwav5jsha2hn27d4i57ls5j"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-arm64"; version = "6.0.33"; sha256 = "1x1b6hc4jg3l3fypdll6rqq29021v2p8y5piclyhsqwwhlzjb2cl"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-x64"; version = "6.0.33"; sha256 = "01pvlmwhdhp6ny3h5m0rm5mahkj33xgmrbcldvh1qsilwb4vqvsb"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-x86"; version = "6.0.33"; sha256 = "1yl8gy6abj4c7n2mkzs6v9mjzv2bhwdny7za6pclay4m1a4kijlf"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "16ij3bf9kil06kh0ca1csqcg3x5ang46z9pd17y6f08im1l0xfj9"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "122aw6hy2xws6wi00g3swcp7ria1qwzrz4ywakwbqjac0winshmn"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "186r14nlx93g053yhxcq9lfai2j9w7nrjiff1y2q5bmnkfnbd38j"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "12mxxvzi9rf53lj3vz2q8fpar915ghdhixpkm9q29kz8ly3hbv1c"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "0zjpj744gld18fni5gwr94yp5bmf7hk8k7mcpg5s34pyyzp3zd0q"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "0yzs527173v46x77if2ark872sjx0a1spz08xsm9d3bpkx0ncyd1"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "1hf30pxgpc1kcmfpcnd4v69xrav99npsv7apzj55fy9z83a2djgy"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "13vpx6vayxqk7g975bgvdslcfwaxvs3rj7ikn7ir3k0kivsp7dlq"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "1i60ry18padghnnwlyxcij0hc8361mh4mnsx4wy1y8ys45s5garc"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "0k4h0j73sjd1w1zkcq1qdz2kdmrjnssr5w9g7xx2l1djkvw93lkv"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "09kzlvz9ddzj4x8p9qnjvb2xkzbhwn2phs4sxwa8305janbhypy7"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "12sjcxxg0l2q3ks4s8lac2l5yb7xn691idww895jkxar7d47vjy4"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "119szgcdrbxqqmmz59phw83b7kv0vmfl2pafhnmx63wvyda1717x"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "15fmfgl0ga7fkz4bw74552ljs2l0iw6sm6xk0v90k6qdihy4z9ay"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "1a0dvvsivcsr6r2ln8r0g7d08swh2pa5fnzcabif833x7rxlriqz"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "0kv445lsj1kkp2mgayp211i5q28j808v54z4fxifda3cynjpsyv1"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "090v3q7d7i1h4a8zafhhh4h4qgws7i4vr20px4x3sq2lcigqky28"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "1s9ia1hh82pnzj0w6szjyg56vb9w9h1rlnqj1nb6nk6vj3a6ihiq"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "1n5j69z3pvmas6a6p5c45qn6mzdmb8ns4yl2if1cc69n3fs6axmw"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "1zbdbainvfx8m1228ql3zs2zs2dincl1fwgfivbwg0pb578l70ab"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "08aqnwzvxhvk9dlxra5f022hjgcsqgcs1kpdm09yy6yma3xd8v6y"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "04asl4lwf3wlrghccip463fri9sgarbgijky8052c1caj68bmscv"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "0x38bnmilkkc2c3i62jkn3vj3visjx87drsj3m3k0x6psn6h3qmr"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "1hkfp1p8z6ada8z5ilbn2j1pw6mqxw69r6719rcv8ggngpwwd21y"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "099s3fcqjl2sjp3fsn1xb3yq3qjv5nwsmy40ipr2wrf17lasjz2w"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "1wbzabbc7br7my9f453n8jds29ry2mx3l3b03b4bc3zl1ri6spzn"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "0jwyfcw085svfr1f3y5xbpap3mhszpax95l7rw6g77fp15qfdzf0"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "0yk7j0d8hgkb9dkgkxrp19cjg09sl3vycpz9ff16md8jjakd2ywz"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "06156xl3wia310qcfjahs5ni58j42pg8s0gjy7yzz7m7ixkig1kp"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "1sydbax1kcg8nbcry6h4ik54gk2q5swbw5cay2w5xl985p6dwkjg"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "00pcsz4vd9mscrwbpwlqqnlacw2xihxgvlp6xw0ycjsdrkq4621z"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "0l9j0fqpi22b791xs1vik98gr4zz004gxni85zmss64pqj7zabkb"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "1zpciqzf5g7sygj1iw3r575msfmr8bs56j68rx7jl90hzrdf14mr"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "1qwbplriqj5b720lnl4h9848pixxagqqa7k73fa11x2r8yqn399b"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "1nyffsb8lvj23x2xg38ngcbg8bh3apv9px1n9slf8jf9qlb6hnhc"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "1ynzpwx6mmj3w5x37ivqjjk5is9hmgwwlb8p50rjhidhc99avlwj"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "00if84zqqkrl7gdak1hx8l93ixidj4sgxj5d6wjji93iiph4m9md"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "0vd5xvmxvlqc6k1c86ib0fk582899vvkfnsnnfmw7f6s8271jcs3"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "0lkv19rqhvykdvs3lnbv0lda66s6wz52ad244yirmmr6gx54a7jg"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "0g4aqyz0685mh4b2w3d96q0m7138w3j5w9ds9yli51gdlv0xpy13"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-arm"; version = "6.0.33"; sha256 = "11qqd4vkjmypah5lg9y37ma374a7kwvrrqi14knc9rzi038xdzc3"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-arm64"; version = "6.0.33"; sha256 = "0ghxb55azggk0cs8aasv57w7n1ag7wb981dfrqrag5cfi6gdwwlk"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm"; version = "6.0.33"; sha256 = "0vglrj3yx5ykxy6lbpb6frsxcp3109rpl6zl859vy6vdmjskpdn2"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-arm64"; version = "6.0.33"; sha256 = "1cnm270drlfq1f839r5frljfg8q4xqn0fqicf97bd2cwd1nyx8gl"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Ref"; version = "6.0.33"; sha256 = "0vrg6xbzhi8mbp6nas6admh6pja3akc9synlcpjh859mg9qr8886"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm"; version = "6.0.33"; sha256 = "0vdabiysl8hjaza06yfmk2x45i2qhr092izx820qv8clfdggmb8k"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm64"; version = "6.0.33"; sha256 = "0zlsdg3bn5i1s09p9lw7xfdcfrm0ii9a1zbfqhvqgvs4zwcvk17n"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-musl-x64"; version = "6.0.33"; sha256 = "0jgmmy5y2ci29izn0w1dh73xvrmvmypbyxjiq1kxjq1si5j465mv"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-x64"; version = "6.0.33"; sha256 = "0l7bh7mfha16dbpmlvgfpkgblw0p00x52bcki96pkjldgqnf2fwr"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-arm64"; version = "6.0.33"; sha256 = "03bk8c7shd8sfvlw8k58aq95yc094247722fs2s2456j1gsirqqj"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-x64"; version = "6.0.33"; sha256 = "0qzdhg82sxa1srjh5lpnjyyz6lww00j1b4sgm0581ya1cjz8b38c"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x64"; version = "6.0.33"; sha256 = "1sn5q5q0qwnj5majqsfbzgirv0kgxs538ri9cbrp52sdz017c3a1"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x86"; version = "6.0.33"; sha256 = "1ddmaapazmsvwmry58x117hjl2l3q7r52l8wk45h820q46v8m26v"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "13l2xvm9zlb2b8xmznjj341nrknhaqcz7hlg4ccs9rmw32p0zvdy"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "1fiqsm2nwz45gxrakbkvfcsp3g8l0nl678df0k52ql4inn77f7p3"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "1nrnwgpgqrjr1pipjld74h1nk2m1gfk83f6lid4hvznyvi4181ph"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "0n8hm8dhl1k70iag7n6pkzi9nfc56xkz4y4xsn6hy792nw17haz2"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "02cjzf07kp8k2vb8hmf72rz6fx2y29biqvdhdva2jj2j1768a9gd"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "0k0cc1swhcrf6ydw0qkx52ikc8mnjv9i0v963yp61n6dhsa5cv2z"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "0ascpl1c8a710ggmxvkxw63rgp1gwkjdr03mmvwlwiwgxks5z4d0"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "0ra2v9l3w9sid1hg21ss7lawp8mgdhv1g04napa4nrv84bcz7kkh"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"; version = "6.0.33"; sha256 = "10hswinnzm4mvhaqj1kr352lx7a7m2c6dc96q7p5dizlsg2rsh54"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"; version = "6.0.33"; sha256 = "0h990mf442c2s9k3vfis7r1nhf36bm2xsmz8472vlhdgym3bvr9h"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"; version = "6.0.33"; sha256 = "15s3ihn50jwh3wdswy2563fl8rjdn5lxwhfcsd8xsjp9j5ixpm27"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm"; version = "6.0.33"; sha256 = "1vcq2m5bcrkvqdphjcx7lz780rgddi4h2sbwhw5ysxmns5nkpim4"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64"; version = "6.0.33"; sha256 = "1jh4xm42mzrd7xqp96qvvinhz7rs9qfal7243nfiznl4y9az4k85"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "6.0.33"; sha256 = "0zfqp5axbl5066655wsd4435194xfnfbs2k8hb1dp82a74fwz2p1"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-x64"; version = "6.0.33"; sha256 = "0kkqj31kxdsd8jzna25lh6f1kqlwpx5pfwgdn02qr7dzln8c25vw"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64"; version = "6.0.33"; sha256 = "04gc5p591kmn3divsqqn8s29x1l3klcysj4zskcidp1dkclx1dq2"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-arm"; version = "6.0.33"; sha256 = "1aik89f8pjg5vrz1lx6g0ccsbkcf38mw0591dbryqjwfdzp08g2f"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-arm"; version = "6.0.33"; sha256 = "171qj7ajbc3fhld7dbqm04xrqmqmhbfmh9vpsl6sqkgp58b8vg11"; })
-      (fetchNuGet { pname = "runtime.win-arm.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; sha256 = "1pf31zyfxd68cs6pklhg5g8izp8r5jzkcxgq85px62ym6xp83r0w"; })
-      (fetchNuGet { pname = "runtime.win-arm.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; sha256 = "0in7gk5bi69gmm992cs4apj2kaxdjsdmfxcrl291822mi2ai3d2r"; })
-      (fetchNuGet { pname = "runtime.win-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; sha256 = "18m6qi5hjlscd8lkmc8a513zycfhm64mqyd7g032j02vrrz1d20y"; })
-      (fetchNuGet { pname = "runtime.win-arm.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; sha256 = "1jq2mc722g8xc7wggyxayfvhan9dplvk4rbp9pjkpiby25mlhj8g"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Composite"; version = "6.0.33"; sha256 = "1ighzhn8ngjnv53nn98b8n8krwh6k764r2kkxwfccajwhpn9sb23"; })
+  commonPackages = [
+    (fetchNupkg { pname = "Microsoft.AspNetCore.App.Ref"; version = "6.0.33"; hash = "sha256-GcPiO+iI0JsHYlqURAmzWjOnDX2jDCUY4jYaIwr8ojs="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; hash = "sha256-SboOaKgRAWf8Ce2mb8izqvTxGNYsKAbgNIDGmdwaMpo="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.App.Ref"; version = "6.0.33"; hash = "sha256-BiGUcXo1FQTlZdR6ndhUQ8lrYG3KaGXNXRVF+Fc3L28="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetHost"; version = "6.0.33"; hash = "sha256-tkJtIwdMSbz4VNyTnz/HQcV8LuN6PAAiN5p34aHhSog="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; hash = "sha256-Eo22rJu2roKFD85Fme3hSYqoHE2YdehHAW+kTi0J2aA="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; hash = "sha256-LOwFh6fozyRwqvP2CBt8JaSsrkNY/D0kHcXlFP/uvYo="; })
   ];
+
+  hostPackages = {
+    linux-arm = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm"; version = "6.0.33"; hash = "sha256-pMY7bdG2du0Lh3xpAUls7WWAzqenMwlvw3tmtkoVmO0="; })
+    ];
+    linux-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64"; version = "6.0.33"; hash = "sha256-BU3yVfKE2h+dHUQcqhxOOp8Pbdwbm3RxPy3/KkjtBMo="; })
+    ];
+    linux-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "6.0.33"; hash = "sha256-4YrPHTlKoNvCgmgKvZx1naRQBiFN81KMMaDQ1VW52H0="; })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"; version = "6.0.33"; hash = "sha256-pECdxdP0x1buwSaxZpioR51ORRl5BokV3JXUb23kGoI="; })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"; version = "6.0.33"; hash = "sha256-MOW9RvWvQbrFIehX3UVdZjhoQz46uj1m0oIJQlwFKUE="; })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"; version = "6.0.33"; hash = "sha256-R9TbY5HpSt1R08xB3mmxTWZE3TBFeK4bH5BLUCyMQ5c="; })
+    ];
+    osx-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64"; version = "6.0.33"; hash = "sha256-ArfQKZst3BbZ1J9I7Rmdg4aehEYWY71jG7bOkMot7BE="; })
+    ];
+    osx-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.osx-x64"; version = "6.0.33"; hash = "sha256-fBfBkKW/nYwFsO1xd0u/nOIZnIG0CGW/RE23PsOQeE4="; })
+    ];
+    win-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.win-arm64"; version = "6.0.33"; hash = "sha256-c+3lplcEkrMapHA+nQPt4v2IkeiAvif6u2Ux32V5Iy0="; })
+    ];
+    win-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.win-x64"; version = "6.0.33"; hash = "sha256-qHleUXickhYB1CIWGWzsMB/BX61fuJXcVchkuKAOwLw="; })
+    ];
+    win-x86 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.win-x86"; version = "6.0.33"; hash = "sha256-wxAzeoLe47TV5GWXXVWRyC+AKqBuTJ79RqS0DwqJpGk="; })
+    ];
+  };
+
+  targetPackages = {
+    linux-arm = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm"; version = "6.0.33"; hash = "sha256-9IIvr+MVkup8SygTV0HIHObHQt7gNAEj+0kYanmJ83Y="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-arm"; version = "6.0.33"; hash = "sha256-ReYcVuhM8+it8FhEWNM+HLTiRsJi+8Xauscpus/uPQ8="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-arm"; version = "6.0.33"; hash = "sha256-NMTRG9jt6aHRuHKQhV2P0ex194t1FM0ZXkQBEdLVIjk="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; hash = "sha256-LKtXdCHaIx88J13bSmANZiAGgYyse8qtha+pi4LPwMQ="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; hash = "sha256-e9KR+J6yBSp6Py/xkrW2Mtc2xW84YDZ/4KFJPY4EkEw="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; hash = "sha256-x18Pl1WygIEU75poeIXlcP3ZxdrS4nRRJ/K3lv6mfyY="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; hash = "sha256-xMt9SDtZ9SlLQpy3GJKx/SxfqGCKIk30HFhQ8HpnUos="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm"; version = "6.0.33"; hash = "sha256-E636XnOUoY2BQP1HkUCGWMRCupjVeQPUVxIiqn1cqm0="; })
+    ];
+    linux-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "6.0.33"; hash = "sha256-g5zbB1DnCSKuCOWtF09GEqGn1uJLdlTN6kqdnSCzRjQ="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "6.0.33"; hash = "sha256-rwWOpf2Pdg84c8bKIUcMYuDTI0kXUELL/nl9psSmX+E="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "6.0.33"; hash = "sha256-obRKiJEVpZ5E3TE7q2oHaYwFYhI23rMiHwp+8ORkwXY="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; hash = "sha256-GLQ/7vf+kqHLu6yeiSY8rq5yPUmZvxKtQ6HRR8iRV34="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; hash = "sha256-oXlmQZ93jZaq7gj8q4MCXWpx0MxKuHhON2SPE44o+ns="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; hash = "sha256-/skm1EA/eVeK/Fedra9Naavck9mkWXZdZTOw+/oFw8E="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; hash = "sha256-mLZz9Y4TzJHjsTMemYfeXXHHqG77rXLSOxN3r7bpd48="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm64"; version = "6.0.33"; hash = "sha256-9oS5Gf9E74c3xG79oFKMoGbHmuuH03QT0CEWu8Zrmn4="; })
+    ];
+    linux-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "6.0.33"; hash = "sha256-ToaiqVy5qonomAVBg5PO1GgrPKL4Cc1BZTJ0z/2LquA="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "6.0.33"; hash = "sha256-5iYNZATXOePDsLA9lI80o1Gjxw4E+B4bJbwdYJJHcZY="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "6.0.33"; hash = "sha256-2xdhvnKsFc8utDWN09zeXzZ5op+WUqkoWLuzdtQAkrA="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; hash = "sha256-3mzU+lDVG+8TqO3OoNnDmj0JhQCuqNxpS3PDvj+3WCE="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; hash = "sha256-m+m6kJGKBSYKQH7K+FZWT6eY3TDkRsbgy5QPxymhWhE="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; hash = "sha256-ueIBjdXXdDBHHVLndlCXOu4h97BTChMHE2xOGqtdaHQ="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; hash = "sha256-PojG+X32PbRZTuGYnAzvuBp+gxR20Vg+Uk2Zj264bsI="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-x64"; version = "6.0.33"; hash = "sha256-mTvhLH6NynlNipMtUToAF3C63rzubVrvaiYo6OqB61A="; })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm"; version = "6.0.33"; hash = "sha256-DaKK9vpjByD/Pn9L1BcTufbHHyzX5R2NnqTBStv8nUc="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-musl-arm"; version = "6.0.33"; hash = "sha256-g/3W0QDx58TsJCHinDefR5EzVD3Dp0cLVNdXOTdpGIc="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm"; version = "6.0.33"; hash = "sha256-wrY7taxtG79TQfQbenMCYVzWdXZm3UWN79OX7ofM9G0="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; hash = "sha256-vu0Prhi85qQZI4/C8xlW0M5sAxlS2l87WmLRn+rugo4="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; hash = "sha256-4x53jrWRUCzKBK6hY6gFFL1xNXN7rqlyf4V8bkXVOLo="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; hash = "sha256-8AYUSNze/g1Ji9S4gaZ7oYppAySnUXnjDVlm/O7jNts="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; hash = "sha256-4it4ArciHQ+N1Z148mc3hTmb4p/X2PNUBGcGChuqEFk="; })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64"; version = "6.0.33"; hash = "sha256-lZCTehqxeLYENhg0CuYpYO6GY3/tP1UCNnJf9MddrRo="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-musl-arm64"; version = "6.0.33"; hash = "sha256-VnJaB1pt07GDdmOasNpOzMp7Mkiqns7t6as4cSVmeAY="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm64"; version = "6.0.33"; hash = "sha256-3ya2Hio+/UB0EdRLwuQYFu/ZzAmKSZFor5QJ+D5jyXo="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; hash = "sha256-/YQTVPObD9OrhU5dQV3dYM+zBuLwpvJrxbiv3Nj7OoU="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; hash = "sha256-XqVPPIwNmwnSBrObqg2PgAotqSiFHL7In+6oB+hz1ZU="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; hash = "sha256-H8dMez59DOTiUuxbV9QVkGsE2nkgI0tFNlmzHfXeDag="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; hash = "sha256-YXt9pfVsqOZid+STshFAEglcYgjievWquHMGqWkhZE8="; })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-x64"; version = "6.0.33"; hash = "sha256-W0SgEXUKeOoZVPUC5fpHw9zyyfydCOdPPxHdF5Xb3b8="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-musl-x64"; version = "6.0.33"; hash = "sha256-Lf1TDP7q5JqeLLTTNpm9NE/EGKedcFVrFBtnukqreRM="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-musl-x64"; version = "6.0.33"; hash = "sha256-FvGON+QxJq7/U3lBb2xeQZttUmxfi+WH2eqt2Ya7aKE="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; hash = "sha256-SPiJX2RUYD066ReIvEk8mj9MIIEQOvWRIjDE0w4eGyQ="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; hash = "sha256-OMJo1JDbTGuWDRJbmgNMPK1tyvPya8OB/PYKBGFQMek="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; hash = "sha256-vHZltBs2GcaCi4J6oi1atf1qLC6ElWuU0aruO34ystg="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; hash = "sha256-S4FD0SnrgsfXju5xFyizsQn9hf6DYiREqKi7baNabf0="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-musl-x64"; version = "6.0.33"; hash = "sha256-uxZDZIk6YNlnwFF2v66vu+bdx4EtcGB/TCIy4Yuv9Uk="; })
+    ];
+    osx-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64"; version = "6.0.33"; hash = "sha256-OY/vdqAzZ99I4lEZbOOQw12TE0AIb5pXxKTvDxO2M2Q="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.osx-arm64"; version = "6.0.33"; hash = "sha256-k3LenomOlacyzq4FlBY/TwV7+ClbK4U0A/O9r0pZHT4="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.osx-arm64"; version = "6.0.33"; hash = "sha256-9KHubWicibZOcixiByzuBKPnJM2u5DSQC9jR3MAR1bI="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; hash = "sha256-7SWFzAlSSCnUbrBtHFcSXnRnfhbHVYjWFhPdeYD7kgk="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; hash = "sha256-X2xWlIbN2GCuHyZtENOWtiI2oyh9YsCbNy4zyHVgDEw="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; hash = "sha256-oJFf9OyPR075rnWA3OTkL9yXh+F97l7fA+EoxAK9TCs="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; hash = "sha256-cM7z2SJoZ0vUVZaAFzZsr6LLFT1aB/FgaFEnPmjaQmU="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-arm64"; version = "6.0.33"; hash = "sha256-EuMc9QvSFCK00E6Ic4ggCTBfElaoTMTpdho1qA9Dcw0="; })
+    ];
+    osx-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.osx-x64"; version = "6.0.33"; hash = "sha256-53MAV3RO1kXzy5IpdZDZIOhoUzFqWHn7+A3aWwdTONQ="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.osx-x64"; version = "6.0.33"; hash = "sha256-tu72AwDH1+oAIXjOJcNbeyKm1s4pncYp0avbMSBrcJQ="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.osx-x64"; version = "6.0.33"; hash = "sha256-smh6SiTtCAuFglqWrXiGGsoIDP9dhGuIKdYjmw+xCyY="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; hash = "sha256-XHypFT3BZS7yjYD4qrktW+KB/Vg9WO3GlVpQiZkbOiU="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; hash = "sha256-9l9tYg70D7bIGmANOnoVPiehm0R2FOKSryevw9ZSf/E="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; hash = "sha256-wP3mcAnXnfMMz4eW1NX9GtZx1V29+OFCdlsXBDhznks="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; hash = "sha256-n3vRppIStWqCc+lf5vegOoEnWQo39/lmS2s+iBqQZ3o="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-x64"; version = "6.0.33"; hash = "sha256-DI2FvmRB+YAKqE+TFSQAnFPzvZf20gJl1kF1LdCD7WM="; })
+    ];
+    win-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.win-arm64"; version = "6.0.33"; hash = "sha256-I2cXLq282Y4Hqwwb4j4UIpZKzwdbzGV42LTzTSQdemY="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.win-arm64"; version = "6.0.33"; hash = "sha256-wP+GUxx6dtOt5ZExByyvU5zRuznGye5LPisgS6/7Bm0="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.win-arm64"; version = "6.0.33"; hash = "sha256-lIklP4WcYw09ZfEWj67YQYAkMM6G0na9G3Q8SRg0K/Q="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; hash = "sha256-d4YXZ4+nnv/98fIBjd4VRKISbdFQSccwCENFPmg3JRg="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; hash = "sha256-T07ezC0o0V648IoVvrguWMxHyowEGp/ZsuixGbpazes="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; hash = "sha256-PwhD8MxNS+YB7+bS/TqMXXCmqMWY8rt4ZrqmtsnX7AI="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; hash = "sha256-ay71j8SXGK3rLyja/ggA/5P8UJpxB91DOkuIeLEDMlE="; })
+    ];
+    win-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.win-x64"; version = "6.0.33"; hash = "sha256-UjItoakBkTBGTMQU5TC9xFbt4imiLnwotTx510VcMYA="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.win-x64"; version = "6.0.33"; hash = "sha256-XcJRWTFQsBWTqwwQlo2I7NUsxcTTyLjNJqgQJDEyj2U="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.win-x64"; version = "6.0.33"; hash = "sha256-S2+8yeI0ahzgbpStXF8fQ06oaqkZ1AKHt+bCBnml+wY="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; hash = "sha256-uZLgWv4QJCpPz8hIU/RCuTpdyyl58Bjk8/q84j6O7P4="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; hash = "sha256-K6VhsUdZ9BCUG2cehfFTvceLCEqQUEuBOKtIHDO9i+M="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; hash = "sha256-DFpoFsXJSeSoTjb0m/ZVAy70FnsWjddFH0JuipZ2zts="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; hash = "sha256-ktOtUmKwRSgzKBctyvmrMOlYppR4xzN64UPWajq/3/o="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x64"; version = "6.0.33"; hash = "sha256-QQ12AvhNi3LzYilmNIrub4Kd4/vLaSxVLdJyDHDBxeo="; })
+    ];
+    win-x86 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.win-x86"; version = "6.0.33"; hash = "sha256-7/7MpglFhvZJb8AaNA4zDQm/pgRPbLEUkAOnDOqhz5E="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.win-x86"; version = "6.0.33"; hash = "sha256-OybB5ATvnnPEsKAdn5a/UdjSPcT78wlf38YNmuRWBZg="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.win-x86"; version = "6.0.33"; hash = "sha256-jso4iQqVeEXZNeofbxuHS+wva9pG/1mFPYzIpYx/iPo="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetAppHost"; version = "6.0.33"; hash = "sha256-raZK4I1xpCglN63I/jSRLfY4EkUdhqnaOzRPjD9BLgI="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHost"; version = "6.0.33"; hash = "sha256-QzMZjkDauMOrs1ZbN/dOCQlUpgMrGsTCNAzT3evupW0="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.33"; hash = "sha256-Tx5FSn8m15qjJ0Q0JcrnRhujGgV7WTr0btNviHMKe1I="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.33"; hash = "sha256-I/jbwabthRKpT7olXuTgaIRTATapDS4WgbUgA77Hijw="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x86"; version = "6.0.33"; hash = "sha256-24iKtiEYCAQLmRxRUfLBgwoq4Qmho+Jz5VvXr65StbU="; })
+    ];
+  };
+
 in rec {
   release_6_0 = "6.0.33";
 
   aspnetcore_6_0 = buildAspNetCore {
     version = "6.0.33";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/91f66f75-bd3e-48f1-acb9-99c0da753f96/42c47999ee4c4d108774536afe5da160/aspnetcore-runtime-6.0.33-linux-x64.tar.gz";
-        sha512  = "12b34fe1d0a679ff63db4bf002a2988194d9e64d0e107d128c247821dd939a86eced0fe453c0638d3742dac3a32e533792c26299400fb4fd5566b75177e66875";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/4ac9397f-3f4a-4cd0-aba2-35e7f1b47396/9823f50c32028899f430bc3ae87251b1/aspnetcore-runtime-6.0.33-linux-arm.tar.gz";
+        hash = "sha512-f6jM4xyaoMg9/RZ7ehFsi0o00hsRVO/HgbwqOMFNNQ54tbnub7jjgU5k3sbJLg8r9cXMmvkMc+o4zLZlQGBBdg==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/0c5a5f3a-881e-4ceb-a334-c5e3b210eef8/9834ffebacea659cd14d272fb01f81c4/aspnetcore-runtime-6.0.33-linux-arm64.tar.gz";
-        sha512  = "7a60a77a306070a3b94db1acfa73938b6880cd079bdac3e5cab174a47af467b9208e9f41d8e12e080831d528151cdaa5b660bea5aa6fe537ec144543c0fffd95";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/0c5a5f3a-881e-4ceb-a334-c5e3b210eef8/9834ffebacea659cd14d272fb01f81c4/aspnetcore-runtime-6.0.33-linux-arm64.tar.gz";
+        hash = "sha512-emCnejBgcKO5TbGs+nOTi2iAzQeb2sPlyrF0pHr0Z7kgjp9B2OEuCAgx1SgVHNqltmC+papv5TfsFEVDwP/9lQ==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/d4641b35-5b85-4250-9913-0f6a2c276888/bd8483d09a767f6c19f9274da2819624/aspnetcore-runtime-6.0.33-osx-x64.tar.gz";
-        sha512  = "f8dcf3d6de7a34d7fb402fd1ddf55bd810cccb95831d12312bc7607c6c7de8a46200c66d7e753250103961ba2e97fa6a85206b49442e1aeab1e290ec69bb55c5";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/91f66f75-bd3e-48f1-acb9-99c0da753f96/42c47999ee4c4d108774536afe5da160/aspnetcore-runtime-6.0.33-linux-x64.tar.gz";
+        hash = "sha512-ErNP4dCmef9j20vwAqKYgZTZ5k0OEH0SjCR4Id2Tmobs7Q/kU8BjjTdC2sOjLlM3ksJimUAPtP1VZrdRd+ZodQ==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/74fa4afa-a6d6-4c32-8ef7-fe88148f10cd/c887bff014d198532ba942988cba124b/aspnetcore-runtime-6.0.33-osx-arm64.tar.gz";
-        sha512  = "26a2f1d6cb3ef9df5b6abc16e025fc2e9aeda386b5da53428abae67d76ff007bc921aec60cff9675dbb7291db7b75c5a7bcaadb54e8c04de59308b02dde924cc";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/e9b663a7-2199-4111-b18e-5ec1f2f2f87e/1746ce0319914f58806f523c6f6ed24d/aspnetcore-runtime-6.0.33-linux-musl-arm.tar.gz";
+        hash = "sha512-V0q861fybhX04s60g3Zh4ZLECJhoSIDgeLitTPyPUG4lpQ883HJ24XqVVuleK5LrxtQadKZWJEGA0nNBSFqc6w==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/a4b5cbf6-85d9-46a0-b698-aaf3cde78d34/e1d46fec4ac226e170ccbacbf111d911/aspnetcore-runtime-6.0.33-linux-musl-arm64.tar.gz";
+        hash = "sha512-PaV7PeE02zjxcJRRjRZlM1ZJHPXWciKyw31yDsEAZE3suPs62NymRRNO+6e1e/Faol/oS5oScRqoDH3gxghhtA==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/94348e55-d279-4667-abf6-00a70cfa4773/67a06176a4ac8fbab11013cd728ed823/aspnetcore-runtime-6.0.33-linux-musl-x64.tar.gz";
+        hash = "sha512-9aQ7C8HIMv1wzfpP4JhJYCdggxEzokEvX30llJbM0NxlmZunek6NSwanYUuFHUeX+S1cfFwcJvOWQrde3P8Twg==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/74fa4afa-a6d6-4c32-8ef7-fe88148f10cd/c887bff014d198532ba942988cba124b/aspnetcore-runtime-6.0.33-osx-arm64.tar.gz";
+        hash = "sha512-JqLx1ss++d9barwW4CX8Lprto4a12lNCirrmfXb/AHvJIa7GDP+Wddu3KR23t1xae8qttU6MBN5ZMIsC3ekkzA==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/d4641b35-5b85-4250-9913-0f6a2c276888/bd8483d09a767f6c19f9274da2819624/aspnetcore-runtime-6.0.33-osx-x64.tar.gz";
+        hash = "sha512-+Nzz1t56NNf7QC/R3fVb2BDMy5WDHRIxK8dgfGx96KRiAMZtfnUyUBA5Yboul/pqhSBrSUQuGuqx4pDsabtVxQ==";
       };
     };
   };
@@ -140,21 +202,37 @@ in rec {
   runtime_6_0 = buildNetRuntime {
     version = "6.0.33";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/250c78ac-a53f-4679-ad2a-cc31fa4c4001/204b39eb9634a8dd9f39cbcaf56030f2/dotnet-runtime-6.0.33-linux-x64.tar.gz";
-        sha512  = "0892015544d8903999f8e0fadab6b4b91eb180e495fa5e36c1a755b1d42e134858b7bdbfd60d1880650d9c528d07e31b9ccfc73e650e5d890a955902a89139cf";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/19a5a6e5-87bf-44b2-b7ed-ac44e9a253b8/00fca686dc0139022528dbe5f6e0f0b3/dotnet-runtime-6.0.33-linux-arm.tar.gz";
+        hash = "sha512-wzSbHJi/jQt50NPeXBJ5L73UrvHAS20MEV1aplHP0uhkJSEXCzEtsMtvrNBXlYs4fGDrauW4KOIlAwDvvW8xlQ==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/694cd8af-7e9f-4161-8c1d-1c9a7b1d074f/d3a8dc90d971ec4f135f6452c176dc93/dotnet-runtime-6.0.33-linux-arm64.tar.gz";
-        sha512  = "c700d4ae3e361fa2a390a8fcf294a2277931b0ea60bd4a2f0ec2bb982bb6c618ba002e5955c3ee96807207b256e10289cf1cfa372029b758aefa6bf1268d45fb";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/694cd8af-7e9f-4161-8c1d-1c9a7b1d074f/d3a8dc90d971ec4f135f6452c176dc93/dotnet-runtime-6.0.33-linux-arm64.tar.gz";
+        hash = "sha512-xwDUrj42H6KjkKj88pSiJ3kxsOpgvUovDsK7mCu2xhi6AC5ZVcPuloByB7JW4QKJzxz6NyApt1iu+mvxJo1F+w==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/82217487-71ef-43cb-8678-d293b802b5a6/cfe49dd7b7e0e3040d4fdc9258c61dde/dotnet-runtime-6.0.33-osx-x64.tar.gz";
-        sha512  = "a0ad81d4bb361d91edc7b42142828fb5ac5b75376e6ad0137f7f28bba5c0d0b68c67af708bc85c15ebb7aac5f98df20bd83a56144a1bf9ac5aeaf5caf84e4128";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/250c78ac-a53f-4679-ad2a-cc31fa4c4001/204b39eb9634a8dd9f39cbcaf56030f2/dotnet-runtime-6.0.33-linux-x64.tar.gz";
+        hash = "sha512-CJIBVUTYkDmZ+OD62ra0uR6xgOSV+l42wadVsdQuE0hYt72/1g0YgGUNnFKNB+MbnM/HPmUOXYkKlVkCqJE5zw==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/aad5df88-c193-4579-b847-633186659a2f/1688cb1838ae0f0b67d16f3ed808f566/dotnet-runtime-6.0.33-osx-arm64.tar.gz";
-        sha512  = "95d0e646f688e6f46545625dfae46d8325c7aee4661d3f0e59044acced9c6192ff51524355696e8f868ebd112e9a036d01c951f7249d863c300d07c1a0913d1a";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/e311cc4b-e2a4-46ef-8f0f-5996ac64e6d2/0a423f3d95284288d08250ce9e34ba06/dotnet-runtime-6.0.33-linux-musl-arm.tar.gz";
+        hash = "sha512-qVlKSJ+GNK8B58YKyrX37grFRLmM5z7mcTWb7Nb2sp9NnmTf4xZoIsBQYVdzHsRPptsCqL4bF6J5r2GmZ5z9OA==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/6c147b46-cd90-4412-9df3-ca84fe040261/d026454e65fe16a83590bd75f139fbf4/dotnet-runtime-6.0.33-linux-musl-arm64.tar.gz";
+        hash = "sha512-5XB5cLKoUrgLH9d6OIPlDeySXZHriQEsFm5KRekXBkwkBApuREsFR2cDPLm56DFLa1EX/62m0kirf5DI5A/lVQ==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/28d86acf-06f5-4bff-919b-28a26264591b/452ad01a142981b4ee4fd55b97117cf7/dotnet-runtime-6.0.33-linux-musl-x64.tar.gz";
+        hash = "sha512-O/5Pnd4Cva812wcnHPVoc7UIwyKTGLvn1Hju2FVBftOUHZ2ajt4v0cxc5fe3PE5a5GZtLMR/4q4J1fhiXEbpgg==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/aad5df88-c193-4579-b847-633186659a2f/1688cb1838ae0f0b67d16f3ed808f566/dotnet-runtime-6.0.33-osx-arm64.tar.gz";
+        hash = "sha512-ldDmRvaI5vRlRWJd+uRtgyXHruRmHT8OWQRKzO2cYZL/UVJDVWluj4aOvREumgNtAclR9ySdhjwwDQfBoJE9Gg==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/82217487-71ef-43cb-8678-d293b802b5a6/cfe49dd7b7e0e3040d4fdc9258c61dde/dotnet-runtime-6.0.33-osx-x64.tar.gz";
+        hash = "sha512-oK2B1Ls2HZHtx7QhQoKPtaxbdTduatATf38ou6XA0LaMZ69wi8hcFeu3qsX5jfIL2DpWFEob+axa6vXK+E5BKA==";
       };
     };
   };
@@ -162,47 +240,79 @@ in rec {
   sdk_6_0_4xx = buildNetSdk {
     version = "6.0.425";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/f57cd7db-7781-4ee0-9285-010a6435ef4f/ebc5bb7e43d2a288a8efcc6401ce3f85/dotnet-sdk-6.0.425-linux-x64.tar.gz";
-        sha512  = "a04b75af7c5850238a8d99a6f60b37753467db615831bb3833c14aec86faa2d6ee9b8643885798924a01e28acff44ac9ed39c89f7cbe53c5cb8753c802e85039";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/2ff9a08a-9a84-498d-83e2-82e3e3c3d03d/64b283f30bb7df0260c8a7596dfcdff4/dotnet-sdk-6.0.425-linux-arm.tar.gz";
+        hash = "sha512-4Muzo4dP7HYCbVzhGs2uB6cg6wK1AMh4gqrrpI5uwpDWI3PlG1M2fsqqG9S9dw8soaquw6hJm90cEUiU2qpNrw==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/ec8e29f5-2fbe-47d8-b0c5-81f11434c00f/ba4bd30be448d649e5ddf1991bf76252/dotnet-sdk-6.0.425-linux-arm64.tar.gz";
-        sha512  = "c15f95664fd0570d5b0cb94c7af6bba5fe830470004f0e958e49d53764714cbf8ddd620b38d487b60a27dbfd467a955856aab3df9c958cde17c942079fdaa55a";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/ec8e29f5-2fbe-47d8-b0c5-81f11434c00f/ba4bd30be448d649e5ddf1991bf76252/dotnet-sdk-6.0.425-linux-arm64.tar.gz";
+        hash = "sha512-wV+VZk/QVw1bDLlMeva7pf6DBHAATw6VjknVN2RxTL+N3WILONSHtgon2/1GepVYVqqz35yVjN4XyUIHn9qlWg==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/ce410b9f-c7f6-4180-a373-bcb6528a0778/448c9df07432b5dc62d08868ccfef62a/dotnet-sdk-6.0.425-osx-x64.tar.gz";
-        sha512  = "5757c661d82408680a6e45efbca260bb9da145bd83f8275280e9ba756a2827ce35c7ae77cb248e9ee6c6cf46730c6e50152b98c0a082c0de764f5e522dfb6ca2";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/f57cd7db-7781-4ee0-9285-010a6435ef4f/ebc5bb7e43d2a288a8efcc6401ce3f85/dotnet-sdk-6.0.425-linux-x64.tar.gz";
+        hash = "sha512-oEt1r3xYUCOKjZmm9gs3dTRn22FYMbs4M8FK7Ib6otbum4ZDiFeYkkoB4orP9ErJ7TnIn3y+U8XLh1PIAuhQOQ==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/24192716-57e3-4e69-9950-7840e05053d1/79398f054d34fb3e424c029e6d41a551/dotnet-sdk-6.0.425-osx-arm64.tar.gz";
-        sha512  = "7383b188c8500ab8625cd34f69f7ec5a4d9ff4ca715f95ee020f2bd082d5023697b021ca4b3b1e6a0782fae2ff89586e541e454fedacdf1c49b42f6e47d12011";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/04bfd229-7d52-40dc-a5eb-d31fe15fbf44/639e3b8aa8616ad25515bfe36faeb2c0/dotnet-sdk-6.0.425-linux-musl-arm.tar.gz";
+        hash = "sha512-xZ6g72yA+AkHrqIj3Hqa1pQxseZyNN7k/uD5EJ7nzovVivaxAq0ReIn04syO98zu+absgLEFeMbqS4RBLyseBg==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/b5f55496-6494-45bc-9ba3-7aefdefb4518/61f15988a48d429bec81f5c5307f01d9/dotnet-sdk-6.0.425-linux-musl-arm64.tar.gz";
+        hash = "sha512-1Yqs5bAh/HMKDaIjPoXjrkcyVqfekzS4kyzC4NBQVDwesbFtzTR193fN9Z5ClxyF0n3vSX/lzwamtgRs6NI+xA==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/c94a92f9-153a-4620-844c-f964dcc7eb8e/ad7baee9c9ed782a5c9ad34509ff47a5/dotnet-sdk-6.0.425-linux-musl-x64.tar.gz";
+        hash = "sha512-zZVyNYECuCFIdP81O76Casm6Dw0m1JST8xKoo7x8D6ui/IK9Xft0AonTJC3N94s0GZbThiNyPGkb5Gk3WnLfng==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/24192716-57e3-4e69-9950-7840e05053d1/79398f054d34fb3e424c029e6d41a551/dotnet-sdk-6.0.425-osx-arm64.tar.gz";
+        hash = "sha512-c4OxiMhQCrhiXNNPaffsWk2f9MpxX5XuAg8r0ILVAjaXsCHKSzseageC+uL/iVhuVB5FT+2s3xxJtC9uR9EgEQ==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/ce410b9f-c7f6-4180-a373-bcb6528a0778/448c9df07432b5dc62d08868ccfef62a/dotnet-sdk-6.0.425-osx-x64.tar.gz";
+        hash = "sha512-V1fGYdgkCGgKbkXvvKJgu52hRb2D+CdSgOm6dWooJ841x653yySOnubGz0ZzDG5QFSuYwKCCwN52T15SLftsog==";
       };
     };
-    inherit packages;
+    inherit commonPackages hostPackages targetPackages;
   };
 
   sdk_6_0_1xx = buildNetSdk {
     version = "6.0.133";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/3fd189c1-072f-4193-8f1c-663b68b9b06f/bf63007e0f0ba0b3d07f1af06c1dee6a/dotnet-sdk-6.0.133-linux-x64.tar.gz";
-        sha512  = "7b4fe0095bc6d3ea43fc3b32f2fc2ccc8fec83b0c50ff74b9e9a019ed40721f46c60d7b3ac08841a5f89d0802d8c347b14a445032a00f3d9a8661558b9c74794";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/af2b3ac2-cf96-4087-809b-60192e8564d0/952e49c2581e6c73d6229c2ce14e994d/dotnet-sdk-6.0.133-linux-arm.tar.gz";
+        hash = "sha512-6Ua3XNGqu1M5mqv6RBCC2cwPMk2zcdlgeSvPWrZkRaFjAvEfkea6NMaZpr7WRe5PF87FXZtxGXJvABEADixuNw==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/759c84b7-4d67-4eb4-94c6-0214d150db31/aea9ac1878560278c50174ee213d88c6/dotnet-sdk-6.0.133-linux-arm64.tar.gz";
-        sha512  = "6820d62ced6d9770ebd3667a64a74e2249471ee5920e4ce4101f21e55950f8d44ebe4ffbf20bc66260fd5d1edc5e534a6f0b70522fc41a5e48e75b0bb00e6ea1";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/759c84b7-4d67-4eb4-94c6-0214d150db31/aea9ac1878560278c50174ee213d88c6/dotnet-sdk-6.0.133-linux-arm64.tar.gz";
+        hash = "sha512-aCDWLO1tl3Dr02Z6ZKdOIklHHuWSDkzkEB8h5VlQ+NROvk/78gvGYmD9XR7cXlNKbwtwUi/EGl5I51sLsA5uoQ==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/c8f09b91-04fe-4d0a-8d01-0556c53f2a5d/cbfe49b3182a2c4ebc7aecd22b6ac881/dotnet-sdk-6.0.133-osx-x64.tar.gz";
-        sha512  = "e142785256b731abd6f7bda79b1422ba6eb9135f61526d6f687be67146253403cbec85d3ee66f49e577e7f296b32f94fa705ccf048292b1c00f981d2ef4fd52e";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/3fd189c1-072f-4193-8f1c-663b68b9b06f/bf63007e0f0ba0b3d07f1af06c1dee6a/dotnet-sdk-6.0.133-linux-x64.tar.gz";
+        hash = "sha512-e0/gCVvG0+pD/Dsy8vwszI/sg7DFD/dLnpoBntQHIfRsYNezrAiEGl+J0IAtjDR7FKRFAyoA89moZhVYucdHlA==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/fee562a1-baa6-4e8f-a3dd-2c49eae8a891/564d31d1daea39179782c413f99c6160/dotnet-sdk-6.0.133-osx-arm64.tar.gz";
-        sha512  = "c0193152166cefbe60a7cbdb4af7e2df365c9e67a0ce0ff5cc1aa06a46d4ffd6cccda3bf026a47116f02e4c52875fdd704aa380817dbc3eab653d30f4f5ffe20";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/b700d687-929e-4e81-be67-1f7f39cd01da/f9d75264cbf2786cae51edfd57c72208/dotnet-sdk-6.0.133-linux-musl-arm.tar.gz";
+        hash = "sha512-xmabIp3sZGchla/XoY6qwwpROoanAAbqtXDtr4qWfoUpvtMQ9OkQdvxM7H8LULSya7Gp1hcJqvPqSH7dMuF2QA==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/f92a7e79-c792-48bb-8d07-4a6ee24b62d6/26bc7013753251407efd71eaf6ad8a3a/dotnet-sdk-6.0.133-linux-musl-arm64.tar.gz";
+        hash = "sha512-Tkz5HhzprAV2OLKjI2N1KMiYZtqPiPbHD/yI1UtrcoF4GtF+Ys3wP19oRHrk7O5IsV+5fJCLyaVcOMdb8HXCTg==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/31aa43a2-5537-4423-8994-564c25089f9e/872a4380086a5a174025e2835a2fe043/dotnet-sdk-6.0.133-linux-musl-x64.tar.gz";
+        hash = "sha512-9Sur8vgIZ1NZN0aN925x7322UKWGEzMJoQtNigTKIFPN+OekJvb/NKPmc0N/c81RabGhw3a8CZNfyjSozyEjNw==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/fee562a1-baa6-4e8f-a3dd-2c49eae8a891/564d31d1daea39179782c413f99c6160/dotnet-sdk-6.0.133-osx-arm64.tar.gz";
+        hash = "sha512-wBkxUhZs775gp8vbSvfi3zZcnmegzg/1zBqgakbU/9bMzaO/AmpHEW8C5MUodf3XBKo4CBfbw+q2U9MPT1/+IA==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/c8f09b91-04fe-4d0a-8d01-0556c53f2a5d/cbfe49b3182a2c4ebc7aecd22b6ac881/dotnet-sdk-6.0.133-osx-x64.tar.gz";
+        hash = "sha512-4UJ4Ula3MavW972nmxQium65E19hUm1vaHvmcUYlNAPL7IXT7mb0nld+fylrMvlPpwXM8EgpKxwA+YHS70/VLg==";
       };
     };
-    inherit packages;
+    inherit commonPackages hostPackages targetPackages;
   };
 
   sdk_6_0 = sdk_6_0_4xx;
diff --git a/pkgs/development/compilers/dotnet/versions/7.0.nix b/pkgs/development/compilers/dotnet/versions/7.0.nix
index 159d9cc23985..21fa129c3363 100644
--- a/pkgs/development/compilers/dotnet/versions/7.0.nix
+++ b/pkgs/development/compilers/dotnet/versions/7.0.nix
@@ -1,146 +1,208 @@
-{ buildAspNetCore, buildNetRuntime, buildNetSdk }:
+{ buildAspNetCore, buildNetRuntime, buildNetSdk, fetchNupkg }:
 
 # v7.0 (eol)
 
 let
-  packages = { fetchNuGet }: [
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm"; version = "7.0.20"; sha256 = "0ab1l6r77a11sk450jhhi9flvsn8gp4fz2il2a0vk1lw5rw23047"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "7.0.20"; sha256 = "050wdpwp7hjk5c9xyx0vj1cmslcdl9acldhxs6al3nx83vssa1kv"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64"; version = "7.0.20"; sha256 = "0wi679cxlfx8s5nl3iqgma9nmxzbi73wamxshgpaaj2dg3z5xrqz"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-x64"; version = "7.0.20"; sha256 = "0bgi8rx7dam9727v936h5ap81fx4k9n708002raw9v69p8yva5v6"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "7.0.20"; sha256 = "0h6f18k05w66797yyj7yqbf6jv5k3c5r089mkw43y4gbqz27vbmy"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-x64"; version = "7.0.20"; sha256 = "1xlqjar4j0g1a7wf8ixjpnn6i19zxr3c7pwr6jdn06yzbi20ri7q"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-arm64"; version = "7.0.20"; sha256 = "0l2md2g657arlf703vf9y8x1k0zx50zf4wy4f96m6qgs9jx8s6py"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-x64"; version = "7.0.20"; sha256 = "1r2nxc0nm2n5dc7laf65yqbjv23g9fzwcvv8vhrnvir6j3lgxfcl"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-x86"; version = "7.0.20"; sha256 = "1n0dz6k338wmadkgb7x0jywz2qxf3427wkjw8xn2zdz4m1fcj58c"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-arm"; version = "7.0.20"; sha256 = "05srdy7bvgasr0yx1mxkilbkls14k0dmp4mzc7jiqv7xspc4jwwn"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Ref"; version = "7.0.20"; sha256 = "00npza90sgnvls4k1k95mhgiw5fpxcrxf60fi17k871m6igdfh1q"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm"; version = "7.0.20"; sha256 = "1q86xz3v8p24728bl7sw0flhzk042ygxa23k0qyhxdn0qwzzq6bw"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64"; version = "7.0.20"; sha256 = "1jjb4jsnm0f1q0s8199nympm9vifaa129l0bj4j1z94i1g85nw1w"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm"; version = "7.0.20"; sha256 = "0cn8j76jbbp6vpf00kr1wwr4z1ij0sgdymawff32qvj44wfmhpnl"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "7.0.20"; sha256 = "0cbk7shnry75p95zyg14pszf396pgpyjwzhraqbds5mmncqisvgz"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-arm64"; version = "7.0.20"; sha256 = "02fz22di6ax1819spb4v22nb89glp3h08kk88am6rx3vgb440sbm"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-x64"; version = "7.0.20"; sha256 = "0wvg2rfp4v8cnqkfjv4ifj9q0bd3vljqnbnf719nf1h0ilmcxcjx"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "7.0.20"; sha256 = "1mq59gpd6p46zl2nl5ijjncghx6fms9nig9zqhxazjd15bqy0l33"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-x64"; version = "7.0.20"; sha256 = "01xpgbphknkjqgsbcngvckg3a8q0y74g409v7hmxsh7rjcradnqd"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-arm64"; version = "7.0.20"; sha256 = "155z494bpri732h1yba6ggmalgwxw68qjpyrbzfj9mi4whwy6p47"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-x64"; version = "7.0.20"; sha256 = "021mg80b9x25jpdm2rc6m91wib15bb5arkxjjfa0cp509i5hnshi"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-x86"; version = "7.0.20"; sha256 = "0jpxs82ndrbs3r28951v0p31ngfkhcs0k7plgywyvd1lpkvdm2nh"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm"; version = "7.0.20"; sha256 = "0bcnw653m7w7if6z84rf4k3mr7hdmvnlv4icflk0kc5jd98bkvhc"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "7.0.20"; sha256 = "03107bdy4i9sckpwnk9s497sfq1prl4mccbc3mak43vbnfyqrsad"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm64"; version = "7.0.20"; sha256 = "1lhlaj2ra25jjr6f6rq5rw4wg981h9js7amld10ccyg2vfrswv9d"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-x64"; version = "7.0.20"; sha256 = "1w5r2nv27h3csd5qd3sx2zmf5drrp3ygb519m4hvn5lazyfah5p6"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "7.0.20"; sha256 = "0r002hclq07y275qwj5pq0nxmb6k8h8yglcynpvw8m0pz8d9mr9g"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-x64"; version = "7.0.20"; sha256 = "0msncsn0lz0dvc6clvc4blq8a1bv5qap7qx27fdibdx24i5lsjya"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-arm64"; version = "7.0.20"; sha256 = "13x37m9mdg8pvq1rzcrr4bp5yqaayz7173p39s623n8zjxrh60ww"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-x64"; version = "7.0.20"; sha256 = "1cv1zmkiz114vk0b0spnnczagbcks5k1fb198lc88pi3c9dpfm0d"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-x86"; version = "7.0.20"; sha256 = "0wpf2p1476ns8xd5qvih5llswag133q4s6mj62yzbba890lg5y78"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "02iri99mhfq9awdymsqhg86pg6qfgfig2r2w96jm9lbx4gkg1rgm"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "0g24nr6v86nikikfvg2b3d8im9cp1hib3xiccklbhkpbym3y98dj"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "1dldykby8yfvq7r7kmlg5wi6spy1ngsxbs18ng34lcqjfxjjdnpb"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "07ip7aflkg89gsbfm1w7sgidn4lvc3csrirzkbdv2jhm876bxz2y"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "13pvjwqlacls6hz719lwc6rz0ghs29gxywisldwnwwbm9i6wdnga"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "15qwwdf3c03gs916r3k49wwg411cmrf5xldydkxjjab8pavdlq0s"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "1mjwlxy5gy7k2iil1jcrssqspn3hrpm2dqwghzx9dr61wvpl6sq6"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "0dwpzaasn5044aqm2xix3czfgrwx0y0jwis6p0x8n8jdqyskpim2"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "0ai75b700v76rmqlblxpkwsd97jidfd5kn3jl0y52yq0ylvc4zyf"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "1jkh7kjhaghslhlx6x7w03kdxi1xbrgxwdj9qav0ci7nvf5j00v6"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "0k5skgnss5hknr4r15gxph54zhk65cnglp117gih8qxyzn0245m7"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "1kllpbyldix05ab1pb775ykxwh9lrcji9vqbyp964b8m68r9yf1h"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "0a5gajmkchf2ad3zwmjaa6mw72snf6hrf3xz581mn8qnjjv68whj"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "0xsyd8jvj39z99ga9x26g1fi4zi39pf3ym87fr9102bg5rllj8m6"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "18jp8cykpj40r61ji5fpvfj7yw6cw041l6r4q30am9sj80sgq73m"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "086cn7jilskr7q2hfy810f4hshzhm9r6kvd2kjzvjwf93s0qfgya"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "11y8c16m63kb1masa0x7ympwjg93ffyp4yfycd0fcf0zhzyw00bx"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "175qh1czpm8vs0ifbg3iwgz2cn3v0rvd51g1k81k6j00z9gmhrsm"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "098177bqda2viwzcabsxrpj1p45jqi5fnyfg9xnnw198gh0iskvj"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "180bkmdr4h14a8l2gs9khm835037pw8aqgjz4snx6wxhq7jbdypr"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "0jdvi1pcb3fxqa01633asixs93rg1lfq98vnba018nbqdifqyvf1"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "09can99m6psr9v93awwkahyxq899sg1l6p8gpp4qscqwpil22r4c"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "0idzsi16ny8bjhii6fwjwqn8wmy8x4q2y0zx4d1vmxfx51ym634f"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "1k5yigh196dn961bbvbyy8jfvw8ghmk4da313a304b4m9rf6q5c6"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "1rnpmqmgdw2y9snjj3kp2irg1aggkq2lccd7v4q53ghnl55jdil8"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "0xibpawi6nahdbrdcb71panhx4w5zlmbfxspwmljn2a77sy9caw7"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "07qrpww6nd67xjj3jin97jwiymyxgpm9mdg4raxs9ss0pc05l5xv"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "0dskgn19yhsq28hvzqs422bq64y5gx5cx33m1m3zq8mfycvscnsv"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "0k70cb1lh6j9qg4pjy6r58z0n5xip3l6i6vkgrdx2rqqvpmq2ky8"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "1qr458jrmsb9nijll88hp56msjmvnk20q73x7qypvqlydsn2ap3y"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "1503pddh5klr3z9kpmbxnr4w472v1w8ggh37iqi79z3b0x72zzi6"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "09ddji35a92iq9f4rm5xmz1vi3bki75xskq3iypjbc52ar7wkfl1"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "03338hfl2sb8ca9v3a42b4fgr7qyv3r2khc0ydhif45r0xjx6zrx"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "0lnm29n2z4r7kjwyfa5gbl8qc5nbbc5qkl9kg8vj2xb9mlk5zsmz"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "15ah793265ikivb5iqblcl4x86g4bqgwmhdlhikgv6a18bq32sjz"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "1jnz72f7m292863wvpmm12gwdnqwbvm45br1958f0gkgp0zmhyjs"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "18k3qs54a4x342ypc0p54ch6xwx9wpfgb5f6iyw0i0f8jjxspbay"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "0nyk8x3myh6b0jfka8mvxbhlzl38qiljky8acfkyvw4dzw0y63rb"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "0541ykf9hhc56jin59lg5iw96apcg740wg1hrj0m8dagjll2c599"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "09dlmiqcscdrvjrg9w5mjlz59ly0la4as4hkadz6j4mqvv2k7j6y"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-arm"; version = "7.0.20"; sha256 = "11bcpf986m4wzrln9v4frh63arrg9r3vmv2lq7x338xnrwxadz8q"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-arm64"; version = "7.0.20"; sha256 = "0i07x8kwsifhzkbx1j8argx31g9dxppqwaysn21cd623d16r2g1i"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm"; version = "7.0.20"; sha256 = "0aq01ld9k4064bgki4q4g4fl08i82pnh5xgxaqk3k48nbsbrzvwc"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-arm64"; version = "7.0.20"; sha256 = "18an54s6jldf330ckigig6s1xnadm7zygrlb35qrhawvygbqayal"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Ref"; version = "7.0.20"; sha256 = "1fv6p9idx6g58y0khw7jl23lkwj01l8246mv045i9q6sp3fm9m2v"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm"; version = "7.0.20"; sha256 = "0qfv5w1s5pj3c46jx2g75parx12p40rywacvb7v0fbllj2nvm89r"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm64"; version = "7.0.20"; sha256 = "10d13b4vl5nhk3iqcpbhdhqgwmymzx875w4yq3pwjkcc2vyhg3j5"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-musl-x64"; version = "7.0.20"; sha256 = "1rbl46pfwh1hkbf5djy1khqyiv2fivkgxs0gcnpx0kpx4lncf73a"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-x64"; version = "7.0.20"; sha256 = "03760jw9bbhcg5gmx5z5xjyccl0sv1lzznk3hx2ynwrwg6dhbkyi"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-arm64"; version = "7.0.20"; sha256 = "1gw4wlraqbr5m5w62wyfx7gsvyj92a8h7i04n9jgc6sfs4yfrsz4"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-x64"; version = "7.0.20"; sha256 = "0fcph5pd0myyzzl3ihnvp6wii4vl09ayri5ba12xgixb3qidskgp"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x64"; version = "7.0.20"; sha256 = "1zxpbwc52xsylc6kwk0sqf24cgyv9b2cz9l3icpl1hnkqims9xy4"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x86"; version = "7.0.20"; sha256 = "1jhw9f2mzx8a1bqdiq7ylk8nccwcqa57sd31ykd7lzq1wbhy2r45"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "11l84kx7v6y10kzlsr74kwvvz44wzj476m5mkm2xv2b8pv1z0i7z"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "11xxvyals3q16bzjd7a4gg0nzidsm822aa92yd752jzcxchdn6z0"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "0dg1m80mxvabdkqjgynnws6vlzj9469d5nrjnk5x2zqcsw9kjj08"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "0rdq3z66azlwsak8n8j9jz8pj0lwsvz9f7n6k7x6mlz20wcw4qs6"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "02ymh38rj3pwak3g9qhviv64kqpclcp40paijg7m184y5bli68b3"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "0s9bca6p8j96as25r22vbcmyyhbavkczdk68ypd7qn4g1s44l34w"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "1mi25ilkzw9375lybrmi78g24xzmcz7mnqgjf8y9qvivwsf7ysgn"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "15jfwa5fva8qz6g2gnbxnppd9cfs7r8fspc9xb7n9zgxl7w5n6gd"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"; version = "7.0.20"; sha256 = "1xvhyafgxaraf97s364a3jk5dad4hsssqqvzx4i8qwg36fdijcq2"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"; version = "7.0.20"; sha256 = "1r27bm12x9gwzv0cid1fdzx9hv9bdy6p6a65lypjzvgwfdgnyksv"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"; version = "7.0.20"; sha256 = "039l3qdsz3ima2jgvp8nqby68cr9mvj8q2xd0lmx37drxvck7bx4"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm"; version = "7.0.20"; sha256 = "05zybhb8dc22f934gj3f55xvsfvqizq0nf4d29ns3z9d370jklp3"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64"; version = "7.0.20"; sha256 = "01rrnbwjpy138pra53ypixk3cr528fazjsl3vsrvf6jnymgxlb4y"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "7.0.20"; sha256 = "0g09yyi0a00q9xa51p1k9hvdj20jmy1ss2r2l28zk9s7lwyih7kl"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-x64"; version = "7.0.20"; sha256 = "09kb949p1qc6rz6mf736id8qfsj6dq8azbrpzx19xzpnylqjch47"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64"; version = "7.0.20"; sha256 = "0l76v2w34igvh6i2hgvhfwmkcch1574ylwl1159649pg7c95kj7c"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-arm"; version = "7.0.20"; sha256 = "1jj2mzcn1dd66fic37wnyrvd07fplrsdj4azrvi0qz3qyykc8wmj"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-arm"; version = "7.0.20"; sha256 = "0q8i69qc58kyxzxfz0cqjlbjcz1n3p130nz2q852rvvcxa4644zc"; })
-      (fetchNuGet { pname = "runtime.win-arm.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; sha256 = "09xk16nb9wrsgjr531dhd7mvpqa7b50akmkqrlndyspma7cbvrzn"; })
-      (fetchNuGet { pname = "runtime.win-arm.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; sha256 = "0l82bqvqw5qqhkgrxfscc4dw197b5sh7ic63pymdhixvx0d3fi1h"; })
-      (fetchNuGet { pname = "runtime.win-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; sha256 = "18sarln3kbkqc1ab9jnadcqqxs8iicf7jqldxzbjzhdpmf96vwna"; })
-      (fetchNuGet { pname = "runtime.win-arm.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; sha256 = "1vh3ymhv33qysc4vj4gb3g1rgajy4jr4kxfjcsq2myn96aan84i1"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Composite"; version = "7.0.20"; sha256 = "12w9hlq70ynkrgqbr555lnqmbf67iz3kaci2vi07zsn3mmak3z6j"; })
-      (fetchNuGet { pname = "Microsoft.DotNet.ILCompiler"; version = "7.0.20"; sha256 = "0c966243j6m22hy3n922rl64vi6y1l7ljn69bwydm5clyh7zvn0a"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; sha256 = "11c31fzq4qfxcsz3p6vzdfnaqs29saf1dnmzq7l90p6ylwsblc7f"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; sha256 = "087q3p57snmvvzzqpxp3vwvi2q21kzlk8qh1w6axrcjdci31xmji"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; sha256 = "1nc8m38jsqai934nn26f6dkl3c0r4sabssjiizcixdyypzlv3hcf"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; sha256 = "0iyn0rkf9vf7vbd58xs24209557dzq1dppjb5d35g39z2kh06k1c"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; sha256 = "1b0ys3g3bg9kxxvs1h1kj79b9n9nl2g6hjhmb3c2cpp4slzlsd3d"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; sha256 = "14nq8b869k43chsn4ba3b3ww9w25fip39ik8rfxa1z8l5k4k6xb0"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; sha256 = "1gajqvzf18p0jppvcwky0shkmw4nzwz8hzx4kwblrs41d8xmw39a"; })
+  commonPackages = [
+    (fetchNupkg { pname = "Microsoft.AspNetCore.App.Ref"; version = "7.0.20"; hash = "sha256-OEDXXjQ1HDRPiA4Y1zPr1xUeH6wlzTCJpts+DZL61wI="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; hash = "sha256-9eXw5iN90VSlSVxk8aJ7Dpt3DXoQ6+obVwk7WFOKOQo="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.App.Ref"; version = "7.0.20"; hash = "sha256-W9RU3bja4BQLAbsaIhANQPJJh6DycDiBR+WZ3mK6Zrs="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetHost"; version = "7.0.20"; hash = "sha256-sqHkR/XrTrjoZCz2sSIMl6UaURtLvO1mnNEatE22RDw="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; hash = "sha256-69omZXcSM0rGsyjo1fWzwV9tIi+P1nnywdt55Nf0jbY="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; hash = "sha256-Xvy+zEEVSrHbmj/HrNlgmxLb4tOHh+qWfgm9SZ06Nx4="; })
+    (fetchNupkg { pname = "Microsoft.DotNet.ILCompiler"; version = "7.0.20"; hash = "sha256-Ctj9D/SUldo8X8lYSQ8N3sRNDM1CJDs8FKIaOYgwJjE="; })
   ];
+
+  hostPackages = {
+    linux-arm = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm"; version = "7.0.20"; hash = "sha256-49IpwRkt/aFtEo04C/CPeDu9eyluyEdGckKwhhZc/hc="; })
+    ];
+    linux-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64"; version = "7.0.20"; hash = "sha256-nizaX/VWGrez3oNq+ZVDomQ2Zo/Xj6LyRSP4K/myOQc="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; hash = "sha256-7jC6NKfeXJDowb/aFpzSSWisrGt/mzu+Zt1hgr8Lg4U="; })
+    ];
+    linux-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "7.0.20"; hash = "sha256-dB4YPadHp/mRoCILrYOvEgjZNkwz3FBUTxgABaL3CTw="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; hash = "sha256-LEwD4BQ/jVdGK0ve2wL+7ZSSgCBCd1Ta2sft5GYG1kc="; })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"; version = "7.0.20"; hash = "sha256-AjMZmzPjcYwi6X9jrLWGpKlWphyKmKFPciqr/pzycPc="; })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"; version = "7.0.20"; hash = "sha256-W09vX3P87S+vp8Uoc41vK22Y+m8utMjA/vylLkJdR+Q="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; hash = "sha256-UdYeRmRNstyV4QFiNOmfQWARN9/j9ov/37tafcod+CA="; })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"; version = "7.0.20"; hash = "sha256-pK8z2e65ndErBa0LjOSuKTNk/MIW3f2kUDWOrxseNA0="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; hash = "sha256-jsGx6b/etx7Zj1FqvZQmGbBBZzPOCGvJSFFhLdGoiNk="; })
+    ];
+    osx-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64"; version = "7.0.20"; hash = "sha256-7MhZEjvvJmJSCYFy6skpATI2K3dwPyiigftFMrjY5lA="; })
+    ];
+    osx-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.osx-x64"; version = "7.0.20"; hash = "sha256-h0AmMfX2/p5C/zevrxBuRmqHUYtmHFfNz4bhcBNJayY="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; hash = "sha256-bTRNP9XkXibYWBVKaJ6gNtm00pEzwKB37zO9Nd7QHqw="; })
+    ];
+    win-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.win-arm64"; version = "7.0.20"; hash = "sha256-dXex6q5gQcBJ5Xccf27GxrTAvTlJyTC5i9Ln0IWBjJA="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; hash = "sha256-YHUzySwU/aC6y2jGNG50RfDE+VhDLWI1ZIPMZNBC2JI="; })
+    ];
+    win-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.win-x64"; version = "7.0.20"; hash = "sha256-5nZu1DgEqIy5HufEOE/4wyXuVyUWSozmpMh/+kqt95A="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.DotNet.ILCompiler"; version = "7.0.20"; hash = "sha256-Kg1eO2qB6EwXn6R/iD7/lvA6oQZ+crbvleCi4P7GUr0="; })
+    ];
+    win-x86 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.win-x86"; version = "7.0.20"; hash = "sha256-T6M4ND0K6i9CI5g08rgaPpECR2968YsJ2+2N2FsKYz4="; })
+    ];
+  };
+
+  targetPackages = {
+    linux-arm = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm"; version = "7.0.20"; hash = "sha256-h4AheC6chrmBEjSK78h9yOpNXYoQSlDI1CGoc7KhYSk="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-arm"; version = "7.0.20"; hash = "sha256-1F5YHSdEbiyGc1xV354GMoZPMuchTwDc3eauJc2RyDI="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-arm"; version = "7.0.20"; hash = "sha256-DO65UGqysAkmdSySTe2uDZ5cxyQuE/SNi4efOorhli0="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; hash = "sha256-zn/CNvUAe1E8oHLYWZprUZ7UNJ+300VxzeZsAM4qJyo="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; hash = "sha256-ZgMgi9v2RAa2wkk23l9ePcTe5gD8dNMppBo+BeU8cMo="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; hash = "sha256-pxYigP2+YwTjOyFc+iwrZsJPCrz9lZBJthMWre2bukw="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; hash = "sha256-MDifMjIVLWLS9QvvFCXLNEHepy/nrBuWKqDHRv26lM4="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm"; version = "7.0.20"; hash = "sha256-OaG6rZCULgf2WZsp7jMgV4Se1S3niS4NYUPeogMv22E="; })
+    ];
+    linux-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "7.0.20"; hash = "sha256-ewal9R6o20GV0R02ylSijVFdWZAbdN8TK1PCc/ltHBQ="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "7.0.20"; hash = "sha256-/20dMbO1Ft0WVhl+Lv1916Thvr4kPP9LuuX4bKE+czE="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "7.0.20"; hash = "sha256-TemMvbNrDzJVHWwxVgnNN2CnTyI6TcvvZDpF4ts6IAw="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; hash = "sha256-6tnGTUx1cW55ozpy318SGj7ws2GcpnA+NJoyRTGX+44="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; hash = "sha256-GmDatrpoKSn7bL7RXlyuLATyOE9kjmxC0m8ANlzjHJc="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; hash = "sha256-BmtD7+bB5Jb6h4/jJurNcNirsdaZyUBjFPP4V3ynXNY="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; hash = "sha256-osY7tcdNIos6uEZHLoEHnefnPhs9dlGxIgQUq5X6lzc="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm64"; version = "7.0.20"; hash = "sha256-RY4H/RaMTcnvwJ7wclD/1Vf+MGxwXYbjmNAWuskaoYE="; })
+    ];
+    linux-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "7.0.20"; hash = "sha256-vq59xMfrET8InzUhkAsbs2xp3ML+SO9POsbwAiYKzkA="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "7.0.20"; hash = "sha256-Y1Dg8Sqhya86xD+9aJOuznT4mJUyFmoF/YZc0+5LBdc="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "7.0.20"; hash = "sha256-L+WaGvoXVMT3tZ7R5xFE06zaLcC3SI7LEf4ATBkUAGQ="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; hash = "sha256-wW2PXWx4WRSAWnajhB0NL4+ke9RqDBOAwt2NxW6Iu0k="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; hash = "sha256-jGQhaLwcM43JvQ9dQ8PTKSHcPVSTczXSTllfU1OyiiU="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; hash = "sha256-jgxTfSjd9bpDI/0DLzDpyFeOLOaSOxMjlAt5a0LUv0U="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; hash = "sha256-hhVsXE6VLAKGGmGoRmaFD/HtJPJ+7bWCSbaZFOCLvsw="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-x64"; version = "7.0.20"; hash = "sha256-0c8Fm3k8c+tFh2Pa/2nYGlDGvOzll15feQyulbgE5gw="; })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm"; version = "7.0.20"; hash = "sha256-fBn8P8fAtg49BnMI1Z8XBMwPqQNcH7qQOERctMfvBuE="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-musl-arm"; version = "7.0.20"; hash = "sha256-GP2mOs+2ozH6wVTsukdOL2c1DMyO7GRp/pxUg5K7bIU="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm"; version = "7.0.20"; hash = "sha256-jO+fl14WkTkmVv31Au0VKCJAHXkEkzjfIgaQmRoNACs="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; hash = "sha256-/0Tww75oid1FnbVUc4j8nJC/N5/kZE3/BMGbffokiIY="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; hash = "sha256-4BvbIOvsS1FO8yIpJQSqusVvwXtEnSb/MgEPTZXfvYc="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; hash = "sha256-CEg5E9cMf9HLtDLb0pIhSX66jebW+ifxbEvtXgGq4TU="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; hash = "sha256-RmPCGQfi02r6mcYel/7WnAJ50ZdJIoum0px+ZcwfuGU="; })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64"; version = "7.0.20"; hash = "sha256-H+de/nhNSKXug7pXxceJ6/dqk6oPx0Ft0ag72lk6JnI="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-musl-arm64"; version = "7.0.20"; hash = "sha256-dWlAyHp79GyqQmhOBOC49CW0rBCbrKtTQKErE5sQ3wk="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm64"; version = "7.0.20"; hash = "sha256-LW2us9viecZAaLSqo2WCAaXHCc8FZ+NMlrIIlYVUFNI="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; hash = "sha256-EnJktpQWI1sDKr8Pl6FxVovDq1FKVv5HU8JBNqtUryg="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; hash = "sha256-piJJaS5vCRBSdgdVP9xNI34SXXhG9KReSj8NuSVqXnc="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; hash = "sha256-dRz8NEBSp6rAwCQbGgjgzHB/pNvXlSiDyYDIOz1DV6I="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; hash = "sha256-yj+HgR7Jcbm/nKLtaXKq8EMNiQMBeQcFPnlqGuWxzCA="; })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-x64"; version = "7.0.20"; hash = "sha256-Zhe1PbrJ7MRVFgAgcGyapLuArirQjLSPOKmqdnpG8S0="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-musl-x64"; version = "7.0.20"; hash = "sha256-XbLOKo0ABmdTOM4uiyXdoy2Ak3SRbOkmtgxtcl0Wb3M="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-musl-x64"; version = "7.0.20"; hash = "sha256-5haonP+KFrshqSmU9fy4Obfi6hddj4ZL02zAI7YVufA="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; hash = "sha256-fQHA/YcfOOZAY955cr1zIz3Jb/WnA6VVDWsOU01gyIc="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; hash = "sha256-VWdYX/oASDMDmuGF0nYGe1gm/uNxvOUi0BvV+1mAuJw="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; hash = "sha256-ck8dAXwoBW5tT89560rEspAb5M1dL8U+j1uohtc5ASU="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; hash = "sha256-+fq25MGwc9OtJl8+rBC/Z4AyUIUz6ScoUiRAkludC6A="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-musl-x64"; version = "7.0.20"; hash = "sha256-ahzHLCX9TtCvZQ/o/uaOTuzoMZzBy1bcmjBA7q4hdOU="; })
+    ];
+    osx-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64"; version = "7.0.20"; hash = "sha256-PHBb0AuRpB8kkQvQJIJSLu5Ub/U2pYA0wMGBarUkS8o="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.osx-arm64"; version = "7.0.20"; hash = "sha256-MTyRTWhDmMaCsNorju/tLb0w+ssKydDX/NBFzSfqB0Q="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.osx-arm64"; version = "7.0.20"; hash = "sha256-VHmF1/ObK5hxGYvm5/+pTdketHnxxcnAGK5RaTQpVqE="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; hash = "sha256-YyET6SqeoFDPk1FdQC6j7OJJzI4b4vTGVPwOmdGA1Qs="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; hash = "sha256-nAxKiA6PWHza9cjM9tncakHvK1tbiFyEViZJdI1iK2k="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; hash = "sha256-9ml/nOY7bpw8cvJhW89n9XciHjqx5uVpOSPxP2ksItY="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; hash = "sha256-7Rlb+KH9/WTP6old7VA+2rHU7rV92See+Rip7YriTpY="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-arm64"; version = "7.0.20"; hash = "sha256-5OvsPNFOG/ZksgTEA5ESSfqt3+nOc2F4qSUvrDLlhL8="; })
+    ];
+    osx-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.osx-x64"; version = "7.0.20"; hash = "sha256-+MQMRFzfG2CbNJnfw0buP4VorL2yR+T4UeEBSbKSmPY="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.osx-x64"; version = "7.0.20"; hash = "sha256-DdumMpP5QN0rPDsB8sjxACM13mT7Wbb0w3LaCe96twc="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.osx-x64"; version = "7.0.20"; hash = "sha256-yktNSySitxWbO6LjcxUuewWFMF2EbcoM2w18CqxmVlc="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; hash = "sha256-iMYmS6EWvlEw2acxRgWe76nwchR3DimtTl7w9iqu1+Y="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; hash = "sha256-hyuWvD5HCStp5Vd3tyr9hZMOrbrhLNbyalBZE7m6K3Y="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; hash = "sha256-uxdaALtA66S7yuS1mup93VcfuTzJRjmk7Mc0azi/GR8="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; hash = "sha256-W1umN/OuIvxHDXWMzkp/xRODlxBE478hElhDn4J9Uzc="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-x64"; version = "7.0.20"; hash = "sha256-903dIh6rx9dFUKvE7FUCdJMYubnbwjjo/95X0G6Blzk="; })
+    ];
+    win-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.win-arm64"; version = "7.0.20"; hash = "sha256-/hqNukz6YVNNcsRz4j4o/YMZOvLJ7QGOo1mdYp5oVVA="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.win-arm64"; version = "7.0.20"; hash = "sha256-h1zjOeQk1iTdX9lfiZHhnT+q6ntGLR+gGCfmu0giv5Q="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.win-arm64"; version = "7.0.20"; hash = "sha256-nAMDc5cf2SGMTuOOE873SmFf7iI5s58D3he9VlM9o48="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; hash = "sha256-yE+B690YZ9FbfnObaOi4sRcLPirZeHnJw0kaSMNi4Ew="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; hash = "sha256-flwlrG6e4n09Pn0cDMS0u0pdTbkQIUpltGnpmiUqJOM="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; hash = "sha256-Jv4vTgdr/HQijmfA9xAPWxzCSbZ91TvTH5nOAlu7A5Q="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; hash = "sha256-gbrJT1aisCWvjwNP3cuJc424w6+91ExcwlEkVUaUrSU="; })
+    ];
+    win-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.win-x64"; version = "7.0.20"; hash = "sha256-lLn+6JAmx20z3Ghvxr9Lb4gtF/bFOEUPa8WKagHrVuQ="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.win-x64"; version = "7.0.20"; hash = "sha256-EWoLS0ygXAaUk7LPrMpaJazIQ6qGZVHblUX0tAB6NQg="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.win-x64"; version = "7.0.20"; hash = "sha256-DVR3W2IjXoQYRSksF2bRk62nPrP2arDA3CSEH2f9YbM="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; hash = "sha256-PX/TZQe5EBdh84DBKfLYHp/8HFmCqLGTYmhpQR1EYww="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; hash = "sha256-v+pfJq1pdSE3ejPRiQtbyxaGEV2vKOe5nCeTL2wS1VI="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; hash = "sha256-X2ox8EJBmf1mhLTByh9e5BnUCWV04VjWjjMWI0Y6UJU="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; hash = "sha256-WnpYP7hvPuBQSSGvQupeHNvGnwi13s2HQSKJepw438o="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x64"; version = "7.0.20"; hash = "sha256-xPeka8TTwkAvi4Omz8RK2z9GhMMaTD4No153URhft/8="; })
+    ];
+    win-x86 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.win-x86"; version = "7.0.20"; hash = "sha256-DBXJXKjkty9sR1xOfgQZrmPxuZegn/VmU5WjMab5Ddg="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.win-x86"; version = "7.0.20"; hash = "sha256-0Ira9rw0tO25f/SeCTSD0z0bxgU7lIREHnrlZgXS/Uo="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.win-x86"; version = "7.0.20"; hash = "sha256-6PjyKEhIrfW9MLIaTfAY4SmuKS0wblxaR9qaQ8IV7nI="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetAppHost"; version = "7.0.20"; hash = "sha256-Xq2ru5TIgQi4j8aV9dzlqfNuICPlAna9IKMTRYrGY6I="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHost"; version = "7.0.20"; hash = "sha256-Kw/jAf+N8O2nYwr5KWnEaNBP4eq7IjWdBMtAX0dH01s="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.20"; hash = "sha256-KRUmKJVPNVSBzDA8Dsh57CqTeCyPpmKjNIVBmNz0gRQ="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.20"; hash = "sha256-3sgzxd64Eml+UxMSrYiiwNNUPpW18PSy3LkxzXCstCU="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x86"; version = "7.0.20"; hash = "sha256-hWTh4eIBf3ra9GE0fYrCjDNm0aT+4NjwCgr1X4VLHMo="; })
+    ];
+  };
+
 in rec {
   release_7_0 = "7.0.20";
 
   aspnetcore_7_0 = buildAspNetCore {
     version = "7.0.20";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/09e67261-215a-4003-bcf8-f90d67dcd02b/b32cf12a5c10b1f74e21c8cb03880891/aspnetcore-runtime-7.0.20-linux-x64.tar.gz";
-        sha512  = "62ed9743972043a72e48d5aa2f7fdf3483cf684a32b051315004d1c778e9712bf66e5e7a97a5a53993fa8e92daf5bacaf2cdb3eae44bb9a9e25532b9a80f4f70";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/7e8680cf-0baa-4957-99b7-81395b8ff60d/5a9c578ff9aaefc7ed77e63b6a90dc03/aspnetcore-runtime-7.0.20-linux-arm.tar.gz";
+        hash = "sha512-6Cuw8dUtkf6mvtQZoYVhKC7Q6d425WTmQeKWyRf39l/HVVzMBG/tZ1rWe058UKcPD0joVZ/08qm7rSvGLc9qsw==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/ae3027ce-cadf-4510-a1aa-125958cf0432/c3d958ba80ec21e9d75ca5e8f43ec2d3/aspnetcore-runtime-7.0.20-linux-arm64.tar.gz";
-        sha512  = "dfb1c1bef4d826defd3d995599a5c03e1bf1a64c65d98b675d6c05dbb7380d98233953e68d53fc5ebec60ad4ef75417073fb1fb3256a0176bb964f0e01161f6c";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/ae3027ce-cadf-4510-a1aa-125958cf0432/c3d958ba80ec21e9d75ca5e8f43ec2d3/aspnetcore-runtime-7.0.20-linux-arm64.tar.gz";
+        hash = "sha512-37HBvvTYJt79PZlVmaXAPhvxpkxl2YtnXWwF27c4DZgjOVPmjVP8Xr7GCtTvdUFwc/sfsyVqAXa7lk8OARYfbA==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/65fff3f3-1b87-42aa-b1f9-04e7e318c1af/4bfbb002455b9a037e75791e99a18c19/aspnetcore-runtime-7.0.20-osx-x64.tar.gz";
-        sha512  = "00677819450d14d9adc2b65f25b9a069bc2b43f72e4db651e77fe0e48320be8eb7c555277281de968e75d0fb19bef960d4dcb27161b8c57bce076ee18bb5ca98";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/09e67261-215a-4003-bcf8-f90d67dcd02b/b32cf12a5c10b1f74e21c8cb03880891/aspnetcore-runtime-7.0.20-linux-x64.tar.gz";
+        hash = "sha512-Yu2XQ5cgQ6cuSNWqL3/fNIPPaEoysFExUATRx3jpcSv2bl56l6WlOZP6jpLa9brK8s2z6uRLuaniVTK5qA9PcA==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/2833b957-8fb7-45fa-bf85-4960260ae344/fa4678e8c3ceba67771b5195a2343049/aspnetcore-runtime-7.0.20-osx-arm64.tar.gz";
-        sha512  = "7de161ea45faef7693d78ca44b585ab73fc183232d3f8d229fde3d05d696818d8d6402ac7ac86ce239a0a6cdae8fc2eafbb445e99443d0c7a4aab3781df35be6";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/40131679-906c-4afd-90f0-576fbed036b1/85a0c856077ad82c29350486ebdb912d/aspnetcore-runtime-7.0.20-linux-musl-arm.tar.gz";
+        hash = "sha512-yoTg7/BS1Ft/qa/Ypo8dViZBVbUHiBEF0gaWmSIFe/MyiVo8OioXAmSORnEvAiV02Trhh8j9JhD4OSkJVoq/Vg==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/6ef9e16e-9a83-401e-8ef5-905ef374b768/725507d68a8bc4a4297e2c82bb1d06db/aspnetcore-runtime-7.0.20-linux-musl-arm64.tar.gz";
+        hash = "sha512-ZUBuFxSjEX2qNCs/0NvNXDIUMVYR6su9hYCCf2mgepSAUwMgukBpKj1tv/gy2SmhQgB58dswyj/Wem/QNRSdBA==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/a3f5953c-68f8-48e1-91bb-0ca62199e6db/b3d7a2de0488fd63fa286c3fc371d68f/aspnetcore-runtime-7.0.20-linux-musl-x64.tar.gz";
+        hash = "sha512-qA8xGTr3DVVujQJtOdeYY8g4mwZf4HeOe0Ng99H202UDulJzbEDnSnFsPDBQCxhYFu1g15sGrilXVLZzdKH6RQ==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/2833b957-8fb7-45fa-bf85-4960260ae344/fa4678e8c3ceba67771b5195a2343049/aspnetcore-runtime-7.0.20-osx-arm64.tar.gz";
+        hash = "sha512-feFh6kX673aT14ykS1hatz/BgyMtP40in949BdaWgY2NZAKseshs4jmgps2uj8Lq+7RF6ZRD0MekqrN4HfNb5g==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/65fff3f3-1b87-42aa-b1f9-04e7e318c1af/4bfbb002455b9a037e75791e99a18c19/aspnetcore-runtime-7.0.20-osx-x64.tar.gz";
+        hash = "sha512-AGd4GUUNFNmtwrZfJbmgabwrQ/cuTbZR53/g5IMgvo63xVUncoHelo510PsZvvlg1NyycWG4xXvOB27hi7XKmA==";
       };
     };
   };
@@ -148,21 +210,37 @@ in rec {
   runtime_7_0 = buildNetRuntime {
     version = "7.0.20";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/2c5981ff-0f0c-47ab-bff4-0ea4919b395b/cbfdfa7f35d133b0bdef87fa3830bfa0/dotnet-runtime-7.0.20-linux-x64.tar.gz";
-        sha512  = "87855297338555a7b577d7e314e5dbf2c2350f8c867a489cd1e535634bad5c123a1871464d37fc9421837ff5d426c2eadecbe0f60bbf3fd32bc2461f47790a40";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/06e8869b-e332-411b-aea2-7e29daae6953/6b8f60cbb630acd5d94219faa15faf6f/dotnet-runtime-7.0.20-linux-arm.tar.gz";
+        hash = "sha512-okqnr+R45ir052xA5j5eXoMkqwHZrZz/MYMkXN63CGH/wRjJq9qfLy/tQjc1yieqwVvsjMX8NS8FvVtyYmWEmg==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/af6e12de-a63c-449f-b35b-b72ec6ee3da5/ae129eca3d734117d14cd5965dca93a3/dotnet-runtime-7.0.20-linux-arm64.tar.gz";
-        sha512  = "c245125ee2708252119a1544556e1aa9e00aa18b2303de69877da10c6c17e3f25024b749ca93b53be76ee0e8e4a75d403f7019b8bc2e50ed1278f656cb2f7e06";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/af6e12de-a63c-449f-b35b-b72ec6ee3da5/ae129eca3d734117d14cd5965dca93a3/dotnet-runtime-7.0.20-linux-arm64.tar.gz";
+        hash = "sha512-wkUSXuJwglIRmhVEVW4aqeAKoYsjA95ph32hDGwX4/JQJLdJypO1O+du4Ojkp11AP3AZuLwuUO0SePZWyy9+Bg==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/cbade9d9-be1e-46c0-9f90-13ba882965dc/31c86e8f4beaf0e5ad9ad35a408be7de/dotnet-runtime-7.0.20-osx-x64.tar.gz";
-        sha512  = "acdcde92f2f2e43584ee59be447f778f4a152c308975c7bdc5c2372b5bbd3092eb9d2233aec3b82756ba1e352a0877ffc17e4c8cfb20a9de91ca6db54d79b591";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/2c5981ff-0f0c-47ab-bff4-0ea4919b395b/cbfdfa7f35d133b0bdef87fa3830bfa0/dotnet-runtime-7.0.20-linux-x64.tar.gz";
+        hash = "sha512-h4VSlzOFVae1d9fjFOXb8sI1D4yGekic0eU1Y0utXBI6GHFGTTf8lCGDf/XUJsLq3svg9gu/P9MrwkYfR3kKQA==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/50dbf5c1-942d-4fd8-b646-1f024326ec1c/5fb99e9dae294298a8131757b3ea829e/dotnet-runtime-7.0.20-osx-arm64.tar.gz";
-        sha512  = "af1cb62e29c69648ebe334e651c2703cd5e87fa0bb28c670bacb3b3dd1608aeae35ae53402c5eb4ed8bf34abd831a08ccb5ef84e5ec70617d9f8d9969fe7b8fa";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/7d1ca778-4415-451e-873a-dc4062d8d9a9/f38f41e5784c0832e24fe18a938ed5e5/dotnet-runtime-7.0.20-linux-musl-arm.tar.gz";
+        hash = "sha512-JczDc9HEwOt0HgSMb9SDZjELNqxvBoxQ9rwBNCoABGQUToRX5+G2zPbZlUTUkUAi78uCTnVjZRe79hyUhSzddA==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/c30b2e10-7c18-447c-b66b-47bf12f88692/0d5fbdecc6b2cc86fd2f43ebfffd7aa2/dotnet-runtime-7.0.20-linux-musl-arm64.tar.gz";
+        hash = "sha512-VSynNGf4BD01HCDXHflbqWOzLox1cG329dP85SXz798TFN8pbET77a1VdXguN2M5mKebLCP390IPgU7iSI8wog==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/3297a5d6-9f41-4098-9597-c1b966c19983/46559d0d813b36264fb414562caca171/dotnet-runtime-7.0.20-linux-musl-x64.tar.gz";
+        hash = "sha512-MbnaCNYzzQAo6wjDbuLFw8sb5tPF4BDIWuKRSW/l6Bi1vln11Hr/hu2TnCYPdi5X/waTSk0JVDdpNbGtx5nxvw==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/50dbf5c1-942d-4fd8-b646-1f024326ec1c/5fb99e9dae294298a8131757b3ea829e/dotnet-runtime-7.0.20-osx-arm64.tar.gz";
+        hash = "sha512-rxy2LinGlkjr4zTmUcJwPNXof6C7KMZwuss7PdFgiurjWuU0AsXrTti/NKvYMaCMy174Tl7HBhfZ+NmWn+e4+g==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/cbade9d9-be1e-46c0-9f90-13ba882965dc/31c86e8f4beaf0e5ad9ad35a408be7de/dotnet-runtime-7.0.20-osx-x64.tar.gz";
+        hash = "sha512-rNzekvLy5DWE7lm+RH93j0oVLDCJdce9xcI3K1u9MJLrnSIzrsO4J1a6HjUqCHf/wX5MjPsgqd6Rym21TXm1kQ==";
       };
     };
   };
@@ -170,70 +248,118 @@ in rec {
   sdk_7_0_4xx = buildNetSdk {
     version = "7.0.410";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/0ddc1522-2361-4394-97e9-52318bf51951/c5aef30601a86810f1f8ea89d42c26a0/dotnet-sdk-7.0.410-linux-x64.tar.gz";
-        sha512  = "20b8e02979328e4c4a14493f7791ed419aabd0175233db80cd60e2c004b829b3e8301281ea86b27ba818372473accf5a6d553e5354c54917c8e84d25f5855caa";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/4b1d565b-7a3d-4e7e-87ad-7c662ec59020/4c6cb8a150efb42f7cea7e0b4c2f61cf/dotnet-sdk-7.0.410-linux-arm.tar.gz";
+        hash = "sha512-lbY5oUddm3Y31BoUwMqzmTs6K0vmPb8lH/74QEYcUdnV7NeO8JyFf+KDmRVfekBEngjHozzgiFDE4Y76q6tFrA==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/3e408891-74af-4ccb-9ce8-895f6806a97d/3a589bbf6e264059544cef47be672540/dotnet-sdk-7.0.410-linux-arm64.tar.gz";
-        sha512  = "2db6a3b9a532d2f59a2b459e634206913a9585c821f3f578a421e3bae346a92dd9b85b76ebde343ca3057275f7ec4d0bca71cbb7f2badb6dcdb516244e84da46";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/3e408891-74af-4ccb-9ce8-895f6806a97d/3a589bbf6e264059544cef47be672540/dotnet-sdk-7.0.410-linux-arm64.tar.gz";
+        hash = "sha512-LbajuaUy0vWaK0WeY0IGkTqVhcgh8/V4pCHjuuNGqS3ZuFt26940PKMFcnX37E0LynHLt/K6223NtRYkToTaRg==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/fc8614cd-f333-4adb-815a-9bbd07e02b16/0ccf5e50cf8fa5c600716395e240aff1/dotnet-sdk-7.0.410-osx-x64.tar.gz";
-        sha512  = "782e15c19ce20aa8333566f23c2d3cdb8e89c7626de6330ddf670c4426e30cc854e44ff3341578622aecf210fa66ddcb63a7d2ad629ed92cb5582ab670f953d2";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/0ddc1522-2361-4394-97e9-52318bf51951/c5aef30601a86810f1f8ea89d42c26a0/dotnet-sdk-7.0.410-linux-x64.tar.gz";
+        hash = "sha512-ILjgKXkyjkxKFEk/d5HtQZqr0BdSM9uAzWDiwAS4KbPoMBKB6oaye6gYNyRzrM9abVU+U1TFSRfI6E0l9YVcqg==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/bfba06ea-d182-4a12-8066-fd78413e6cc3/f7940d1e8d8ae641a3a3d65b6bfa1071/dotnet-sdk-7.0.410-osx-arm64.tar.gz";
-        sha512  = "c0ef1914f2b298504433bca9cdab02dcf324421ece39657b66523f13b7a7166e726783673a602fb462f3db5c53f59a89381b918e7658d49a57763b43cf75cedc";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/fb542b02-38a4-4564-bc66-d7822758cf1c/d18f1e24ef1b3cdb4ef10bc641ce9a5b/dotnet-sdk-7.0.410-linux-musl-arm.tar.gz";
+        hash = "sha512-x7Gc3yExJkVv5/IBcf+/XMQXcjBbR9jQbGRhKlCeiRMSZAXKjqW2T5P/TSz+op+hKGcdQO8jrWadi0coIjjfwQ==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/7e1f9446-53ee-469e-8dde-cc307306ac61/bce850d1c118b4b6dcf9f808b22a8a54/dotnet-sdk-7.0.410-linux-musl-arm64.tar.gz";
+        hash = "sha512-O+6089U2DMm8Fzm2kCj1grZqajhMlmj/EqD9ucKfktx1e3sXs9/MgeVQP5razNe56lSQ+OFinN2Y4bRZKbaS3Q==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/6d16b077-939f-435d-8f2e-11813d76db6b/ba4829249b04d6c818bc175846e694b5/dotnet-sdk-7.0.410-linux-musl-x64.tar.gz";
+        hash = "sha512-Y0W6gTmvQteoMwtaXhfHGz4GgGZWEAbGi/4r+1wavSiS8NkD+3rrwqU22Ee8End4DNZR+lMTMMFvowKgdstUFQ==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/bfba06ea-d182-4a12-8066-fd78413e6cc3/f7940d1e8d8ae641a3a3d65b6bfa1071/dotnet-sdk-7.0.410-osx-arm64.tar.gz";
+        hash = "sha512-wO8ZFPKymFBEM7ypzasC3PMkQh7OOWV7ZlI/E7enFm5yZ4NnOmAvtGLz21xT9ZqJOBuRjnZY1JpXdjtDz3XO3A==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/fc8614cd-f333-4adb-815a-9bbd07e02b16/0ccf5e50cf8fa5c600716395e240aff1/dotnet-sdk-7.0.410-osx-x64.tar.gz";
+        hash = "sha512-eC4VwZziCqgzNWbyPC08246Jx2Jt5jMN32cMRCbjDMhU5E/zNBV4Yirs8hD6Zt3LY6fSrWKe2Sy1WCq2cPlT0g==";
       };
     };
-    inherit packages;
+    inherit commonPackages hostPackages targetPackages;
   };
 
   sdk_7_0_3xx = buildNetSdk {
     version = "7.0.317";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/3207f51e-26ad-4d43-9249-5e03e93e5895/af409554ce918557a05f8e8102f199ea/dotnet-sdk-7.0.317-linux-x64.tar.gz";
-        sha512  = "906ecbfa31b10ae5e2a8ba713d113ccd83e3a9b9e4d3e322482692891542959e76c51db5dd3825fb4a2cf1e951737006a99be7290f309d6822567d3a533a7a9e";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/8aacc3f6-bf06-4cb1-ba10-ea76c29bf550/7c657ce9fbaf35843a30a34a7ba0e3c9/dotnet-sdk-7.0.317-linux-arm.tar.gz";
+        hash = "sha512-S1DHTRWHGrRc9/0Bb6BR8Dg/AJX5G07ycQUCgY4vn2kCO00A1YTvd9gYeujpWo0pI7PQPr4qP/cKkQntEvdI/w==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/e08e38c2-46b5-45ba-b318-6b0949b3cc2b/1780549adba82e521439b7a0511229ef/dotnet-sdk-7.0.317-linux-arm64.tar.gz";
-        sha512  = "22badcdb2cba0f1bedb1fcbdc99269a66a01a232193e00b42823806cee5d46194b8dd008a53e17455072a410f77bd351676f351670be96c13572d8e30cfad180";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/e08e38c2-46b5-45ba-b318-6b0949b3cc2b/1780549adba82e521439b7a0511229ef/dotnet-sdk-7.0.317-linux-arm64.tar.gz";
+        hash = "sha512-Irrc2yy6Dxvtsfy9yZJppmoBojIZPgC0KCOAbO5dRhlLjdAIpT4XRVBypBD3e9NRZ281FnC+lsE1ctjjDPrRgA==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/c03db249-372d-404f-8767-dc7e4a104ade/49d2336dc14b70dc937d8f91716e4fba/dotnet-sdk-7.0.317-osx-x64.tar.gz";
-        sha512  = "d3dbd0fe7cbc62388f150adba5d818abee3986863d757ce63088f4feabf801052c08a608acd5036f97191435fe99224acb12c7365be7f77def28553a231ac3c9";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/3207f51e-26ad-4d43-9249-5e03e93e5895/af409554ce918557a05f8e8102f199ea/dotnet-sdk-7.0.317-linux-x64.tar.gz";
+        hash = "sha512-kG7L+jGxCuXiqLpxPRE8zYPjqbnk0+MiSCaSiRVClZ52xR213Tgl+0os8elRc3AGqZvnKQ8wnWgiVn06Uzp6ng==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/697b6485-989f-48d7-86ac-320529a85b35/5b5ed55e7e4e2c0a1ba2c3e0cceefe95/dotnet-sdk-7.0.317-osx-arm64.tar.gz";
-        sha512  = "b5f367e1e20d728d7167c81e4146358e760f136b9ee0fc410d813c14366e38b09a069031aa8ca6d8df438435b6ab4e2e989be309e097169459365d4befaf9f5a";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/6e895738-571a-4d6f-8519-0d64ad4a95d2/75c8734c8f3dee31dca0591f7634b4f8/dotnet-sdk-7.0.317-linux-musl-arm.tar.gz";
+        hash = "sha512-fKoRN8pHJHGrlZ3s634+KCigjbX7Dhxrlz8kcKHLbIv60zLMrDH2bhGYLkc6/4KAmzX6XANkF4J66DcTe+NPOQ==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/2df5854b-e405-4191-a794-8c24ddb9b95b/b0c9ac55d4f324aa81bb5918e115347c/dotnet-sdk-7.0.317-linux-musl-arm64.tar.gz";
+        hash = "sha512-7US11MyzefQoaSLiJtGC5eubwS9M7bYALwbleUt5XT6/GajlqOmQxFfff566mUe8HHIQr2qN/yxnItZMnmHwQA==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/9141d472-8ae1-46aa-8218-190017c16ed6/7877e0accaa6b6800570f7b46a831c97/dotnet-sdk-7.0.317-linux-musl-x64.tar.gz";
+        hash = "sha512-Wn1fIXAQs1QfqdC9tD12lJaFW54RQ4TPZ4jtR3G4NUZqsYeMU3nIkUk7VLh8FHB3j1CTHFpsiZr2E0gZO7lj1A==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/697b6485-989f-48d7-86ac-320529a85b35/5b5ed55e7e4e2c0a1ba2c3e0cceefe95/dotnet-sdk-7.0.317-osx-arm64.tar.gz";
+        hash = "sha512-tfNn4eINco1xZ8geQUY1jnYPE2ue4PxBDYE8FDZuOLCaBpAxqoym2N9DhDW2q04umJvjCeCXFpRZNl1L76+fWg==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/c03db249-372d-404f-8767-dc7e4a104ade/49d2336dc14b70dc937d8f91716e4fba/dotnet-sdk-7.0.317-osx-x64.tar.gz";
+        hash = "sha512-09vQ/ny8YjiPFQrbpdgYq+45hoY9dXzmMIj0/qv4AQUsCKYIrNUDb5cZFDX+mSJKyxLHNlvn933vKFU6IxrDyQ==";
       };
     };
-    inherit packages;
+    inherit commonPackages hostPackages targetPackages;
   };
 
   sdk_7_0_1xx = buildNetSdk {
     version = "7.0.120";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/8b678e05-b3c7-43ae-a31a-c007a901d939/934ec0853faa6404aa924c99e019f788/dotnet-sdk-7.0.120-linux-x64.tar.gz";
-        sha512  = "cb9faba83ab276c935ef35b31f016ca4617f0d967c5b4bf1e993c2159992fb59d1dd25dce09928915b9ff586ead7acf92ec1dd96937c93317a99ca0c92b616c9";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/3ab51fcf-7641-4e33-aa59-53b394ae1e2e/79905a3a4708000a7a50da44a7256ad7/dotnet-sdk-7.0.120-linux-arm.tar.gz";
+        hash = "sha512-epZI3jwx+NElfZiYL0rivTusMkQLz8uAQCdShZkJNK7ocZASoso/VkZUblZtKWP2O/idGbVordxNMkzpdOpLxw==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/17a7bef9-4696-4b93-a3cb-f4bb9aaf2985/3e19b62d05b8e85b0a46d5dfd99196a5/dotnet-sdk-7.0.120-linux-arm64.tar.gz";
-        sha512  = "f530f794afe3c3b9bd87b8ed509a1a13b1c8fe6f2bc6e6cce3e8cd6b56327c0ff27fc138122c2dad68770cc5015737e007ef5706599c189ef0cc7521cbf0b654";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/17a7bef9-4696-4b93-a3cb-f4bb9aaf2985/3e19b62d05b8e85b0a46d5dfd99196a5/dotnet-sdk-7.0.120-linux-arm64.tar.gz";
+        hash = "sha512-9TD3lK/jw7m9h7jtUJoaE7HI/m8rxubM4+jNa1YyfA/yf8E4EiwtrWh3DMUBVzfgB+9XBlmcGJ7wzHUhy/C2VA==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/b1da5ec0-e336-4716-b9ff-77f8160e7878/5c40db0a17dc493eb0be8d047d0c6885/dotnet-sdk-7.0.120-osx-x64.tar.gz";
-        sha512  = "94deb9988509fcbfffc357114d0f5645fc6b6f6156664040cd5643a191bef10ae2fba4168aa689ff7da1a1b6fa779eb4e53a77a7847beceb7f0ba451d2c20d57";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/8b678e05-b3c7-43ae-a31a-c007a901d939/934ec0853faa6404aa924c99e019f788/dotnet-sdk-7.0.120-linux-x64.tar.gz";
+        hash = "sha512-y5+rqDqydsk17zWzHwFspGF/DZZ8W0vx6ZPCFZmS+1nR3SXc4JkokVuf9Ybq16z5LsHdlpN8kzF6mcoMkrYWyQ==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/3d081107-64cb-46ef-ab37-41560d585efb/5aa6a70b37790bbea98d7b8c380eacaa/dotnet-sdk-7.0.120-osx-arm64.tar.gz";
-        sha512  = "dc06801d8de34df698f93e3aa872d57131dd3e33ac4f7cddbc96223911e0ff32fdcea78332da7be0013362c90cd24db2d86c1e275297be6dd162948f2bd38cbc";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/202eccdf-4461-42ed-a260-0061216380b1/076bff1764888073337b16ed57dbdbec/dotnet-sdk-7.0.120-linux-musl-arm.tar.gz";
+        hash = "sha512-HNomb4ipUPRUT9/M8ezCaBa3XCn0hmv9mFiSkJQtmCp0zhfy9QfGKAsPM3t0OprQHlOjwQAcdHe91K3VO7BhXw==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/69b2b43d-6e1b-46c8-96b1-6f2e8871dd26/0405b62c3762de24e55635674a37f038/dotnet-sdk-7.0.120-linux-musl-arm64.tar.gz";
+        hash = "sha512-XTEkw9rx7RzvDIOOdTY3rx5SAws2Ywu/p9uhdqfsok/p5cTfnv8hcPqWz2PgBV30LwlQs7WQDesoJZDkthLz+w==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/0aafc9ee-0ca2-484e-b1ce-5f40458d49ed/06cf3c6a1515f931527e8fd6986e3982/dotnet-sdk-7.0.120-linux-musl-x64.tar.gz";
+        hash = "sha512-xQirUxDXQ/V+p4YR/+NUJo/og+fGc+6Ajaqm3eMLpFTV1w+BkcSetSrkqAwGLtZJC6HWt1L8xUGw63g19O7ofw==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/3d081107-64cb-46ef-ab37-41560d585efb/5aa6a70b37790bbea98d7b8c380eacaa/dotnet-sdk-7.0.120-osx-arm64.tar.gz";
+        hash = "sha512-3AaAHY3jTfaY+T46qHLVcTHdPjOsT3zdvJYiORHg/zL9zqeDMtp74AEzYskM0k2y2GweJ1KXvm3RYpSPK9OMvA==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/b1da5ec0-e336-4716-b9ff-77f8160e7878/5c40db0a17dc493eb0be8d047d0c6885/dotnet-sdk-7.0.120-osx-x64.tar.gz";
+        hash = "sha512-lN65mIUJ/L//w1cRTQ9WRfxrb2FWZkBAzVZDoZG+8Qri+6QWiqaJ/32hobb6d5605Tp3p4R77Ot/C6RR0sINVw==";
       };
     };
-    inherit packages;
+    inherit commonPackages hostPackages targetPackages;
   };
 
   sdk_7_0 = sdk_7_0_4xx;
diff --git a/pkgs/development/compilers/dotnet/versions/8.0.nix b/pkgs/development/compilers/dotnet/versions/8.0.nix
index a982f4ab9f88..1d787aac0a84 100644
--- a/pkgs/development/compilers/dotnet/versions/8.0.nix
+++ b/pkgs/development/compilers/dotnet/versions/8.0.nix
@@ -1,140 +1,210 @@
-{ buildAspNetCore, buildNetRuntime, buildNetSdk }:
+{ buildAspNetCore, buildNetRuntime, buildNetSdk, fetchNupkg }:
 
 # v8.0 (active)
 
 let
-  packages = { fetchNuGet }: [
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm"; version = "8.0.8"; sha256 = "04gvqgl6b46dfxqs2m8miwn7z7j5accidm4vl22ddpj17r8yhx8z"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "8.0.8"; sha256 = "1vi4ccb95bn6zf3pjrgi1nkcmca4s49s4xb5ni12yfbxf5jw5vv2"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64"; version = "8.0.8"; sha256 = "1nvp2dhznb8h4pcfyllwcx2vzygjpcqrd32blilylk5g5nqd163s"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-x64"; version = "8.0.8"; sha256 = "1mhlrvl7bs28bwfqwxydsmcjb4cm83ps2ahp02d86s6z30inlm6v"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "8.0.8"; sha256 = "0dnn3zbzj1ijp5kn7zqws4chnwklmdbiglv2dy664b99xspfrlgz"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-x64"; version = "8.0.8"; sha256 = "1bclpw8sa5fs8nv33smlkb4zx2ipans7ir67i5cdp2y3qg3afrks"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-arm64"; version = "8.0.8"; sha256 = "0gnhrkbr0r4l6x0165g68m87mhavcpv8hqkipsjq2ww53bp7csli"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-x64"; version = "8.0.8"; sha256 = "1jnr76a8r7sfjvl5p932mm4xn9pqnyv8rkbqddcbr9d396g18srn"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-x86"; version = "8.0.8"; sha256 = "0jkjns3rpl2rzs1x3blsirkxgsz64685my1nl1xzh838y1mk16yg"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Ref"; version = "8.0.8"; sha256 = "1fb7zhy8p247n8jfr69ca8f46b578ffvv0viqxwsa1ssl24a49g6"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm"; version = "8.0.8"; sha256 = "0w57jbrf8w2ffs7m78saawniaabasxjkxvmv1lqm6hkb8b3y4rd7"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64"; version = "8.0.8"; sha256 = "0lppcnba7jhzr034inxb0pqbywapfin7s9n6lncv6sbwmwcdw7b4"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm"; version = "8.0.8"; sha256 = "1l04vb02ddvafbwax79qs5nfg49dg733mnawxjnzfhjszs9872vr"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "8.0.8"; sha256 = "1s7yas0561jv3ihka8zmhxqhb2zc55lslj451dl16196i3zgla45"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-arm64"; version = "8.0.8"; sha256 = "1h5c5riyj465i8cdl6w4q10ymkfwd6f38nnqdbhs4hz9s3yqnw8c"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-x64"; version = "8.0.8"; sha256 = "025h7ys6n6b4vfp05gsr4vqph9nhi1rg028fpr3g7sxp9s4b694w"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "8.0.8"; sha256 = "1avn1pwjan2pkiw1knh0gw5dj61ylyahi9nc8mh69z7q97yrpsid"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-x64"; version = "8.0.8"; sha256 = "1yf1zjx64rjqxaqp31iih6vqfhp09r8hck6fr7xdbq24d1jqxdf7"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-arm64"; version = "8.0.8"; sha256 = "1mazrqxr1hfpka0im7h0n8ab73rn2zdf2jbi9fn48panz3ncqgwl"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-x64"; version = "8.0.8"; sha256 = "06j8vp6w3mjqd2qrf6ndmmfc563qd5gsfqwza99vzvwvsyyclix6"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-x86"; version = "8.0.8"; sha256 = "1wia1vgf0ywz4mqz8zqiba8m3wzz4fb5zgk4glwyyf4m646s96ky"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm"; version = "8.0.8"; sha256 = "00rh92hfqmpzb1s3imsc78n24gmbd1hyi8s09ra4z6fzkrz8vi2h"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "8.0.8"; sha256 = "0mvr8swzpgmm6fp2gh0lr8kbdp90ng6j2m80gk5im8q46ggjwz2m"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm64"; version = "8.0.8"; sha256 = "0bgsva11n48n9cw2xjfr071x3aq0yqnis191hw8zrgk07gq7q77a"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-x64"; version = "8.0.8"; sha256 = "1i0g0jv7vnp7rbagjppldypqx1c6bxsk4zx87w5km1n0aclfmyfy"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "8.0.8"; sha256 = "01bsp8lj08jvv3bpnb0ngccmgmdfcvqx1038r5ls001ax4l1p4nb"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-x64"; version = "8.0.8"; sha256 = "1b2zg6gjjri57v43v4sindbikqlxxgrmp4f89gyz7467rd718qa9"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-arm64"; version = "8.0.8"; sha256 = "1g7kwsdj9d9wy67acz3svkcp80aaf3npfsyhgnvslqgwfg53r5y4"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-x64"; version = "8.0.8"; sha256 = "1qgj8zhsb4r42zcaw8s66wgs294405d0vkvysvfxjhq0qf4d8k0b"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-x86"; version = "8.0.8"; sha256 = "1ghvz25730jskl3g7mijn80k2pnaddzadlpc5hrbhk1psrziv4cx"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; sha256 = "0jv18yz2cfrmky3v0mssddisnfraiynj2gp6djsj79i5an8lm86q"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetHost"; version = "8.0.8"; sha256 = "0z3aginrqsi7gbcj8rmga35jrw9qabcn6l0sxkysrs4b0qysfsv4"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; sha256 = "1fggfcilvg0icc2zym93wiy2ww3jvzyblrymyrvab5q5n49ni3n7"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; sha256 = "1vhav8c6fl3kf24i85iq4hvkml1hbl0fn23zcw0il8za0wa96wjh"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; sha256 = "07lmlyd36d4qgjn238hdb0rxki9dc367b05a8xfp4p9nf765s68r"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; sha256 = "19cw3h709whiysagdmrbqbd19pwqc9893dy39dkl353zwhcr802l"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; sha256 = "1my2f45ikw0kay03d1l6yrdcxc9iwyg8w6qyzyhpvbwybva3szqb"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; sha256 = "03zqkvfvgplrk2g0bd95agbly8lilqksp7v9jkfv8xi6fchyz7mk"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; sha256 = "0lvr6w07wxxs68xc4ki83xgvqbzraapnik8f73k0105vg80n684m"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; sha256 = "1pch0b5f4a936ma9l2pf1y8b89swppzc1034yr9c58f92agwm7a5"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; sha256 = "0bj9cgambifzjk68fcidfc2qw1jw6pmy40b6kimid8kig3vi8vc9"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; sha256 = "06ag1kj6d606h3vmqz2aap9pq7ca5c2w7qa0135md98nivl8ra2z"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; sha256 = "10z3lzn58wv0211fx14xy6nckkpvr7jssnq9gd7jisc40wg47m19"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; sha256 = "0cchmg00iabygbqrzrzw4pj461jw15a66bn8niqbv4j2j7fdxc43"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; sha256 = "0f2yal46hqa26s7wrilymhlydj74cj705wivajw204pvx9y29nrx"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; sha256 = "0jzya3wa3v5d27yr7cw3rin61xkgyllx5bmnmb3nlx9m7yv7s9mm"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; sha256 = "1fp73xdqbzbllb4bc942dnrmk00cgrr496svis58w1w1jhas8fg3"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; sha256 = "0mb6zr6ly59hlc8i4jqgwxrhrsvw92690s036d2zjq5yqiiszq15"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; sha256 = "185dfmvph0dp0syrya02yq8pmaqx8rpz6an91n14mvjrmp6g2xqi"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; sha256 = "1nncg3m5www0vhl7xr0d128a4sm6dngwf9y8shrgpi1c533yff50"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; sha256 = "1z5ii7qq6kvhi62dbjg1miwll6z89xi3ndggrjymbq62q26vxk9f"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; sha256 = "0aqm506ls3nqa1qx9vp8zr96mqsbf1q1ni1jcy0ql39khqcf77lc"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; sha256 = "017jfihz6l7pai2lakj5niwnnmn890xd2lgr9vvzn9lf6m1gsa28"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; sha256 = "0g80h08qizf0bmfi19ky90x8sf00x15xbwx6nmm1gmd0wfkcmfrd"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; sha256 = "1w914cpv0lpvmqi0zhrfxchida2adbllhr6617ix3f7w2g2z4vvc"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; sha256 = "1zwhsmjclhjawsjz7fwnsdmv14dgrch31spba32bkyqsn0bmfhnh"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; sha256 = "06x7nldwx6cfx2k8j26nhvg4vlflaz3qk3aqjld08jzjhzh9zl5i"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; sha256 = "0p3ylipzvd41idbb8d11120rakknr8f8ys15kv5fid765wck8xcc"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; sha256 = "1vrqkddhi87hsa4agx1akfhvygxqlj3b1pq6g405k1pdxm7x0ngz"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; sha256 = "1r80l23i677carh93fpkc4qr1wnrkfx8wvdbqj70k29qarjp1zyq"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; sha256 = "0yf7i13rrjdc9ibqff99cspgnz8qgyx85hv4jvgxz2d3jknv8ck5"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; sha256 = "0jkfh00davbf4ix27ph1p3g85amvrqjix2rapw1375pkv6vnhg1g"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; sha256 = "0r9s92nx7lz9alxc2kn67h0x8vl71wh7hv5dqx0fmhafgllw8dd2"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; sha256 = "13klkc3iy2lqxlknygfbqgqrpb6q4i3ihsvi9834aw17fiznrj60"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; sha256 = "1hxxpl4wzn18gq5zpbr0vz87bs4czmvbibhsf1zznwb2yvlr0sh0"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; sha256 = "0wzl1naijk3gm879bd6s2975yhsksnq2gl7jg7j1bnwik27nwpl6"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; sha256 = "1nvzykpd7d51bqh9lkskfffggd0hfm0hrxrnmp075ibd4v98cc9l"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; sha256 = "1j15hhf2hii4fh2nnmr7wmjxcx3v58ckm8lf5nsnz71fjcy6r2j1"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; sha256 = "1fchcm8hpianyj2n7lq4vajxak8ww9hxdh9bl6xpx2vij8rhhh87"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; sha256 = "0lj58x7l8f5nj9pyy6d7my611rpw0b9m5x4cb8rhqrx6ywzpjmfb"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-arm"; version = "8.0.8"; sha256 = "1g0kyfs8dj9jirc6qym1y93hxkcff1c1z2cws1qsqsrxbnrrn5dj"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-arm64"; version = "8.0.8"; sha256 = "1p5jgznx61rfanyzvvbkasp13yysjks9driwdm42cc7gw35h2lig"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm"; version = "8.0.8"; sha256 = "1wsaw71mq2d6a2n3hxrb1mablbr8rz7x35ibh41y11nyhldwvn3i"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-arm64"; version = "8.0.8"; sha256 = "1z8qvz3k1r699gkk96zrdffbqbb2j949gmh89hafcj9phmrbnvz8"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Ref"; version = "8.0.8"; sha256 = "150rhzlbbg5fr1la67pbyksk6ca8ypqj5j1izc77c9c9xasfa7nz"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm"; version = "8.0.8"; sha256 = "0lxq6m1b91yc58xqwrw84r90vgviwg97nddilbzsp9bml2y4h8y0"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm64"; version = "8.0.8"; sha256 = "16n7frb84h0ckkripfm5x698l7b4m9i2brwrsfr7n2ccxkilnfhw"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-musl-x64"; version = "8.0.8"; sha256 = "1rd3fzdd4dwdiwqcrnaacy4kh01w1j3f37ig4bw1zpv2kyb2c6f7"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-x64"; version = "8.0.8"; sha256 = "07a0hi147lag3qm9k7757w7p00l870i9ayhx2slw2g3vsr5fy12g"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-arm64"; version = "8.0.8"; sha256 = "0ysqwf6xbrv1c6q2chkr1hnkw407w1gk4ccpkivn697d1pc832hg"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-x64"; version = "8.0.8"; sha256 = "1y9w1xj6hjh0bdcq3ywi98v4mkcpk55x48ac2b157qjpqam906c4"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x64"; version = "8.0.8"; sha256 = "13s6ymx8vnxiz4ynss7cx1hc5rlwip746y735x4hjqqwqnxlnbc1"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x86"; version = "8.0.8"; sha256 = "0sh1r13xmphk3zb625h8814s455kx0x0h0p3liaxd0nfh8dy2gmz"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; sha256 = "1irszs3125nl5d00yyiganqbsdid1sqj289nirvsgzrkmzk0c44k"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; sha256 = "0lh81hxx7ai6hn8mfy579rym8zxydphq4nahwy1db56q3n7kbkrk"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; sha256 = "0a3x5vaqp0a3gm0dkwkai15jyi1qgbqapr7qg2nrv8q2w53vj007"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; sha256 = "0z71d2s8nn8pidzdnsvq8gsnl8kkf2limnm5fxvrfxc6kq22b9qk"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; sha256 = "0xk8va4vidial13wzc2i315k0w6yh6dgnch5bg53wwz2kkm5b7rv"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; sha256 = "1qb75x60bpr9kwp8s938arplym8p1zj7hsxs2mwna9271c254yx3"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; sha256 = "0wjn5krkprgkz87iqzr10ncs3hfzvg2n9zb1xbcm3f0m5af893il"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; sha256 = "015mg8cyqa6c4q2zqrq68rbmzcnjpm2ay5cwrrg99r2q72k85yff"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"; version = "8.0.8"; sha256 = "1sh70bdi1fz8zg2lnln2adn2yzjqi3fq8wazjbb8xgz3jbiha8ln"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"; version = "8.0.8"; sha256 = "1z0h02av5737mlk3y94lyjqhyjc577kx7yzmacl89m32ky4r2wk3"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"; version = "8.0.8"; sha256 = "10qq6jvzg75bzlc0wv8z6wi9zv9f53rxf7ya7175lxjszfzjmrkm"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm"; version = "8.0.8"; sha256 = "1kqcb196n8zgcwi4jznlzqx0mv1y2r2gk51wvvv3vhvmfjd6igsl"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64"; version = "8.0.8"; sha256 = "0bcdfhqsls04gg93av3rnxmjz9cynli36nmdc9wxgqnr8vma799i"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "8.0.8"; sha256 = "0zzsb5xkifks23vryy4mpm1xyi69mix2xn657cmgp0nn26c9169h"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-x64"; version = "8.0.8"; sha256 = "0vhx3z0aqnvlmjliqmd3cps5m34w69srwjw1506k2gipd1bhzgcx"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64"; version = "8.0.8"; sha256 = "1jfwbyr43z6id96qpplxv8mvxgdwc6spiy327lbx1gdbpf6yvv1i"; })
-      (fetchNuGet { pname = "Microsoft.DotNet.ILCompiler"; version = "8.0.8"; sha256 = "197lnzrfxws1b8pz64kiqjayaidv4rnigdyigpnfjq67w7x80s1a"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; sha256 = "1ax2ygccd1wnlcrad0kzv1lkb3z67vpwbmmqfipzbzsdaj81sgqg"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; sha256 = "04jwnn2ppdl1h11511df5wljmqx6hdzaw01qi44q5j5yab5ss01c"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; sha256 = "18nk4niv4nmpvhd67jflra7qrlq83mh8h3216p14kdiwmwbbzakb"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; sha256 = "1px4k16qxasb4vb7w2jcwjfr39mybhrjb120044km2ianz5mqsvn"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; sha256 = "194y9hvf4rjshnjvxn8j971byxmd837ax3fwp5j2gj8lr5pmh43v"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; sha256 = "0gxprpxvd28ci5xshappd200f16vzgph7r4k921sx98ffpl45sz0"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; sha256 = "1mbd0x4cwzn8284xbk66mr18s7fc37g75yp9r21agfz2vv6yjcn1"; })
-      (fetchNuGet { pname = "Microsoft.NET.ILLink.Tasks"; version = "8.0.8"; sha256 = "0kcg2pz794qh3lis9n06c8zmpa2h4q5pp5lfysgm403xzisd9pmj"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; sha256 = "0nzhfz87nfr8619pj75hnnq0kcl8w82kv4xr4528sdwbl5953dj3"; })
+  commonPackages = [
+    (fetchNupkg { pname = "Microsoft.AspNetCore.App.Ref"; version = "8.0.8"; hash = "sha256-5iWiiKBaB6V5x3GDvZ1DpyxDHFIsmewksoeIizz8Z7k="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; hash = "sha256-2KBKkVUlpiO1bOY+Ia2PKjurY2taV7CHnzU7Jr5HYUs="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.App.Ref"; version = "8.0.8"; hash = "sha256-3x7ltOqJJXYO+zHIIvH1SDEz9fTrHqNoyK68teiHGZQ="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetHost"; version = "8.0.8"; hash = "sha256-ZGunPQaL6Kz97BpQY9lSOPEsy1CvZiTZeidqnG18anw="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; hash = "sha256-x45oE7EFl6V29tVnuvzfcnAufOQjVf8FYxG8TSNz77k="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; hash = "sha256-UHKTFAfqIxoBZ38I6wBdMNA6NyQ4FhSJcHNQZxjaCu4="; })
+    (fetchNupkg { pname = "Microsoft.DotNet.ILCompiler"; version = "8.0.8"; hash = "sha256-KmiA+uHHYOnsfdG3F20mu0XllcRxEvMvWkHz7vK39KQ="; })
+    (fetchNupkg { pname = "Microsoft.NET.ILLink.Tasks"; version = "8.0.8"; hash = "sha256-st7UdPx9AFKf9o6WewsmUKhbP2IG2KQjHRCTdP4Vj00="; })
   ];
+
+  hostPackages = {
+    linux-arm = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm"; version = "8.0.8"; hash = "sha256-VL9omnR1wz323jyU+UQWPuwKOv7UfkkiZ+8ja1JYDM8="; })
+    ];
+    linux-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64"; version = "8.0.8"; hash = "sha256-MaWj6kbZ4td5Yq1aMyK1nqUva7d5bDXSewRoqjF0jS0="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; hash = "sha256-Dz8dkFRN//VvdLjWxe8+5o81adh/gqYyo5aHxtjzoqs="; })
+    ];
+    linux-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "8.0.8"; hash = "sha256-MJmQmBHWgvsqO8XYLnqsyUTfQ72VeJ/3EHq6OHtZ+n8="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; hash = "sha256-dmtcy7cqijoJAUCEJTNcvqaRneRMCn7WJkurjk2YpN8="; })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"; version = "8.0.8"; hash = "sha256-liIF45Ljv47Wkl9xhN2IWH4vbFPCUkvF++i7ENsCB+o="; })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"; version = "8.0.8"; hash = "sha256-Y3KRiZ9i1IQoU/X70+c5hUkPsfSUJD8mrWecspUAEPw="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; hash = "sha256-LACty1K+yIIJiTgArn6DpuMqKS+uhVBCgIG2e4W1XBI="; })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"; version = "8.0.8"; hash = "sha256-deYqv/tadlpOOMof1/MoLu2fIjcfbQ4Y/auc97c0GIM="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; hash = "sha256-a6q/Fq88tknCNUEMiGAdCNOMj8rUyWMa3LdasqMl06I="; })
+    ];
+    osx-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64"; version = "8.0.8"; hash = "sha256-MeztjburvdAXPWL4eLVhvL2+K9qd3otNatH8QbJf3Mk="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; hash = "sha256-Q7ZRUqGLN41EIbmTPQXiiLIJsLWwHHlTMCg7e9B38Fs="; })
+    ];
+    osx-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.osx-x64"; version = "8.0.8"; hash = "sha256-nb0PV2g3PjENKIFLnnUynIxa9GWjVRyprHRbrMAfHW4="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; hash = "sha256-exBYb8kUySdkudyNrs5ArXa/wkkS2b6lhVpm4jZMnqQ="; })
+    ];
+    win-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.win-arm64"; version = "8.0.8"; hash = "sha256-b6WidfvMYv6zHy1nd4kGc5oCg5tTDxPlg8CESjurv5E="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; hash = "sha256-4OtC6HUOpa6DSJPkA+/72wQHgGj3Kqh7iQyJtvvNtz8="; })
+    ];
+    win-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.win-x64"; version = "8.0.8"; hash = "sha256-bHuEFTwVzaQOEV1w/Jtfe8ZHMOtwHWsSqiiqoun+SkQ="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.8"; hash = "sha256-wTLpzd7iu6eCyOn6ct4ZzB2NQq7GzNUJEsh+zkgHbdU="; })
+    ];
+    win-x86 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.win-x86"; version = "8.0.8"; hash = "sha256-Q6mYxptkYaF0ThyJSX0uUVKK6R6x6Xkfi/40EqiDAQA="; })
+    ];
+  };
+
+  targetPackages = {
+    linux-arm = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm"; version = "8.0.8"; hash = "sha256-H3XoUT5B3taEoJvUFhlTRZ5/LI8VVaFxd82QZejD+xE="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-arm"; version = "8.0.8"; hash = "sha256-eYuDkv5aQvet7FzZOsZ5LZHnbNE4na74cmq3JsDaBNA="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-arm"; version = "8.0.8"; hash = "sha256-UMSNfp7fmU9UTkCj6GFoqz4iLDpM1zh0WP9W7KBIMAM="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; hash = "sha256-lSBjAXq7gADmOA7NaK9S+S+8Xx8oTsI6Mrp3fgA3eVM="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; hash = "sha256-RZ3KnxLJocJS9mSAwP69XCe0kA/uCppUNSMp4soCkN0="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; hash = "sha256-iW0U93hxohZrnGYB4us1XAaOBXMtMofMlN/FVdVjSS4="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; hash = "sha256-X6iM6I4WpVbLCEDhwwUrih1801VKfFz3gAaYZuQMTxk="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm"; version = "8.0.8"; hash = "sha256-wCNIvKB1pav/orE1e9Ljcb8NUiaIZ447KsyHtEI1uFM="; })
+    ];
+    linux-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "8.0.8"; hash = "sha256-Yu/CZXF9OS9CtGV1ohPRRLHKpg3xZXmH+8aukhZjJO4="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "8.0.8"; hash = "sha256-hSj6/ogmBRNoC4VIqmkp7IsFcYf1IzVhHFsGU4BW/ug="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "8.0.8"; hash = "sha256-VXwu3zMEoxrLfABVIc2zIN22JsoUwCeuM7W++7lGeVc="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; hash = "sha256-GRldzHE2XXJdR6qAdcxgLcXZM1gNoiGsfJg0M5qnlR4="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; hash = "sha256-VACUGeR/lEFnS8O3kVBimN8U2sIr1/aU9hHyBA4cnKU="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; hash = "sha256-C3891F6er32h/x4bjp7nMbHOWvaGhjaAVxPwGQtxwtc="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; hash = "sha256-s57vIXMmdrTdlGmfqyemkSJP11MltQWemJnet92e+A8="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm64"; version = "8.0.8"; hash = "sha256-HDpL4+yMCXuy05nnJWKqZB2KkumluhvznAxAglZ2x5o="; })
+    ];
+    linux-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "8.0.8"; hash = "sha256-/9Hsru4pLWKMb2LTF1erdHILGdEc/2NnuTIG+dcf1jY="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "8.0.8"; hash = "sha256-Leqb/Un4/GRgRcymCJWnPhjZCn8A2hl4nFdYJfkNdqs="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "8.0.8"; hash = "sha256-y5IbKOkqAKBpyWiA0PFmrtVXGXsWLHvX2FsiICm6egU="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; hash = "sha256-Ls2+jcDC4FW9zO81O2JP6BtKeazhydWEiXBPg/GJsfw="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; hash = "sha256-jJ7jGIYzDYqBZzJEG3BwS+NqUv7o7tRxUNgOTQ0oFSs="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; hash = "sha256-SCj9QjWOJvv3TvlR0TpIyFZrebRFTkVFVPdQ82F08gQ="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; hash = "sha256-LbvKpuOg1Rdqtabz1UvoADiNOkh+phBdXcD9iBGAAD0="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-x64"; version = "8.0.8"; hash = "sha256-TwTvStZ7PMGpFh16lSI4iAJwDz/lnJkqHk/RQ0KEQB0="; })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm"; version = "8.0.8"; hash = "sha256-p2Xix0JrQlMxDbvuPmXXaikVLVdKo1OPdk5w5PKSp3A="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-musl-arm"; version = "8.0.8"; hash = "sha256-shWbs109a6xx0JyJH1hwjs0OR/KhemxYjjLJhrTzE7w="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm"; version = "8.0.8"; hash = "sha256-cdjNG4XehuADgSuW0c/PKC+6VA0rdzisUKYJXMPhSvM="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; hash = "sha256-kxAG5q8z/6d3jjYhIbEOLTa9sFUveg9AK9QWEYb+Osc="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; hash = "sha256-M881jx3YlNWC51BZguFtvn9UfU6neFeRhSaq0zsMCFI="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; hash = "sha256-BwC5R+ECo52tePjkq/B6OEQvS4hq8tlAfUOBi9UufSg="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; hash = "sha256-E6clBJ6GdZd3d6XaGqlwcyJq9UN4a9t+ixdZi7Ro4Xw="; })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64"; version = "8.0.8"; hash = "sha256-epjQsC2vTOpppEuMljG78vm/RWecUu/YJRAt+2ETd9s="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-musl-arm64"; version = "8.0.8"; hash = "sha256-DHGL/dDpQ6LhathaNJxp3M3qQcCEG9oYisUQ6WMurMA="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm64"; version = "8.0.8"; hash = "sha256-6hx88DtgvvwRhyEFHS32AKvRwwHZyS44SxYRG4La+i0="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; hash = "sha256-KdRDHgeE6ShPewlbreXJ+87JrPGdhO5CEGBzVOyn44M="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; hash = "sha256-g7De3JFCkr1wtMguY1QJXAZD5CX855/xen6pCMCrkDE="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; hash = "sha256-PdskfOr7EiC4VDvyAo5k5MjmKayexsyPNkJhaAhVXjg="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; hash = "sha256-tSZ9tj81dWrHqrau0in1b/ZgbMyDs5P9Ea3sofhQ/ks="; })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-x64"; version = "8.0.8"; hash = "sha256-21RqIxjfaIOaABcqoe9AlZElWdXNd44dX0jodejOFNY="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-musl-x64"; version = "8.0.8"; hash = "sha256-nCSziE636/NGvg4J8HKI0CZ48SZZvwKu22QZa7Q/sAg="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-musl-x64"; version = "8.0.8"; hash = "sha256-3vnqKFPAhjoLP6h/MnVfhoWOr2/0XvnUyufafbYED8Q="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; hash = "sha256-4zmkFZSBB46KjlubRHJ+DIBZs22CJLbIonT9hVsf57o="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; hash = "sha256-JeCvY8S+YPlFMwNokIxIfOsMc+cPSxIRozAVT03+ZlU="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; hash = "sha256-EXfxzK1Z7kqCDckq829GHat6EfYCKJ+9BrcBeHd1raA="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; hash = "sha256-oDjnxygsxPsy1Mgnx59tpmqikAgN5H4o3IBzXup4zNo="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-musl-x64"; version = "8.0.8"; hash = "sha256-xxkmlp9i3x/4Ii+e4YYMPAA4iWdK2cwwj4030tp3o+U="; })
+    ];
+    osx-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64"; version = "8.0.8"; hash = "sha256-ZB3eGK98abOZpcYmfWx0V3G/8AWr20gGyB/Ko5Zl91I="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.osx-arm64"; version = "8.0.8"; hash = "sha256-L1IBy+DvMCZIbTzmlvSU2vsRrlZz7f29VS4H0+1/stw="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.osx-arm64"; version = "8.0.8"; hash = "sha256-6G+7coU3SeYUTAjWl0iSYi28nGv5mzTnS8nkMMffGP0="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; hash = "sha256-O59V6pzicz7KWwUy+5qB3nAwSxhRsM9HoCq2uInaaHY="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; hash = "sha256-o3tSBAtHJGV5FbpreOQPF1VPb1ZoJI0unynfBUwvZ+E="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; hash = "sha256-NI6EnCoVuFHZ6mH9ZMXb38GhmQUhfxwP+vPlO/MsVnI="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; hash = "sha256-zvmCpjhY5JRezpwVr0S90rJfV0YGZ/wFJswo7Bl6tQQ="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-arm64"; version = "8.0.8"; hash = "sha256-D4qB2A3tJGN3nJcxMl/gBxA+LQx5QiawYWHn1Y3jWHs="; })
+    ];
+    osx-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.osx-x64"; version = "8.0.8"; hash = "sha256-emanxsPDi9tYicfkeLRVN4r+yZq06jG2RdoVpRG/lK0="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.osx-x64"; version = "8.0.8"; hash = "sha256-x7WOZWhE4NX6yc5MBlFO4EKHt4ExhnGx6lhmYrr8wfk="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.osx-x64"; version = "8.0.8"; hash = "sha256-SWEUTsvHkPP9S8iRW/PrneIZV7NRkz3IPiVmKZ95X6w="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; hash = "sha256-bG/yxRP8uNHjCcZkSOlqSqgWIesuww8irvtSsC8jIfE="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; hash = "sha256-0EJXF7Aa+7nEUOvqMCDLr5Gwa9OWu/Ol5kpCymTVkP8="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; hash = "sha256-sdCf4IfySwQalViNicdX1NFN3obWCImm6I6Zzhu1pxs="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; hash = "sha256-jHU0GS/mtOjKniVojxzKdk6VgQghNLRWi4G0/W+kflw="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-x64"; version = "8.0.8"; hash = "sha256-hBmQqsJX4lPCEkwh0kuZl81KNkqR+4FZWwBKaGQPPPk="; })
+    ];
+    win-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.win-arm64"; version = "8.0.8"; hash = "sha256-kWp27hqFc4GlvnFiiPZlW8F6UEXmFRNAN5RkkNfM0D4="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.win-arm64"; version = "8.0.8"; hash = "sha256-lD/M7PhWXUSsS3FJ4doXNo+zFLIAnhqBmtfBkDvOX9U="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.win-arm64"; version = "8.0.8"; hash = "sha256-xJc8ynP8Yaq3fdBrd+1wSgF02dx6fKaO8Ty1JJvm87w="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; hash = "sha256-/1nQT+3thlkAeQbfsIakuD+/oZsq9KeI0vCgCFubOO8="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; hash = "sha256-2P9wZVY4iQmOxKttjrqb2fKQMWHzupFgVuwcE4egAOU="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; hash = "sha256-ZTK07ZSjid/flmTDgrp/GH37rmYpOYdXTKzJnEeIx3k="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; hash = "sha256-Lzxot9nzljMCvyqLHiXOu6qC3rgB3iN6JG5t1QCAbko="; })
+    ];
+    win-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.win-x64"; version = "8.0.8"; hash = "sha256-NmsUnkmjpbxYa3jNjLa3+CbbSa1ipFvolk6fjJQ52co="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.win-x64"; version = "8.0.8"; hash = "sha256-pkfKvNeb779TUp9jp19peJjCXK3NGpexaFjWwc3dSBo="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.win-x64"; version = "8.0.8"; hash = "sha256-C0zUiMMAQ9nd1n7PDVoBhCShHzdGI67YFySTpeFH8uE="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; hash = "sha256-ojXEKX1OwepAx61seCAPh27UATzGTsE6VenT061IOmU="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; hash = "sha256-wMhsf3QncEUGSnFrGEck2Kyb8cPLPW8n7ZgKHwebdI4="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; hash = "sha256-AGqQ6fZicft/cBquuHb9jOh10N8gr/sLfijYzwm9vcM="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; hash = "sha256-hl5uj5iR2xXkefLQJ7DVU0NfThLatJUOqm9MGZUN9HM="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x64"; version = "8.0.8"; hash = "sha256-gS1Lu8UcYwlJL+N4Q86NnObCYOjsaG09+bHbjXr1Ro8="; })
+    ];
+    win-x86 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.win-x86"; version = "8.0.8"; hash = "sha256-z5swa/BoIPh7oDb4WpAh5uvXZ46artGD/lnQm4e2cko="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.win-x86"; version = "8.0.8"; hash = "sha256-fpqkDTGVOO85fWS+X5Yj//NRkVoRf/RxJZ974N4OKvI="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.win-x86"; version = "8.0.8"; hash = "sha256-nZEdf9Y3TLgyLOzSpn5ryl4xAbIy1vMGnVqCcYr4G74="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetAppHost"; version = "8.0.8"; hash = "sha256-NDGG0iZtxXLArTb3DEF1ELT3nHNTT5ogXqG00+70f9s="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHost"; version = "8.0.8"; hash = "sha256-QYpsPJMunG+1LY6iOhkqe3TWZeUnV2sFdCRGKByEJcg="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.8"; hash = "sha256-B0EIM5Jxi367oSvB1mHiHE3VpdoE02OF9FbFC1FlkLk="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.8"; hash = "sha256-y1V5P/emZwwzWoz0UtMC/OYQjK+nGe9vkrY4RE9HRVI="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x86"; version = "8.0.8"; hash = "sha256-vz7hG4LOgtZVpOMCCDrosxSiSUAIFmHWHxPe2kfIAWo="; })
+    ];
+  };
+
 in rec {
   release_8_0 = "8.0.8";
 
   aspnetcore_8_0 = buildAspNetCore {
     version = "8.0.8";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/648de803-0b0c-46bc-9601-42a94dae0b41/241fd17cee8d473a78675e30681979bb/aspnetcore-runtime-8.0.8-linux-x64.tar.gz";
-        sha512  = "d6c0cc2aac79fbacbf81b597f286763599f66278c17ddb448ce0b93d499bad8f88777d425854e68602945ab18af8a61f1ee59d431d5503006137f86113faa8b2";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/26f16795-9928-4ddd-96f4-666e6e256715/bf797e4f997c965aeb0183b467fcf71a/aspnetcore-runtime-8.0.8-linux-arm.tar.gz";
+        hash = "sha512-0P7t2Ru0AoBp2M/xcmGR6fCZIOdWQF3g0rv29DEWJ3zJPr4kg/QFuqSXK1T/6JsJy+FypjnmA5eucTjfXvSMTg==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/f6fcf2c9-39ad-49c7-80b5-92306309e796/3cac9217f55528cb60c95702ba92d78b/aspnetcore-runtime-8.0.8-linux-arm64.tar.gz";
-        sha512  = "c3dc9d71fca0a48eda96074cbcef4c9a265c1c4e10cbff38614dd74d79443ae9d1ccd10714764cd041291f81d83c0ed1c307abf89249ab4b6f58a5de952fcffd";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/f6fcf2c9-39ad-49c7-80b5-92306309e796/3cac9217f55528cb60c95702ba92d78b/aspnetcore-runtime-8.0.8-linux-arm64.tar.gz";
+        hash = "sha512-w9ydcfygpI7algdMvO9MmiZcHE4Qy/84YU3XTXlEOunRzNEHFHZM0EEpH4HYPA7Rwwer+JJJq0tvWKXelS/P/Q==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/465bdf6e-407d-4512-a222-32dafb225ad8/c22004de330d10a06141dee0f42b5d12/aspnetcore-runtime-8.0.8-osx-x64.tar.gz";
-        sha512  = "d3ba8dcfaddcd6d50fd434911fe3eb8309666939a8a1ede800d7da2dd814efbd781d1449a42b71d1c71d9593465e9e97205025eb432808ef9a3ba0dcbdba0e3e";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/648de803-0b0c-46bc-9601-42a94dae0b41/241fd17cee8d473a78675e30681979bb/aspnetcore-runtime-8.0.8-linux-x64.tar.gz";
+        hash = "sha512-1sDMKqx5+6y/gbWX8oZ2NZn2YnjBfdtEjOC5PUmbrY+Id31CWFTmhgKUWrGK+KYfHuWdQx1VAwBhN/hhE/qosg==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/a7080974-fac8-446c-ba20-313f6f323fbe/f907c126c9bcd394939a7cdf86b85f4b/aspnetcore-runtime-8.0.8-osx-arm64.tar.gz";
-        sha512  = "a196c62b14e9136362073826a03e76e0a147027f03655529426e594f7e44eb8dd036daea80997876047171c1793c7edcfa5146bd55a01b591d9405fb1646eb00";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/9255e487-cdf2-4690-9840-74712503e37d/40be3d122db1d1ffa53a9843321c3979/aspnetcore-runtime-8.0.8-linux-musl-arm.tar.gz";
+        hash = "sha512-XZ9gnnLc/MFra7Y9Sef9R8Pi13kT2d4UhkQX+ypTSy99tWUw2xZazGNjNkHHBtD6upXbmFsJhEZ32MtBA5oMZw==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/95f358cf-86b5-4789-8ee8-063067081c8b/e50e603b2453d7dc65eeb26dd4cfb398/aspnetcore-runtime-8.0.8-linux-musl-arm64.tar.gz";
+        hash = "sha512-YCjCkwbUlp7kBMRZ3KMTDx6WFNGVTo7UQAFAs1rYoeZqCos64CFV32vQRs2TCQdCIEh6HCYlw58IG9xsjtYgBQ==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/7d2ac05d-2bef-4069-9513-bb2ef7fab48d/4f3d2d3fec003a65513dc1f70c126ab7/aspnetcore-runtime-8.0.8-linux-musl-x64.tar.gz";
+        hash = "sha512-gi8uFxbcLSqkb/CPTS2bueqMgjMnhdCrpfTzPl62C9zYTomc0qE8qTAyImcQtfDKXHFZvtoXAn+E76KFJ4tXmA==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/a7080974-fac8-446c-ba20-313f6f323fbe/f907c126c9bcd394939a7cdf86b85f4b/aspnetcore-runtime-8.0.8-osx-arm64.tar.gz";
+        hash = "sha512-oZbGKxTpE2NiBzgmoD524KFHAn8DZVUpQm5ZT35E643QNtrqgJl4dgRxccF5PH7c+lFGvVWgG1kdlAX7FkbrAA==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/465bdf6e-407d-4512-a222-32dafb225ad8/c22004de330d10a06141dee0f42b5d12/aspnetcore-runtime-8.0.8-osx-x64.tar.gz";
+        hash = "sha512-07qNz63c1tUP1DSRH+PrgwlmaTmooe3oANfaLdgU7714HRRJpCtx0ccdlZNGXp6XIFAl60MoCO+aO6DcvboOPg==";
       };
     };
   };
@@ -142,21 +212,37 @@ in rec {
   runtime_8_0 = buildNetRuntime {
     version = "8.0.8";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/68c87f8a-862c-4870-a792-9c89b3c8aa2d/2319ebfb46d3a903341966586e8b0898/dotnet-runtime-8.0.8-linux-x64.tar.gz";
-        sha512  = "8f5220098c562fa3490417748eb9f4f9ca1551f7155728b9ebb1924359c63c18dedef643bcd89ec67b59cb5b1b9de7283ee156ef381ffb16801b516dba9b1b0f";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/5e427de4-981a-481e-9fec-fa77b02a7edb/0d156acae55ca1329b6b9a8de70f398f/dotnet-runtime-8.0.8-linux-arm.tar.gz";
+        hash = "sha512-yHr1qq8y4YzNwpZRecZaq65eDp6Oogn2w2QnDOLkr//ql5yiLhQ95GdONqKxLGa1dViK4hnxZjaspxIUQCQCiA==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/ac04b123-0542-4e80-9216-93f51a6814b3/d110733c152d34ab4eedb435ccfdab4d/dotnet-runtime-8.0.8-linux-arm64.tar.gz";
-        sha512  = "246fb7e5edb51db93421c6bb7420f7a358430b98b224a71fb70e71a2bce0bc91f853aa89109f2188b0ab28532a245c3d52baac163463e01a02019dea37fd39f2";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/ac04b123-0542-4e80-9216-93f51a6814b3/d110733c152d34ab4eedb435ccfdab4d/dotnet-runtime-8.0.8-linux-arm64.tar.gz";
+        hash = "sha512-JG+35e21Hbk0Ica7dCD3o1hDC5iyJKcftw5xorzgvJH4U6qJEJ8hiLCrKFMqJFw9UrqsFjRj4BoCAZ3qN/058g==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/0159972b-a4d6-4683-b32a-9da824d5689e/ffb0784119abf49015be375b5a016413/dotnet-runtime-8.0.8-osx-x64.tar.gz";
-        sha512  = "8029986c1f8bbf1b0e8d0929756156fe41d46d2df6ebe1ab1c66fbcea2add47c35b934573c6198797cf60d2b372cd463e70326c0a35b0926dab4d5c157a357f3";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/68c87f8a-862c-4870-a792-9c89b3c8aa2d/2319ebfb46d3a903341966586e8b0898/dotnet-runtime-8.0.8-linux-x64.tar.gz";
+        hash = "sha512-j1IgCYxWL6NJBBd0jrn0+coVUfcVVyi567GSQ1nGPBje3vZDvNiexntZy1sbnecoPuFW7zgf+xaAG1FtupsbDw==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/e9ded115-7a30-4952-bb72-ff101583f20b/5a7628261b98d095d2c97ec3fe5267be/dotnet-runtime-8.0.8-osx-arm64.tar.gz";
-        sha512  = "88b06dd051819bd9e8ce2c340b2516dc0e4a77d565eff145d8e957b2552a641e235a5ce7e8db3607475887bc766f1530d01d0e7efd80d10cd652a299954398b4";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/2f4507aa-972d-429c-9129-cfe95c1279eb/60dd9afc3f4786a568b01119c2280c63/dotnet-runtime-8.0.8-linux-musl-arm.tar.gz";
+        hash = "sha512-im+SDZPX1VJ9won0clIeKmca+05mOqrP2CwyZYwuo56rQ6XJfT09e6WEA+v79suW/HP/W3zMGpRH0Tv0HuuAyQ==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/8d78f160-0833-4db5-bd62-947f8bc2d571/25638f47211018a7bd8fd9d314763196/dotnet-runtime-8.0.8-linux-musl-arm64.tar.gz";
+        hash = "sha512-JvNeHGB0p9maQOpI9sAtt49OLHQ8vHRGOglNoBThJuk3nQm05WgJrJgpsmtroKkBrcR638PF01qX6erVppMUiQ==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/d9c4e4e4-bb2d-4f1a-9ded-bff5e354bd5a/0c6dbc5f68bea36a65fdf80e6aa4d55f/dotnet-runtime-8.0.8-linux-musl-x64.tar.gz";
+        hash = "sha512-yi/zIUVQZRMlP4Ds1ytcJNi9oo9EroPJiMOev6dec31VELy4S8J6FJ0uaZV2H4sSTXcBUirpu8rBf8MmZyF+tg==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/e9ded115-7a30-4952-bb72-ff101583f20b/5a7628261b98d095d2c97ec3fe5267be/dotnet-runtime-8.0.8-osx-arm64.tar.gz";
+        hash = "sha512-iLBt0FGBm9noziw0CyUW3A5Kd9Vl7/FF2OlXslUqZB4jWlzn6Ns2B0dYh7x2bxUw0B0Ofv2A0QzWUqKZlUOYtA==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/0159972b-a4d6-4683-b32a-9da824d5689e/ffb0784119abf49015be375b5a016413/dotnet-runtime-8.0.8-osx-x64.tar.gz";
+        hash = "sha512-gCmYbB+LvxsOjQkpdWFW/kHUbS326+GrHGb7zqKt1Hw1uTRXPGGYeXz2DSs3LNRj5wMmwKNbCSbatNXBV6NX8w==";
       };
     };
   };
@@ -164,70 +250,118 @@ in rec {
   sdk_8_0_4xx = buildNetSdk {
     version = "8.0.401";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/db901b0a-3144-4d07-b8ab-6e7a43e7a791/4d9d1b39b879ad969c6c0ceb6d052381/dotnet-sdk-8.0.401-linux-x64.tar.gz";
-        sha512  = "4d2180e82c963318863476cf61c035bd3d82165e7b70751ba231225b5575df24d30c0789d5748c3a379e1e6896b57e59286218cacd440ffb0075c9355094fd8c";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/788ca4e7-c3ea-405d-9f82-2d362d4a08f6/d54b1aefd4048bcf4eebb24edfc6aeb9/dotnet-sdk-8.0.401-linux-arm.tar.gz";
+        hash = "sha512-+5Co5S9d0p5ZU+RmLMnVfKqW3GqPb/bPrheUeqij9Ttf7xuzW4wFgV+hyvvccxefcpbOhGv1dp7hLJ2vW9J5QQ==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/14742499-fc32-461e-bdb8-67b147763eee/c14113944f734526153f1aaac38ddfca/dotnet-sdk-8.0.401-linux-arm64.tar.gz";
-        sha512  = "e8738b21351d030a83be644571f3674c8dda9e6fbd360b221907a7108fab02becd18e1331907535a1294d8c4d0f608519674c27c77dc2c2803cc53cce3e10e0d";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/14742499-fc32-461e-bdb8-67b147763eee/c14113944f734526153f1aaac38ddfca/dotnet-sdk-8.0.401-linux-arm64.tar.gz";
+        hash = "sha512-6HOLITUdAwqDvmRFcfNnTI3anm+9NgsiGQenEI+rAr7NGOEzGQdTWhKU2MTQ9ghRlnTCfHfcLCgDzFPM4+EODQ==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/b266f183-c677-4f93-a729-abe0334401ea/ca0ce4f684c4cfea2d372223f9c67cbd/dotnet-sdk-8.0.401-osx-x64.tar.gz";
-        sha512  = "063aeaf4e949b96d501b77873279f0286cde46f9212b59181c6db21630401fd6a352e3259848cee8e127e4ceac85a25e0bce36699a2fb6f6e2a91997c6f61eae";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/db901b0a-3144-4d07-b8ab-6e7a43e7a791/4d9d1b39b879ad969c6c0ceb6d052381/dotnet-sdk-8.0.401-linux-x64.tar.gz";
+        hash = "sha512-TSGA6CyWMxiGNHbPYcA1vT2CFl57cHUbojEiW1V13yTTDAeJ1XSMOjeeHmiWtX5ZKGIYys1ED/sAdck1UJT9jA==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/29ef2c29-154a-4c44-9450-071ae664767a/4ce00627f3eaee13874b54f033a9a27a/dotnet-sdk-8.0.401-osx-arm64.tar.gz";
-        sha512  = "a3232c0693b41ee6b18dc3c8b26d82dd9116132bd7871dc9c0a0acc5e7995f352e760869fe91a08828417ea7b91fc27859aeea449b9efabc17c136a57737c93e";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/f9eed98d-5e19-4822-85d6-c59c62376bad/52ba188eabe759516711f14247c57f7a/dotnet-sdk-8.0.401-linux-musl-arm.tar.gz";
+        hash = "sha512-xcVH6zAdyWXu8dm8xkIxZ44glZG4AZengknTXRZVpUafOc5t5lQ2N19uQtItFZw9xIe+F/bb52NAQAlfyYjbIQ==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/8f3dec03-a016-4c06-a4b0-04efcffbe521/e0e94170cbed0aa9312be63e43a69932/dotnet-sdk-8.0.401-linux-musl-arm64.tar.gz";
+        hash = "sha512-L6q5PdOKSThgMgg6D0o6WlZh1uz/SpjwaO16oHsgEjOAT6Dl76SRG27r7cmZTVnE1dhD3rdz5+JieyqpfmNKgg==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/3ce68ecc-a007-4d15-9196-79ced76a154a/6a45f69bb5c24576abeea048cea09987/dotnet-sdk-8.0.401-linux-musl-x64.tar.gz";
+        hash = "sha512-5xG3SDImlGPif5iwScRC02hM3CExFRMyhaKxie9FZLZRJ3R83TqQDeU1gQGb349HQm8s/Jv8HAw6gxBvm7VOpQ==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/29ef2c29-154a-4c44-9450-071ae664767a/4ce00627f3eaee13874b54f033a9a27a/dotnet-sdk-8.0.401-osx-arm64.tar.gz";
+        hash = "sha512-oyMsBpO0HuaxjcPIsm2C3ZEWEyvXhx3JwKCsxeeZXzUudghp/pGgiChBfqe5H8J4Wa7qRJue+rwXwTaldzfJPg==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/b266f183-c677-4f93-a729-abe0334401ea/ca0ce4f684c4cfea2d372223f9c67cbd/dotnet-sdk-8.0.401-osx-x64.tar.gz";
+        hash = "sha512-Bjrq9OlJuW1QG3eHMnnwKGzeRvkhK1kYHG2yFjBAH9ajUuMlmEjO6OEn5M6shaJeC842aZovtvbiqRmXxvYerg==";
       };
     };
-    inherit packages;
+    inherit commonPackages hostPackages targetPackages;
   };
 
   sdk_8_0_3xx = buildNetSdk {
     version = "8.0.304";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/52cedf32-8a92-4966-b184-18404ea1c5a4/cc399fff1b152b822776514ad247df50/dotnet-sdk-8.0.304-linux-x64.tar.gz";
-        sha512  = "971c344379240ec4bfaaf1eca69c6667e594cdd0dfdcde6e8962cb7a41d669dff91c644e48eed3573d841b7b3e60ce02e0c27a7ce37b66cdec27bf3457087c4a";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/c73041ed-e684-4dc9-981a-2db502409dd7/0e24c20b4b1d0a728e20982de0b8790f/dotnet-sdk-8.0.304-linux-arm.tar.gz";
+        hash = "sha512-MbSFdO52Ow1BggwfSWs+BVNsa2n9bnZBJEsc1l3MOy7V77SD17/MPC/O0v5OlGWJpY4kTdxaExyyZUgiAYwNLg==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/be9572a5-bcd5-46a0-b10d-0d00229ad57c/b80d3adb25c20fec467bd33f29f9a1be/dotnet-sdk-8.0.304-linux-arm64.tar.gz";
-        sha512  = "6ce93ba330848b4045b6c63f96ad0a91c474361cb0a208bd4128d418fd6da04695559add63df9a0acf283a32e6e781328d3979af900e0b2382cf006c9982806d";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/be9572a5-bcd5-46a0-b10d-0d00229ad57c/b80d3adb25c20fec467bd33f29f9a1be/dotnet-sdk-8.0.304-linux-arm64.tar.gz";
+        hash = "sha512-bOk7ozCEi0BFtsY/lq0KkcR0Nhywogi9QSjUGP1toEaVVZrdY9+aCs8oOjLm54EyjTl5r5AOCyOCzwBsmYKAbQ==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/8b5c27ce-6c82-4a06-8960-15ebd5434595/508572144872e190e7f00ba6583011d4/dotnet-sdk-8.0.304-osx-x64.tar.gz";
-        sha512  = "50f0265436e8c3d756ba00ab7fcd606cb5d452d7bede4daf97e4c02cc97dbbafc00b76f37ec4f07bbed4bee643a433849ddbd363ad2d916aa5965ee74ba317d6";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/52cedf32-8a92-4966-b184-18404ea1c5a4/cc399fff1b152b822776514ad247df50/dotnet-sdk-8.0.304-linux-x64.tar.gz";
+        hash = "sha512-lxw0Q3kkDsS/qvHsppxmZ+WUzdDf3N5uiWLLekHWad/5HGROSO7TVz2EG3s+YM4C4MJ6fON7Zs3sJ780Vwh8Sg==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/5ba638c9-0721-42c5-8bf8-9706c0f9c033/f8dbde51758bd9e734a9c932b60e12bc/dotnet-sdk-8.0.304-osx-arm64.tar.gz";
-        sha512  = "6993a950bc5bff0efe762ba2562a88761e93c61024d93633209950cbb68aeb5ff189fcbfe9247a1cdebbe37e738136123c7d4eda1050708608bb1ff0408eff4d";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/21dcf586-94e5-44f2-8407-bd409d73f59a/ec99c395aae24f38dd5cf91c8dc06fd3/dotnet-sdk-8.0.304-linux-musl-arm.tar.gz";
+        hash = "sha512-0tEHHGdGZKj+lvYaYgTFb54sZZjSoR406skWX/MNHNMxGeEOeUmamjVOxGHjBj5Ad3KzYvNkDmQRTNzSpO8Pag==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/8083f186-347d-43ff-ac05-575f63a1c692/dfbfb3ee9943b880472ccb8e5517a881/dotnet-sdk-8.0.304-linux-musl-arm64.tar.gz";
+        hash = "sha512-8mbyyMQFN32ExPGRegxKdJMJfMhTlA7hKQ7vyHdzMZNagAAqnGx8AxmP82YbyKui6TNBXYp3iUn/kB2ov9qNGg==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/5cf9b56c-0da6-4229-9e30-44547aba8be6/20d2e5353050b04d3272aa5c4a1b689c/dotnet-sdk-8.0.304-linux-musl-x64.tar.gz";
+        hash = "sha512-QdptR5cqfKZ268Bxhh+jxW8xH2PuCff+A8wJzvHkdx5O/nPF/GsCq4TwB8LnBE1+4WxliXH6hW1T8V9D5qYdmw==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/5ba638c9-0721-42c5-8bf8-9706c0f9c033/f8dbde51758bd9e734a9c932b60e12bc/dotnet-sdk-8.0.304-osx-arm64.tar.gz";
+        hash = "sha512-aZOpULxb/w7+diuiViqIdh6TxhAk2TYzIJlQy7aK61/xify/6SR6HN67435zgTYSPH1O2hBQcIYIux/wQI7/TQ==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/8b5c27ce-6c82-4a06-8960-15ebd5434595/508572144872e190e7f00ba6583011d4/dotnet-sdk-8.0.304-osx-x64.tar.gz";
+        hash = "sha512-UPAmVDbow9dWugCrf81gbLXUUte+3k2vl+TALMl9u6/AC3bzfsTwe77UvuZDpDOEndvTY60tkWqlll7nS6MX1g==";
       };
     };
-    inherit packages;
+    inherit commonPackages hostPackages targetPackages;
   };
 
   sdk_8_0_1xx = buildNetSdk {
     version = "8.0.108";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/95a365b4-ac3b-4300-ab6b-54cbc73220f4/4aabad928064af8761315ef34b08c24b/dotnet-sdk-8.0.108-linux-x64.tar.gz";
-        sha512  = "5666ddf6fa9b65deaba4d7c5fcc2e2d56f631c4f5f6fb2a9f5919af0616ab2b420b12a828becc2e4b8628a76ac3dae824b55abde5c6d5ac59ee131d7eceae7c2";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/27228a4b-1ae9-4c1f-8a21-eecd21d6c7b8/c0500c9fac6db54f68c04956b828e8ea/dotnet-sdk-8.0.108-linux-arm.tar.gz";
+        hash = "sha512-+vqFZLNLUktCCeEEfOfPEZCl1C57obE1JPXeYCsHXmMM3SKVZ/FOsvCubJaskQrp27T8TlKN+VjJ0xRxNB7tyg==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/07df5bfc-98ae-4335-91c4-c95ec5f99a58/48a310e5d1bde3e77c53a51c99bdfc08/dotnet-sdk-8.0.108-linux-arm64.tar.gz";
-        sha512  = "6cc723f2b139d19b2e17da5936698d388a5b64638b75ef78c40c407ed3cfd3dea745c2916f03efc9e66479fc55d608eb3a89305727ecdb1c999b183b58de258d";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/07df5bfc-98ae-4335-91c4-c95ec5f99a58/48a310e5d1bde3e77c53a51c99bdfc08/dotnet-sdk-8.0.108-linux-arm64.tar.gz";
+        hash = "sha512-bMcj8rE50ZsuF9pZNmmNOIpbZGOLde94xAxAftPP096nRcKRbwPvyeZkefxV1gjrOokwVyfs2xyZmxg7WN4ljQ==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/5ea78b09-65a7-4b08-ac65-bfae17afb322/7416ecc76a30ae4c77e71aade36e037f/dotnet-sdk-8.0.108-osx-x64.tar.gz";
-        sha512  = "a80fee279abfeb558a5540ca2a969a11bb3dbeade8c39d8c47be8a2d622ef1c2bedb22c874598ad41dbff2b95d5a43197bd9f55fc933ab4ede5edcb6a76cf6cb";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/95a365b4-ac3b-4300-ab6b-54cbc73220f4/4aabad928064af8761315ef34b08c24b/dotnet-sdk-8.0.108-linux-x64.tar.gz";
+        hash = "sha512-Vmbd9vqbZd6rpNfF/MLi1W9jHE9fb7Kp9ZGa8GFqsrQgsSqCi+zC5LhiinasPa6CS1Wr3lxtWsWe4THX7Ornwg==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/64a3d858-c2e3-48d1-8236-7c6702efc1f8/191bed6c7f89244eb998b0f186db57d7/dotnet-sdk-8.0.108-osx-arm64.tar.gz";
-        sha512  = "83b01276474b4b62bf0a282fbe11d2353a2191d90becd403b373cd6dfc95264442a907117ad8f615765b13969267b887d26a9f24dbd5f88d8b55daa94412d13c";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/24ef2f24-ca8e-4c3d-8466-2311550147d4/acbf2877ab4b8a611a3b63a9b9853dfc/dotnet-sdk-8.0.108-linux-musl-arm.tar.gz";
+        hash = "sha512-77MI2BrBAgli8U0D58qUGaKQGghGEg4HzZXGVAf+KYGiY2DC/+oUHYBYGqxtLDanN5x2wHsvs31O+4NpBfj/aA==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/63bf0f75-e962-46b3-b7c3-12aa20129d46/071514943265037c423e6f5e40df7ace/dotnet-sdk-8.0.108-linux-musl-arm64.tar.gz";
+        hash = "sha512-5wCbo3OwQ8y0aVVycayK5RirnJtbNk6YQdi5cwW2A28zJA5nLnxIN5hhaiM0KXSNUDj9/TNjUrggYK/WRXRwRQ==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/cab77c39-2e16-4f29-a9cb-e490d7fff442/ee37bc88e34e082a64d834ed5041bcee/dotnet-sdk-8.0.108-linux-musl-x64.tar.gz";
+        hash = "sha512-dEcVUB3jlG8GzTFvNcq8DjY+CvZRBEyXZwjA1I1OsNCUidkszrKDx1Gy7tDik86qq93Lq/fCXiHWWOv/ncMEqg==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/64a3d858-c2e3-48d1-8236-7c6702efc1f8/191bed6c7f89244eb998b0f186db57d7/dotnet-sdk-8.0.108-osx-arm64.tar.gz";
+        hash = "sha512-g7ASdkdLS2K/CigvvhHSNTohkdkL7NQDs3PNbfyVJkRCqQcRetj2FXZbE5aSZ7iH0mqfJNvV+I2LVdqpRBLRPA==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/5ea78b09-65a7-4b08-ac65-bfae17afb322/7416ecc76a30ae4c77e71aade36e037f/dotnet-sdk-8.0.108-osx-x64.tar.gz";
+        hash = "sha512-qA/uJ5q/61WKVUDKKpaaEbs9vq3ow52MR76KLWIu8cK+2yLIdFmK1B2/8rldWkMZe9n1X8kzq07eXty2p2z2yw==";
       };
     };
-    inherit packages;
+    inherit commonPackages hostPackages targetPackages;
   };
 
   sdk_8_0 = sdk_8_0_4xx;
diff --git a/pkgs/development/compilers/dotnet/versions/9.0.nix b/pkgs/development/compilers/dotnet/versions/9.0.nix
index 9232daa7073c..f615911b77a0 100644
--- a/pkgs/development/compilers/dotnet/versions/9.0.nix
+++ b/pkgs/development/compilers/dotnet/versions/9.0.nix
@@ -1,96 +1,166 @@
-{ buildAspNetCore, buildNetRuntime, buildNetSdk }:
+{ buildAspNetCore, buildNetRuntime, buildNetSdk, fetchNupkg }:
 
 # v9.0 (go-live)
 
 let
-  packages = { fetchNuGet }: [
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm"; version = "9.0.0-rc.1.24452.1"; sha256 = "05idm7kclnb8nw0nwv9wr40sm5fw7wk3zy2khiaiyvwf5c7klbkq"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "9.0.0-rc.1.24452.1"; sha256 = "1pxyk6yblg9y58w4lp9nb1dwwh0yvis4lq8b5w65ikihfyarm844"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64"; version = "9.0.0-rc.1.24452.1"; sha256 = "1prajkaxj7j0jdf6s52pkmgxi8d8al6h7kvl9viwgqc3jqz2kib6"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-x64"; version = "9.0.0-rc.1.24452.1"; sha256 = "02kz3kagy2zq19vxq2rilnnc8lnal4g6l9zzsba3045daij0gp61"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "9.0.0-rc.1.24452.1"; sha256 = "1r8577sjl8bifagq8cz7lx2jzdhhn3r668h313mz7fxwl2bqwv1a"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-x64"; version = "9.0.0-rc.1.24452.1"; sha256 = "1bdjl8kh80p3y51yngzvvz2kc9algsg5mx9givyapkcvj465pvhc"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-arm64"; version = "9.0.0-rc.1.24452.1"; sha256 = "09ispgilx7ss1b43wqcy7c9k1145p622h22vg6z3c0g90i0n2qgw"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-x64"; version = "9.0.0-rc.1.24452.1"; sha256 = "1lnz66r42mrxyfjdv5hswwmxv14fikn5p2il512vq0rmqq3fjwg7"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-x86"; version = "9.0.0-rc.1.24452.1"; sha256 = "0l3wb3v7grmpipd6p40dajzc574qmffv01g68n5c5qy38fs5kicl"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Ref"; version = "9.0.0-rc.1.24452.1"; sha256 = "1091fxvfq9zicgrx9cnk3x7xsg4389qxnj2cbfa6fq96p6rizhi1"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm"; version = "9.0.0-rc.1.24452.1"; sha256 = "16q6865rwblb2jiqvpiasw6fcq1n4h221pi3xgjdc62vkx0k5xd0"; })
-      (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64"; version = "9.0.0-rc.1.24452.1"; sha256 = "01c2ya9wmf7qkpxyjlnlflihxqpi6wrfq4slp3dylyaylypgha45"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm"; version = "9.0.0-rc.1.24431.7"; sha256 = "01qlklw2y6ci1mm8p4fcx4f7sx4lzx9rbn7d9pn1j85j2bb88rp9"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "9.0.0-rc.1.24431.7"; sha256 = "0qidj6b5qymfggpgflg3173jalzmvxz662g9pkj02cd1kbm6qp5a"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-arm64"; version = "9.0.0-rc.1.24431.7"; sha256 = "0x7vfky0ar1i3521xaai20a08j43cg2azdfghxg5dxaa1ynl53j5"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-x64"; version = "9.0.0-rc.1.24431.7"; sha256 = "1i597rmx8ab3lbl4xkff5vnvkrikpm1zk1vd5b7bk8jyz1ls2wa2"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "9.0.0-rc.1.24431.7"; sha256 = "008w5dlmnpc73mxk580l79a84djxnchyw8cjabh8d0255fk6p3a3"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-x64"; version = "9.0.0-rc.1.24431.7"; sha256 = "1bcfx38p4zqbvqvp3mrjm8yzcbh88i4vwd5af90z1ikfaml6841r"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-arm64"; version = "9.0.0-rc.1.24431.7"; sha256 = "00lhshwp5gj8ckdq276lrjp7025xhmi33vlj1284xhfvbbfam58c"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-x64"; version = "9.0.0-rc.1.24431.7"; sha256 = "1wqqq09ixbshswx59fq6ignj88izazw1k8sqp2iarxfv0jkv8fng"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-x86"; version = "9.0.0-rc.1.24431.7"; sha256 = "07qgqja3c1f62yfi3lqjjsyazp1hlkk41wkpk117b2xm8hw6yx4q"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm"; version = "9.0.0-rc.1.24431.7"; sha256 = "0a0kmkrq99hk6sm690qwam6i0fdgzpx8yiawa6h4ylpazy8jxfxv"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "9.0.0-rc.1.24431.7"; sha256 = "0qbaijdf4k3z71820r01z3sib5l7nlr6mjf75gil39yhd9s6slc7"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm64"; version = "9.0.0-rc.1.24431.7"; sha256 = "0v56060wm998yy34pdr8cqp8vbc3m97yzsvc50rm6rkhdld44vql"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-x64"; version = "9.0.0-rc.1.24431.7"; sha256 = "08afgp9k7nr02jikd5xaim53qiqdn4r556v2sfmgv17mvix7vhmz"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "9.0.0-rc.1.24431.7"; sha256 = "1ldmhq12xka64hn327p503m6ji12djkjax9lnr5lcflx527k5i3f"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-x64"; version = "9.0.0-rc.1.24431.7"; sha256 = "13qk3ppy0ym4x81jwxa0322hlzxhhg6vkb5n0xzyzy5ks8rfqnx0"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-arm64"; version = "9.0.0-rc.1.24431.7"; sha256 = "17f4wkf7pq1c2hacl1z53am96wg5ydq9z0gsdz5zabkyfgs4knin"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-x64"; version = "9.0.0-rc.1.24431.7"; sha256 = "1p39yik8xx87xv3jykljxv9jsazkkgcw47ckppzfzadf6967nh2r"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-x86"; version = "9.0.0-rc.1.24431.7"; sha256 = "0kqw9hnircqdbgpvk4m634nrn4lxj2p40a6qlscsqvw5yq06qvsz"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; sha256 = "05y2i9grw8my2kg2svrrmpk2zflvcqidmkyycf58p9a3bmd2xp32"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; sha256 = "00gsj3xwfpsc02rv4h75hrjq140ppr1bjqz5ics9xygj9gqrf40h"; })
-      (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; sha256 = "12vld4zgmlm1s73vn3csss9v81zh53xv0hhw138rrizsl8sxb0x5"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; sha256 = "09yn2lqvij53mv0w4n6fqpxhh15hp3fap1ymjjv4bv11y0gsml22"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; sha256 = "1xvhiswcni1z6czcmra2q25i6ih4pf5crfajgzb6mhvxxambk50x"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; sha256 = "02mlwynhl24avpyvllsgpmnrp6q05a3q5ia34anfs9fjxdbf31yr"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; sha256 = "1gxvgw12g617vj5gki2ag51ll4bxqfffbg5bkqjbnxig4ilh0xmi"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; sha256 = "0v7fmdv74lgybk7bvighf5i1qwhlsb44lmxmkxn6f5ijc7jd1v5a"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; sha256 = "1ql7115ihqqv09qzd23jd4ng7dnhk0vjiy892w2vnlaghkka1klr"; })
-      (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; sha256 = "02v6yklh3kw6xl8aacxjbsijrh0x8654hnjf3aa0qi5ffpng9czh"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-arm"; version = "9.0.0-rc.1.24431.7"; sha256 = "0bi1vrf5g26gmwv5js7rc4g5anva0m0gsinr7cvqixd2g13jl708"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-arm64"; version = "9.0.0-rc.1.24431.7"; sha256 = "1r3p996mj6hvl7gi6kffbnmm744i24smlxb9ay8hbkjmagv7pjp2"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm"; version = "9.0.0-rc.1.24431.7"; sha256 = "0llqrym4z3jrqf79hpl7w25vqnhrjsjmywayp5vr4c0y2bjpl3sk"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-arm64"; version = "9.0.0-rc.1.24431.7"; sha256 = "1hqfam3749yy15fyvqza54vvsx883kk0gq9fs2y78idmj0pr4g95"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Ref"; version = "9.0.0-rc.1.24431.7"; sha256 = "109f84rqdqj5vl0fxyb7nhq5lil9s1b7l6cv5y8z4gg139dv0z38"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; sha256 = "08qm6yp5swc7zryk5qkkwbsxybn8if6zmrai280bll8ygn932594"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; sha256 = "0n5dgj0lhxcjzy8bbzkavz2d3ixf4d1diyq4i6nysgri81kk8wd6"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"; version = "9.0.0-rc.1.24431.7"; sha256 = "10lr36pv80c31vpzpnl3jxs655xm2d2b1gj26891hzpwp0v1z9l6"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"; version = "9.0.0-rc.1.24431.7"; sha256 = "07j0samh7jlkjphj2dlkphj0jrhs694qw2md6hr7mpinjr065ji4"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"; version = "9.0.0-rc.1.24431.7"; sha256 = "0j1nkhmkg3p9n626j04lqr1vv3xnpnzvnhr39j4cn0ixyr7pbfqd"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm"; version = "9.0.0-rc.1.24431.7"; sha256 = "1rq2ixq8r6r29mn2xi31jpck1xicgwg3zjzlvs5zdib8w7rxiznl"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64"; version = "9.0.0-rc.1.24431.7"; sha256 = "11pxn2gwss6s8rmkgzvrljjwndif3pdlpfy0l3y5fbq60rrv6gy9"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "9.0.0-rc.1.24431.7"; sha256 = "044j6xkzylzawfjghqr5fkr63k0xhxvs7azmw8pbgh6mprmva4w9"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-x64"; version = "9.0.0-rc.1.24431.7"; sha256 = "16izyfqy0d2mvjl45z75ymhvjyrk5njrcfv1k7h223b1c1rn8p8d"; })
-      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64"; version = "9.0.0-rc.1.24431.7"; sha256 = "1fvhwlyvz0fm9cd0pw7l9a64shc565yk47hp873y7dai4lsch03v"; })
-      (fetchNuGet { pname = "Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; sha256 = "1fnk9q8iplj70jqy490fgg67z6sx5kyblkwd8z730s9yc3jr3919"; })
-      (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; sha256 = "0yxnbm7p8s9s1j7rl7cmvg1j6xnxrp64qp4dsi9c5hzn0fxg3jjk"; })
-      (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; sha256 = "1lzfk31aq4kfaypbqrzv74vw1pw27576a1yxpdyxls84lmd10dsy"; })
-      (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; sha256 = "0cq9i0cfd4gg5vgywf2jvyn8mbqnwjz6gi20x7ij85bad9hanm82"; })
-      (fetchNuGet { pname = "runtime.linux-x64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; sha256 = "0zv3brnkvn8v8ml2597vl7z1ydy71j6q7ycjkygy4l0b053870sw"; })
-      (fetchNuGet { pname = "runtime.osx-x64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; sha256 = "0vgr2xnskksrnrwlzk0n7qrajwkmz7cyvaifb0jbcx3kyzchxiz7"; })
-      (fetchNuGet { pname = "runtime.win-arm64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; sha256 = "0v22m76v8f5kwd5baww7l81ap33jrw4ccsz0lyki3hj2ssmzvr3i"; })
-      (fetchNuGet { pname = "runtime.win-x64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; sha256 = "0x8nafwsh0y0dycdpwjix1rxfkwk25irsqrbzcbqbdx3aas6jpk5"; })
-      (fetchNuGet { pname = "Microsoft.NET.ILLink.Tasks"; version = "9.0.0-rc.1.24431.7"; sha256 = "1bbpncqbd2f73n8nznhi2m2i5z8n2hds0ryz616n0nzcc4y3gnkz"; })
-      (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; sha256 = "08k1fzwvqyiqik98r0b03f089y4n06p5nfr73688rijgzm55l8zh"; })
+  commonPackages = [
+    (fetchNupkg { pname = "Microsoft.AspNetCore.App.Ref"; version = "9.0.0-rc.1.24452.1"; hash = "sha256-IcIfs7kmYWeUW0xI23FCgzzdTx/TstTzY/En7HZ3IYE="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-YtwuWl1DpYuKY97P2iJmm7ov5q05by3eFL4inl+Kwhc="; })
+    (fetchNupkg { pname = "Microsoft.NETCore.App.Ref"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-aHywWxrhPfKRL5sZelbQiUZaMLRn+e4A3UXihjNBLoE="; })
+    (fetchNupkg { pname = "Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-KaSR5WA+aTDOR41PuvwsXZt/zHsOJOKxBEfSGxFO07o="; })
+    (fetchNupkg { pname = "Microsoft.NET.ILLink.Tasks"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-f9o3PGHsW2BNMN9noBsUFv0SRRUR2m+RHceJtjCzd60="; })
   ];
+
+  hostPackages = {
+    linux-arm = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-1P7Y8+FoxfaL3vTLPx5/LPYw2ZVhxC5sTSKbjHCPAuc="; })
+    ];
+    linux-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-yT+zcwYGL1f8oMC7S9sdLjbLpaR5/zdrRtpozZ+w/YY="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-U8rxugP2w8JS1I1cTMzN3XYjw9uVHZqPDDppdE9dtns="; })
+    ];
+    linux-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-iRO1a77VwLcu4vWro3eHHcxh8nQlY/ik4+pT/2c3khA="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-XIODRgELUOKfn5L5g40Mxzcf/qH7pCJoRRvZPW1eY38="; })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-hqYfNrj8fhgSMkK+sEQTtZdidJeD2vvvDoMBtK8ZmYI="; })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-JMpiQJY23noyNK0KjkkyGmYJJLyTNiHhlZPKA6vSQB4="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-XjcQWqUEadp9u90HZU45gt/ANzn7Z7yuV24SrMKY7tM="; })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-Dbt1T/Y9AsuITCNDu7+9to+9Q8aUAGmEsemONyucNkg="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-AlWrYGpqFSTj6UDEZ77kFq+KrN9SOO7fLu+R5hiICTM="; })
+    ];
+    osx-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-ewDINCVRtePHQRceMn0xhUFNjEr08AsaS9WBvz3lcLs="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-8CNaSv1PxoyQGSc7W64BlviEgBtggYzSjDh6vPl3YSI="; })
+    ];
+    osx-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.osx-x64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-DV1kc2BhDSHgmWE7lqUtM3u5YfXl/EKo3FU04LHzP5o="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-58cO2fdzdLYkWC6q7dn5dXKpMj4WzE95tlnPqW0X+W0="; })
+    ];
+    win-arm64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.win-arm64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-GugOroZ0SRoGoP3xE3jt91vTbHwXLPq8bHYckNC8SIA="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-ceT9q9ZCwhGnp+BrxgjPcoyrAqKHc7VK47M4tM2pQmw="; })
+    ];
+    win-x64 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.win-x64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-lvAHbw3hhS6OnCuUMLEa4NKJWZPHqcBM3IeXpeYtLHo="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.DotNet.ILCompiler"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-ZV5ptFKjt4UX+ytjnWMRk0/Xc+hR8tuYb8ADqLlTFnU="; })
+    ];
+    win-x86 = [
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Crossgen2.win-x86"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-ULArvCiy+bOHtkD5E0q7u+Cfg7R+IJZ4A60ldV798vs="; })
+    ];
+  };
+
+  targetPackages = {
+    linux-arm = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm"; version = "9.0.0-rc.1.24452.1"; hash = "sha256-eC46DyuObx9VhFP4PyY/3JWqAck8bW4Bt2hZyuapLRY="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-arm"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-6WaE1hKyIBnsTe3YlVP/lHR9HOnMkYtqDZEZLzidFAc="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-arm"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-u7sukf/qUk+gUVxFj/r9rzkQTVUcg2SqNhOmhPOsEyg="; })
+      (fetchNupkg { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-pYPVNaL6x5zRCBxCsPso8Ae0k9aaDbvH0aHS+j5pdIs="; })
+    ];
+    linux-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "9.0.0-rc.1.24452.1"; hash = "sha256-hKCalXcwzlgMLwthSnTcHkDOW1g2XUo4Kj49uryZvt8="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-qlxs6pqhMQHkvOkJY37f9VMlxwnjUffue656XJaRLWI="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-h1FtdGrQp0HjK8fJajK1h5YV9fgBZCBQOH9M4pqMamE="; })
+      (fetchNupkg { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-EBCX8Uvy+Z40i+VjuUK+F5CAZYblQLKzAExfx/uQ+gE="; })
+    ];
+    linux-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "9.0.0-rc.1.24452.1"; hash = "sha256-KmyOl6C8u/PrCAMiY/KwELYvRafnM4SfcnEhKvU5BeU="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-Q41rpitFgIbgUpIh7iGzXTaCVDoUoDJ7HYddW2krHAE="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-bsQyjyidOkZLtjR1JadsIkRp6gDlHjEsJEbNLgKGtdE="; })
+      (fetchNupkg { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-2YfhVuvSJe2sIkPFgocqAJubbb1PU7r93YoICq3ntAo="; })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm"; version = "9.0.0-rc.1.24452.1"; hash = "sha256-oPUyQZ9bGNbk6yPeIAQkNmDmDNcq3o2jFIsunotBBps="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-musl-arm"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-CBwqR3ii9Yg3O9lG/UAFaltVHmH5aFk2r8+IV1zeIS4="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-Uw965RIeMJJ3uV5xX6WWGVq8i+CHXpiOw1mOT6rPmFI="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-JBUxkn0eUboAElHl+o2LyC7f9eJz4jJ9/odxXa43FSM="; })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64"; version = "9.0.0-rc.1.24452.1"; hash = "sha256-ZsUpPpaD4cfjTnTPAw1VqKHYX51XFG1ck0Ae2dWUKt8="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-musl-arm64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-RY5CrQ9K9VZeh8+1r8Rjg0gEFBBRqR5EGTFkBfx0+3Q="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-FG9CGm1wZlMzKGzr70+qg62NLmYot0uG9yilyoEBpmw="; })
+      (fetchNupkg { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-QtCqH/Ah7EW2lNWHq9y4sAQI+8XOWMLBrqPIuDEV1ic="; })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-x64"; version = "9.0.0-rc.1.24452.1"; hash = "sha256-wdwHZFStEDDU0v8nah6hylLErKUxC9x3CvgL/9Qcfwo="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.linux-musl-x64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-QnGhafheornOKm2H+UO9M+a57S7OzU7oomMp1Gs+qcQ="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.linux-musl-x64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-v8J9etz1hP2q02KbUjKxDUc8So2qlzajFCDbM9N9TiE="; })
+      (fetchNupkg { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-HZS5qup9w2rWf1K5zIq7BEYTi8BC5co+Mz9Ey7iOcPc="; })
+    ];
+    osx-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64"; version = "9.0.0-rc.1.24452.1"; hash = "sha256-hSj4rqdeeerbuFQT7DI38eIOI3XUUun7nfi4ypPyggU="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.osx-arm64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-4sp79lNVzgWRV2l1WjURkZBTq13OTRPfoRsaWU1Kd+Q="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.osx-arm64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-JT2SL5C1RXS80C7hB+YcCHW9Nynq4+1dCd4nckZVDsM="; })
+      (fetchNupkg { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-pnE0Z0AxP+2tiQT72EIjrsfRxN9q/rWQ/5J1SIF8rVg="; })
+    ];
+    osx-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.osx-x64"; version = "9.0.0-rc.1.24452.1"; hash = "sha256-DO5bDJGbzav8ji/1Wp5+VCU2xd/7P+tD8eMCBCeisq0="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.osx-x64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-ORBkaFVuxvBBcqo0vklECC72Paoy13E33gt/ctHojq0="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.osx-x64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-oFvsMtKz+O9/B7asuc2DsH8KhRhAdS4D6qR64O8dE48="; })
+      (fetchNupkg { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-sXYAaSQvdrsknqu85ZzDfRFKQ3lKxPmK3CeYJwJ/u78="; })
+    ];
+    win-arm64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.win-arm64"; version = "9.0.0-rc.1.24452.1"; hash = "sha256-/GFhQQTpATa+eVsIKIS5hYQwEzueYT7IClqfTuO7OiY="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.win-arm64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-DJWq3FrbwU6QCJLuMWKFvQhwrszUHIHbZEi+cjnUkAI="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.win-arm64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-NtpJ9HN+LvXLb/qBn3Dz5XGTqhrlB8oUFCzge9zkxJ0="; })
+      (fetchNupkg { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-quzQ5GEyFmdsn7VXSsjSFHIcYnHwxb3OXP5Rcnar7mw="; })
+    ];
+    win-x64 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.win-x64"; version = "9.0.0-rc.1.24452.1"; hash = "sha256-53HpBsY1A7xFKDSKW+yMjoTdK+calt2k8z1XQbIx39I="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.win-x64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-zzq0pwTb9ayiuFijGfhXPyIk7YsGu1Q611CvHhPAGPM="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.win-x64"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-WUB7TDKuqe/+vZMdwtmb8yst0+6STi/H7gf1jmb0adw="; })
+      (fetchNupkg { pname = "runtime.win-x64.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-mc6g5oRPUbsFFwn5KDeY0LbzLGlyiPZxAhtjGEsIh+I="; })
+    ];
+    win-x86 = [
+      (fetchNupkg { pname = "Microsoft.AspNetCore.App.Runtime.win-x86"; version = "9.0.0-rc.1.24452.1"; hash = "sha256-lMVZtEPD48KKReYFsJ2rmJzCvlQNkGvajbfmd/ZYfFA="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Host.win-x86"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-mHRvOES1i3VCmHfyQOakMNyvvJYS0xGdF8YFNpTEDx8="; })
+      (fetchNupkg { pname = "Microsoft.NETCore.App.Runtime.win-x86"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-X29sAPaFb6yZptgoQK6QnRKbLRmmkrnvWw2zHC1MHE8="; })
+      (fetchNupkg { pname = "runtime.win-x86.Microsoft.NETCore.DotNetAppHost"; version = "9.0.0-rc.1.24431.7"; hash = "sha256-8LP07HWuRAyUGk5aSIpBHcAso16yM6UQ7YbPAen0Zgs="; })
+    ];
+  };
+
 in rec {
   release_9_0 = "9.0.0-rc.1";
 
   aspnetcore_9_0 = buildAspNetCore {
     version = "9.0.0-rc.1.24452.1";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/da25731f-e296-4e2a-8f2b-0213d26e1799/859039cd012f8cfba53991f8f5543609/aspnetcore-runtime-9.0.0-rc.1.24452.1-linux-x64.tar.gz";
-        sha512  = "f8fd285d67bb044d631596869d6301e10a2a243c81c9a05096a66aff4fb3431529812c7482e6cf0e065e8e065fc50b16b50d7f2a495ab30077a68bd45b3ba376";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/c414fabc-f831-4c5d-af5e-8e85ebecc6a0/670acec9f83315bec2788393db85e708/aspnetcore-runtime-9.0.0-rc.1.24452.1-linux-arm.tar.gz";
+        hash = "sha512-EgHd12xUpnbLKHRD7xszFtCHufNVfHl/ckzU/LhphutJmzEilZskl2RE4mIoXAWooPjz8oKJRjHlj6TeQrtUiQ==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/c5075cd5-2552-4f77-96ce-31450f9ff8d5/e6ff2b52e2a27a60eb3585cbca01d60b/aspnetcore-runtime-9.0.0-rc.1.24452.1-linux-arm64.tar.gz";
-        sha512  = "84610a38fb9a98eb7bd26ba89a9c4998682ec3fffb5eade5bbafbafd63cac7d9a5279618bb5b2575d27feec098da5fe6f7150c67253f3f37762601590396e122";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/c5075cd5-2552-4f77-96ce-31450f9ff8d5/e6ff2b52e2a27a60eb3585cbca01d60b/aspnetcore-runtime-9.0.0-rc.1.24452.1-linux-arm64.tar.gz";
+        hash = "sha512-hGEKOPuamOt70muompxJmGguw//7Xq3lu6+6/WPKx9mlJ5YYu1slddJ/7sCY2l/m9xUMZyU/Pzd2JgFZA5bhIg==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/b0414fd7-20f9-4363-9dbf-072880e97b17/89584fa06e9ba1154a7e02402a28d82f/aspnetcore-runtime-9.0.0-rc.1.24452.1-osx-x64.tar.gz";
-        sha512  = "ff4a6e35b41f5200521ea4b257b293e4d48f1786ccaa9cd85b55ba96ad36036dbc149d2ff820f1dff5f2d9acf6c38b6c3540e700c2c2db5fe6d82d4f85f461ae";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/da25731f-e296-4e2a-8f2b-0213d26e1799/859039cd012f8cfba53991f8f5543609/aspnetcore-runtime-9.0.0-rc.1.24452.1-linux-x64.tar.gz";
+        hash = "sha512-+P0oXWe7BE1jFZaGnWMB4QoqJDyByaBQlqZq/0+zQxUpgSx0gubPDgZejgZfxQsWtQ1/KklaswB3povUWzujdg==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/0bae8dff-9440-4388-a03e-af44e20673a8/8ab257a4963967970cd59c31c213f38d/aspnetcore-runtime-9.0.0-rc.1.24452.1-osx-arm64.tar.gz";
-        sha512  = "03f7e03352d1ad2d54e9de4c1cdd7a94c2311bb36d4c6296661fab286cddebf3f57204f73892efd53f43cfb13ba73cafae95d0522c47be03203d5fb69a0ecfe9";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/8d4492ed-c733-4cfc-bf16-4f13191587f2/c843723067d5fc1d790ffa1810c683c1/aspnetcore-runtime-9.0.0-rc.1.24452.1-linux-musl-arm.tar.gz";
+        hash = "sha512-Kdvu4spDebM0V+KwVliBFPoxgTUGxTWaIxRfI6QdBj0F6qCX6hF2I6QPqxE1FrRRUL0XovBXKHViwz/pFovymQ==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/bc3735cb-fea1-4f97-8669-3ab0e389d055/084b94228b13a45478ac75f5158801b3/aspnetcore-runtime-9.0.0-rc.1.24452.1-linux-musl-arm64.tar.gz";
+        hash = "sha512-n08aOk85N3d5v092zguXYxAtnKYX/99h/3Wg2Bxcxj+1BCcI/xCxqD5VgFDZuVu68Vn6d+J8wD4K00NEHhZLXg==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/10aac5f7-c037-4874-8c05-425e668b0a24/4706d38e511259862e93a61f15dda28f/aspnetcore-runtime-9.0.0-rc.1.24452.1-linux-musl-x64.tar.gz";
+        hash = "sha512-D5RfnHYZkY1hmmbPtsiwH9mTlDjOjvi+B5f66ky9c87eb9JcIlhV77eTvmcL/A9xmOnyMfoFEdfPMZ0vq7rJ0w==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/0bae8dff-9440-4388-a03e-af44e20673a8/8ab257a4963967970cd59c31c213f38d/aspnetcore-runtime-9.0.0-rc.1.24452.1-osx-arm64.tar.gz";
+        hash = "sha512-A/fgM1LRrS1U6d5MHN16lMIxG7NtTGKWZh+rKGzd6/P1cgT3OJLv1T9Dz7E7pzyvrpXQUixHvgMgPV+2mg7P6Q==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/b0414fd7-20f9-4363-9dbf-072880e97b17/89584fa06e9ba1154a7e02402a28d82f/aspnetcore-runtime-9.0.0-rc.1.24452.1-osx-x64.tar.gz";
+        hash = "sha512-/0puNbQfUgBSHqSyV7KT5NSPF4bMqpzYW1W6lq02A228FJ0v+CDx3/Xy2az2w4tsNUDnAMLC21/m2C1PhfRhrg==";
       };
     };
   };
@@ -98,21 +168,37 @@ in rec {
   runtime_9_0 = buildNetRuntime {
     version = "9.0.0-rc.1.24431.7";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/72048153-7c19-4e69-bcf3-22563060db07/cd181715a0f7cd3cec8c87b115181da9/dotnet-runtime-9.0.0-rc.1.24431.7-linux-x64.tar.gz";
-        sha512  = "9f9a85b8d9f6362ed2c2d0edefd04999181b2c386647644fbc1d9f248255387324399edb1c40bc7fa8c47adc22e2d71db5f25ce794521d59e46c40593b5f6cc5";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/26c238f2-53a2-4fdc-981e-31272c80d107/67c11b008d57d501cd2e5ca642cbc8c1/dotnet-runtime-9.0.0-rc.1.24431.7-linux-arm.tar.gz";
+        hash = "sha512-ioPeMA6PnsZ/cFAE9VIpVz3Yv7EG9sQjie+ylsI4buJ4Rvgbqv5rQmnpxyaQN+XsPxN2xyvBA+RkHJGBp+V2Rw==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/54f6fb3b-da5b-4a2d-98f4-ae07c814a586/e5f2a5ba551ffe53ea1c2ae9b7681f0b/dotnet-runtime-9.0.0-rc.1.24431.7-linux-arm64.tar.gz";
-        sha512  = "8542bb9381e4eca6f0ebceddec68525cc59e34f7244613cf33cb2151f570c3345cb6d081c492b01070e762d3440f02d4558234532d58ff3dc919057e06b7bdac";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/54f6fb3b-da5b-4a2d-98f4-ae07c814a586/e5f2a5ba551ffe53ea1c2ae9b7681f0b/dotnet-runtime-9.0.0-rc.1.24431.7-linux-arm64.tar.gz";
+        hash = "sha512-hUK7k4Hk7Kbw687d7GhSXMWeNPckRhPPM8shUfVwwzRcttCBxJKwEHDnYtNEDwLUVYI0Uy1Y/z3JGQV+Bre9rA==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/13d7d905-549f-44e8-9062-a678a742c5fb/94c51ca9c08ef9b5cceabafc2337118f/dotnet-runtime-9.0.0-rc.1.24431.7-osx-x64.tar.gz";
-        sha512  = "f62f867eab633737c450ffb0543a726f1ba2f46a4265cb47978d88dad0c6b80a8db5ccf6f583842f85cb613b96d2f7c6806d669826f4b92b906e71d8d10e53e8";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/72048153-7c19-4e69-bcf3-22563060db07/cd181715a0f7cd3cec8c87b115181da9/dotnet-runtime-9.0.0-rc.1.24431.7-linux-x64.tar.gz";
+        hash = "sha512-n5qFuNn2Ni7SwtDt79BJmRgbLDhmR2RPvB2fJIJVOHMkOZ7bHEC8f6jEetwi4tcdtfJc55RSHVnkbEBZO19sxQ==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/8abf3e03-1ab3-40fd-a9cf-fa22005be2e8/cb0c3c5d130ef8ae76a982860fd3606a/dotnet-runtime-9.0.0-rc.1.24431.7-osx-arm64.tar.gz";
-        sha512  = "a825fca9edde53ab6abc0efe0c44d6fb25c5c77aeb2d35b6c414d42f364453ceb069ed9db8865c2bb82523989fceb7cccbf86047699590ff756a6b9c54c21d74";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/c948e710-a590-4492-870d-1e44ce476a55/86522880c5160af3c81bfa71378b79b9/dotnet-runtime-9.0.0-rc.1.24431.7-linux-musl-arm.tar.gz";
+        hash = "sha512-ERibzBMUhpSROsX7BQt324EErGLdOblwzZau85n3p87mVqMUtE8BE/lnJufuCiad6jhjcCD+BiYaiwHKDfnktA==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/9ef6c8f0-49ac-4b37-9e7a-0f2cbbc74472/ceebdb8281a18bc80d17147ec3146cd0/dotnet-runtime-9.0.0-rc.1.24431.7-linux-musl-arm64.tar.gz";
+        hash = "sha512-3WKnNzaydaFbWv+jRloO89aWGaBsyqo5FrMx9Fs4WakCjnjrfNhcdm3v+5cDx7uWeI9AYdVJy98yW/gYlDEFIQ==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/30c11bec-b456-45de-bb45-5e892fd1a509/cd72910d2c8b0c908f717a3563c2445f/dotnet-runtime-9.0.0-rc.1.24431.7-linux-musl-x64.tar.gz";
+        hash = "sha512-vXcBXKRriSj3CmHmz+8jxeMIrUDAPd1CHCEBQbGjjNXE2O31Nl6LruIn21pqxx++pIHBqLPFum6lgzCv3X/iMQ==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/8abf3e03-1ab3-40fd-a9cf-fa22005be2e8/cb0c3c5d130ef8ae76a982860fd3606a/dotnet-runtime-9.0.0-rc.1.24431.7-osx-arm64.tar.gz";
+        hash = "sha512-qCX8qe3eU6tqvA7+DETW+yXFx3rrLTW2xBTULzZEU86wae2duIZcK7glI5ifzrfMy/hgR2mVkP91amucVMIddA==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/13d7d905-549f-44e8-9062-a678a742c5fb/94c51ca9c08ef9b5cceabafc2337118f/dotnet-runtime-9.0.0-rc.1.24431.7-osx-x64.tar.gz";
+        hash = "sha512-9i+GfqtjNzfEUP+wVDpybxui9GpCZctHl42I2tDGuAqNtcz29YOEL4XLYTuW0vfGgG1mmCb0uSuQbnHY0Q5T6A==";
       };
     };
   };
@@ -120,24 +206,40 @@ in rec {
   sdk_9_0_1xx = buildNetSdk {
     version = "9.0.100-rc.1.24452.12";
     srcs = {
-      x86_64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/3b2b3c23-574b-45d7-b2b0-c67f0e935308/23ed647eb71a8f07414124422c15927d/dotnet-sdk-9.0.100-rc.1.24452.12-linux-x64.tar.gz";
-        sha512  = "e8130817b779d0104a6eee33d98d97c3fad1c336013435f47c0e9e22370172b75da37ade76e49dec7cbe696884390d2e6941cc69e2bad5593d6d1c6b41083051";
+      linux-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/87c96627-cf20-47d7-8cb4-d5e083084dd4/07d4b533e746b344a3dbf9f7279f450b/dotnet-sdk-9.0.100-rc.1.24452.12-linux-arm.tar.gz";
+        hash = "sha512-8xpKLDCAqSHP3XGTPR9XwvV/9MQ/WgrW9SZAvHkeVPjAUm2OEgatIfhoI1elPPbUiKiwEQfnw0vq/iyMNCXdjA==";
       };
-      aarch64-linux = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/f7739964-9e84-4bb7-9435-509458a15f9c/a95ad7f9deb8ce2fd30173dfe86f55ba/dotnet-sdk-9.0.100-rc.1.24452.12-linux-arm64.tar.gz";
-        sha512  = "f5742537128801c199a127266175066058788a26e8a603cbd26a1c16e9ef33a5d418e4790a3cea722d7de483eee8b68e0de4bb1dfdf279713369ed3b4d163a11";
+      linux-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/f7739964-9e84-4bb7-9435-509458a15f9c/a95ad7f9deb8ce2fd30173dfe86f55ba/dotnet-sdk-9.0.100-rc.1.24452.12-linux-arm64.tar.gz";
+        hash = "sha512-9XQlNxKIAcGZoScmYXUGYFh4iibopgPL0mocFunvM6XUGOR5Cjzqci195IPu6LaODeS7Hf3yeXEzae07TRY6EQ==";
       };
-      x86_64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/e26e36f6-746f-462c-8599-5d0a1f00e786/f1b8264ac10442b40009aa8cea46b23b/dotnet-sdk-9.0.100-rc.1.24452.12-osx-x64.tar.gz";
-        sha512  = "0d1f0718eeef006c3ecfbefeebf9df0772ec22c74db4bb635b6463b8aedfd3957274b908b51ec019ced69d3e7af4ae9252f18e87b14a4411e1089a4cc41e37d0";
+      linux-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/3b2b3c23-574b-45d7-b2b0-c67f0e935308/23ed647eb71a8f07414124422c15927d/dotnet-sdk-9.0.100-rc.1.24452.12-linux-x64.tar.gz";
+        hash = "sha512-6BMIF7d50BBKbu4z2Y2Xw/rRwzYBNDX0fA6eIjcBcrddo3reduSd7Hy+aWiEOQ0uaUHMaeK61Vk9bRxrQQgwUQ==";
       };
-      aarch64-darwin = {
-        url     = "https://download.visualstudio.microsoft.com/download/pr/930f4eb8-188f-47d5-8a26-28ca393b7d1b/c07a519e3d7e326c3f640ef72ea1193e/dotnet-sdk-9.0.100-rc.1.24452.12-osx-arm64.tar.gz";
-        sha512  = "af30b31cd937e9fc97e164b83628c2c1ecd21329b75f742d9f5232aa68427d25b5d702cc565aa860d3c738c8727790569bf66a3ed74e5cef719ae589d302846f";
+      linux-musl-arm = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/8cb683aa-4558-45ac-944a-73ac40b708d2/2795bd0253d5518490378edc7f7b562e/dotnet-sdk-9.0.100-rc.1.24452.12-linux-musl-arm.tar.gz";
+        hash = "sha512-hICQDhS9EDT1hsPhdAK+LwTKslDXm00d2jqoh+n6+mg604it9/JbXHsNxDM3XOHCcrPZQZY25tsPe/MA6EGgpQ==";
+      };
+      linux-musl-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/8737d284-0c4b-49a0-984c-23fddc7abcd8/ada586539e4417b557d60d0214e8b2eb/dotnet-sdk-9.0.100-rc.1.24452.12-linux-musl-arm64.tar.gz";
+        hash = "sha512-ZWv6TnxKPuKAuZ6v+mILCbibOjufbTPJ14fB+JOLhK+1qkPYBUboGiv9UydwwoLFmuoWf1DQGlcCeiBh5ZXw6Q==";
+      };
+      linux-musl-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/791e9a41-59da-4f92-9dfb-2cceaaea001b/710f7adf35dc2f32be49ac2834ad0afd/dotnet-sdk-9.0.100-rc.1.24452.12-linux-musl-x64.tar.gz";
+        hash = "sha512-sdgATPnD/7Uw+7PUJZF0ywdqMroAJo2qQ9v0Uv5tRsz5eaY9f1OucKL6ehAanfG9O4QFUqySqFIRm7c4WmX2Xw==";
+      };
+      osx-arm64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/930f4eb8-188f-47d5-8a26-28ca393b7d1b/c07a519e3d7e326c3f640ef72ea1193e/dotnet-sdk-9.0.100-rc.1.24452.12-osx-arm64.tar.gz";
+        hash = "sha512-rzCzHNk36fyX4WS4NijCwezSEym3X3Qtn1IyqmhCfSW11wLMVlqoYNPHOMhyd5BWm/ZqPtdOXO9xmuWJ0wKEbw==";
+      };
+      osx-x64 = {
+        url = "https://download.visualstudio.microsoft.com/download/pr/e26e36f6-746f-462c-8599-5d0a1f00e786/f1b8264ac10442b40009aa8cea46b23b/dotnet-sdk-9.0.100-rc.1.24452.12-osx-x64.tar.gz";
+        hash = "sha512-DR8HGO7vAGw+z77+6/nfB3LsIsdNtLtjW2RjuK7f05VydLkItR7AGc7WnT569K6SUvGOh7FKRBHhCJpMxB430A==";
       };
     };
-    inherit packages;
+    inherit commonPackages hostPackages targetPackages;
   };
 
   sdk_9_0 = sdk_9_0_1xx;
diff --git a/pkgs/development/compilers/dotnet/vmr.nix b/pkgs/development/compilers/dotnet/vmr.nix
index e9124e115f98..5099b91d2a6b 100644
--- a/pkgs/development/compilers/dotnet/vmr.nix
+++ b/pkgs/development/compilers/dotnet/vmr.nix
@@ -27,7 +27,7 @@
   unzip,
   yq,
 
-  dotnetSdk,
+  bootstrapSdk,
   releaseManifestFile,
   tarballHash,
 }:
@@ -93,7 +93,7 @@ stdenv.mkDerivation rec {
   buildInputs =
     [
       # this gets copied into the tree, but we still want the hooks to run
-      dotnetSdk
+      bootstrapSdk
       # the propagated build inputs in llvm.dev break swift compilation
       llvm.out
       zlib
@@ -145,7 +145,7 @@ stdenv.mkDerivation rec {
   postPatch =
     ''
       # set the sdk version in global.json to match the bootstrap sdk
-      jq '(.tools.dotnet=$dotnet)' global.json --arg dotnet "$(${dotnetSdk}/bin/dotnet --version)" > global.json~
+      jq '(.tools.dotnet=$dotnet)' global.json --arg dotnet "$(${bootstrapSdk}/bin/dotnet --version)" > global.json~
       mv global.json{~,}
 
       patchShebangs $(find -name \*.sh -type f -executable)
@@ -334,7 +334,7 @@ stdenv.mkDerivation rec {
     "--no-artifacts"
     "--no-prebuilts"
     "--with-packages"
-    dotnetSdk.artifacts
+    bootstrapSdk.artifacts
   ];
 
   configurePhase =
@@ -346,7 +346,7 @@ stdenv.mkDerivation rec {
 
       # The build process tries to overwrite some things in the sdk (e.g.
       # SourceBuild.MSBuildSdkResolver.dll), so it needs to be mutable.
-      cp -Tr ${dotnetSdk} .dotnet
+      cp -Tr ${bootstrapSdk} .dotnet
       chmod -R +w .dotnet
 
       ${prepScript} $prepFlags
@@ -369,7 +369,7 @@ stdenv.mkDerivation rec {
   buildFlags =
     [
       "--with-packages"
-      dotnetSdk.artifacts
+      bootstrapSdk.artifacts
       "--clean-while-building"
       "--release-manifest"
       releaseManifestFile
diff --git a/pkgs/development/python-modules/clr-loader/default.nix b/pkgs/development/python-modules/clr-loader/default.nix
index 583cf34320e4..90006a6fe44e 100644
--- a/pkgs/development/python-modules/clr-loader/default.nix
+++ b/pkgs/development/python-modules/clr-loader/default.nix
@@ -36,9 +36,7 @@ buildPythonPackage {
 
   format = "pyproject";
 
-  buildInputs = [
-    dotnetCorePackages.sdk_6_0.packages
-  ] ++ dotnet-build.nugetDeps;
+  buildInputs = dotnetCorePackages.sdk_6_0.packages ++ dotnet-build.nugetDeps;
 
   nativeBuildInputs = [
     setuptools

From 3fb0ab6f5936466896b49c0cca094ff4cc5a6974 Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Sat, 21 Sep 2024 15:05:39 -0300
Subject: [PATCH 09/14] dotnet: disable restore in test project creation

---
 pkgs/development/compilers/dotnet/common.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkgs/development/compilers/dotnet/common.nix b/pkgs/development/compilers/dotnet/common.nix
index 4858e99eaa71..426eb848d869 100644
--- a/pkgs/development/compilers/dotnet/common.nix
+++ b/pkgs/development/compilers/dotnet/common.nix
@@ -86,7 +86,7 @@ stdenv.mkDerivation (
                 unpackPhase = ''
                   mkdir test
                   cd test
-                  dotnet new ${template} -o .
+                  dotnet new ${template} -o . --no-restore
                 '';
                 buildPhase = build;
                 dontPatchELF = true;

From 00fe5f61bafc8ef87f495747ea9da3ba2f2f17ee Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Sat, 21 Sep 2024 15:19:51 -0300
Subject: [PATCH 10/14] buildDotnetModule: remove duplicate attribute key

---
 pkgs/build-support/dotnet/build-dotnet-module/default.nix | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pkgs/build-support/dotnet/build-dotnet-module/default.nix b/pkgs/build-support/dotnet/build-dotnet-module/default.nix
index bffdcd6e1315..950a17b8b256 100644
--- a/pkgs/build-support/dotnet/build-dotnet-module/default.nix
+++ b/pkgs/build-support/dotnet/build-dotnet-module/default.nix
@@ -216,7 +216,6 @@ stdenvNoCC.mkDerivation (
       "projectFile"
       "projectReferences"
       "runtimeDeps"
-      "runtimeId"
       "disabledTests"
       "testProjectFile"
       "buildType"

From 9bb309d5b5021ea4f25955eb9b1db5e994086fda Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Sat, 21 Sep 2024 20:49:19 -0300
Subject: [PATCH 11/14] buildDotnetModule: set --no-restore in
 check/publish/pack

---
 .../dotnet/build-dotnet-module/hooks/dotnet-check-hook.sh       | 1 +
 .../dotnet/build-dotnet-module/hooks/dotnet-install-hook.sh     | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-check-hook.sh b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-check-hook.sh
index 21ebbbe5381e..38ded5874ad2 100644
--- a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-check-hook.sh
+++ b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-check-hook.sh
@@ -62,6 +62,7 @@ dotnetCheckHook() {
                 -p:ContinuousIntegrationBuild=true \
                 -p:Deterministic=true \
                 --configuration "$dotnetBuildType" \
+                --no-restore \
                 --no-build \
                 --logger "console;verbosity=normal" \
                 "${runtimeIdFlagsArray[@]}" \
diff --git a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-install-hook.sh b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-install-hook.sh
index cdd4a50f5d2e..7b008a26d1c6 100644
--- a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-install-hook.sh
+++ b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-install-hook.sh
@@ -55,6 +55,7 @@ dotnetInstallHook() {
                 -p:OverwriteReadOnlyFiles=true \
                 --output "$dotnetInstallPath" \
                 --configuration "$dotnetBuildType" \
+                --no-restore \
                 --no-build \
                 "${runtimeIdFlagsArray[@]}" \
                 "${dotnetInstallFlagsArray[@]}" \
@@ -73,6 +74,7 @@ dotnetInstallHook() {
                    -p:OverwriteReadOnlyFiles=true \
                    --output "$out/share/nuget/source" \
                    --configuration "$dotnetBuildType" \
+                   --no-restore \
                    --no-build \
                    --runtime "$runtimeId" \
                    "${dotnetPackFlagsArray[@]}" \

From ae7b2ae6ee2123d71da1c8dd1658bb019c8c07a0 Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Sat, 21 Sep 2024 21:41:40 -0300
Subject: [PATCH 12/14] dotnet-sdk-setup-hook: fix typo in cd

---
 pkgs/development/compilers/dotnet/dotnet-sdk-setup-hook.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkgs/development/compilers/dotnet/dotnet-sdk-setup-hook.sh b/pkgs/development/compilers/dotnet/dotnet-sdk-setup-hook.sh
index b36f3dfd7059..1e7908b049f0 100644
--- a/pkgs/development/compilers/dotnet/dotnet-sdk-setup-hook.sh
+++ b/pkgs/development/compilers/dotnet/dotnet-sdk-setup-hook.sh
@@ -135,7 +135,7 @@ configureNuget() {
                         -s '/configuration/packageSourceMapping/packageSource[@key="_nix"]' -t elem -n package
                         -i \$prev -t attr -n pattern -v "$id")
                 done
-                cd - < /dev/null
+                cd - > /dev/null
             else
                 xmlConfigArgs+=(
                     "${xmlSourceConfigArgs[@]}"

From 0774f8f9c2e57abde884bd212dd87491e571ddd9 Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Sun, 22 Sep 2024 16:44:07 -0300
Subject: [PATCH 13/14] dotnet: add patch to fix fetch-deps in dotnet 9 VMR

---
 ...gPackageSourcesMappings-don-t-add-em.patch | 30 +++++++++++++++++++
 pkgs/development/compilers/dotnet/vmr.nix     |  4 ++-
 2 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 pkgs/development/compilers/dotnet/UpdateNuGetConfigPackageSourcesMappings-don-t-add-em.patch

diff --git a/pkgs/development/compilers/dotnet/UpdateNuGetConfigPackageSourcesMappings-don-t-add-em.patch b/pkgs/development/compilers/dotnet/UpdateNuGetConfigPackageSourcesMappings-don-t-add-em.patch
new file mode 100644
index 000000000000..089b8b0fcaab
--- /dev/null
+++ b/pkgs/development/compilers/dotnet/UpdateNuGetConfigPackageSourcesMappings-don-t-add-em.patch
@@ -0,0 +1,30 @@
+From 93137ea040472f4042dd186427699ad249e7251b Mon Sep 17 00:00:00 2001
+From: David McFarland <corngood@gmail.com>
+Date: Sun, 22 Sep 2024 16:41:07 -0300
+Subject: [PATCH] UpdateNuGetConfigPackageSourcesMappings: don't add empty
+ mappings
+
+---
+ .../UpdateNuGetConfigPackageSourcesMappings.cs              | 6 +++++-
+ 1 file changed, 5 insertions(+), 1 deletion(-)
+
+diff --git a/eng/tools/tasks/Microsoft.DotNet.UnifiedBuild.Tasks/UpdateNuGetConfigPackageSourcesMappings.cs b/eng/tools/tasks/Microsoft.DotNet.UnifiedBuild.Tasks/UpdateNuGetConfigPackageSourcesMappings.cs
+index 3b188c1801..9b7050ef46 100644
+--- a/eng/tools/tasks/Microsoft.DotNet.UnifiedBuild.Tasks/UpdateNuGetConfigPackageSourcesMappings.cs
++++ b/eng/tools/tasks/Microsoft.DotNet.UnifiedBuild.Tasks/UpdateNuGetConfigPackageSourcesMappings.cs
+@@ -115,7 +115,11 @@ namespace Microsoft.DotNet.UnifiedBuild.Tasks
+                 // Skip sources with zero package patterns
+                 if (allSourcesPackages[packageSource]?.Count > 0)
+                 {
+-                    pkgSrcMappingClearElement.AddAfterSelf(GetPackageMappingsElementForSource(packageSource));
++                    var pkgSrc = GetPackageMappingsElementForSource(packageSource);
++                    if (pkgSrc.Elements().Any())
++                    {
++                        pkgSrcMappingClearElement.AddAfterSelf(pkgSrc);
++                    }
+                 }
+             }
+ 
+-- 
+2.46.0
+
diff --git a/pkgs/development/compilers/dotnet/vmr.nix b/pkgs/development/compilers/dotnet/vmr.nix
index 5099b91d2a6b..2c95d7d6ee6b 100644
--- a/pkgs/development/compilers/dotnet/vmr.nix
+++ b/pkgs/development/compilers/dotnet/vmr.nix
@@ -138,7 +138,9 @@ stdenv.mkDerivation rec {
                        (global-name "com.apple.system.opendirectoryd.membership"))
   '';
 
-  patches = lib.optionals (lib.versionOlder version "9") [
+  patches = lib.optionals (lib.versionAtLeast version "9") [
+    ./UpdateNuGetConfigPackageSourcesMappings-don-t-add-em.patch
+  ] ++ lib.optionals (lib.versionOlder version "9") [
     ./fix-aspnetcore-portable-build.patch
   ];
 

From 505bcb2595a72024de26b69a102f790a6ef4ca4a Mon Sep 17 00:00:00 2001
From: David McFarland <corngood@gmail.com>
Date: Sun, 22 Sep 2024 19:41:58 -0300
Subject: [PATCH 14/14] tagger: update lockfile after VMR package improvements

---
 pkgs/applications/audio/tagger/deps.nix | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/pkgs/applications/audio/tagger/deps.nix b/pkgs/applications/audio/tagger/deps.nix
index 76ab54d97096..231c388ebe67 100644
--- a/pkgs/applications/audio/tagger/deps.nix
+++ b/pkgs/applications/audio/tagger/deps.nix
@@ -28,10 +28,7 @@
   (fetchNuGet { pname = "MetaBrainz.MusicBrainz"; version = "6.1.0"; hash = "sha256-wZBTTSQNPll/5/sZPPxa6d0QBjwA8FLA2vFE/838VWs="; })
   (fetchNuGet { pname = "MetaBrainz.MusicBrainz.CoverArt"; version = "6.0.0"; hash = "sha256-yN+godNeB6l8ihNupq9cNe+PaYaPTngHJzwkMH9ySbE="; })
   (fetchNuGet { pname = "Meziantou.Framework.Win32.CredentialManager"; version = "1.4.5"; hash = "sha256-aJyLlVg6jKY2Van0hwAC5JEF/j+YtEq5ZFLkyI3scsY="; })
-  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "8.0.6"; hash = "sha256-wvudYblAZ5vOdQ/3Ssl24exAXRkhOG7KBZUjquLGo5o="; })
   (fetchNuGet { pname = "Microsoft.Data.Sqlite.Core"; version = "8.0.0"; hash = "sha256-aew8/vRyzCc7MMNHziR8tsg66EFkJC+Snst3F+a3Ehc="; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "8.0.6"; hash = "sha256-7kLTos2RiNJOmxg6NcM8QieifWMHgxHgd5e+DBNQI0Q="; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "8.0.6"; hash = "sha256-oAQI/uV0G/uEFp+2yAyhILZ6hr9t+oWh9TEY646Vphk="; })
   (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "5.0.0"; hash = "sha256-5rFBJ8Fkw7+11iCG9nMVhOqPCpyVIrbUzrFQhc/2eHw="; })
   (fetchNuGet { pname = "Microsoft.Win32.SystemEvents"; version = "8.0.0"; hash = "sha256-UcxurEamYD+Bua0PbPNMYAZaRulMrov8CfbJGIgTaRQ="; })
   (fetchNuGet { pname = "Nickvision.Aura"; version = "2023.11.4"; hash = "sha256-us9K5RayuZGe2fkhk/c2Qw45gKmrfvyNBvHdcOnzWj0="; })