Merge

2020-06-09 16:29:17 -07:00 · 2020-06-09 16:29:17 -07:00 · 5267e21dbb
parent 9e38dcf1fc 24b9e84276
commit 5267e21dbb
12456 changed files with 875701 additions and 808413 deletions
--- a/.azure/pipelines/benchmarks.yml
+++ b/.azure/pipelines/benchmarks.yml
@ -0,0 +1,18 @@
+# This configuration builds the repository and runs benchmarks
+
+# Don't run CI for this config
+trigger: none
+
+pr:
+- '*'
+
+jobs:
+- template: jobs/default-build.yml
+  parameters:
+    jobName: Windows_Build
+    jobDisplayName: "Build only : Windows"
+    agentOs: Windows
+    buildArgs: -ci -all -pack
+    artifacts:
+    - path: artifacts/
+      includeForks: true
--- a/.azure/pipelines/ci.yml
+++ b/.azure/pipelines/ci.yml
@ -1,28 +1,746 @@
-# Don't run CI for this config yet. We're not ready to move official builds on to Azure Pipelines
-trigger: none
+#
+# See https://docs.microsoft.com/en-us/vsts/pipelines/yaml-schema for details on this file.
+#
+
+# Configure which branches trigger builds
+trigger:
+  batch: true
+  branches:
+    include:
+    - master
+    - release/*
+    - internal/release/3.*

 # Run PR validation on all branches
 pr:
+  autoCancel: true
  branches:
    include:
    - '*'

-jobs:
- template: jobs/default-build.yml
-  parameters:
-    jobName: Windows_Build
-    jobDisplayName: "Build and test: Windows"
-    agentOs: Windows
-    beforeBuild:
-    - powershell: "& ./src/Servers/IIS/tools/UpdateIISExpressCertificate.ps1"
-      displayName: Setup IISExpress test certificates
- template: jobs/default-build.yml
-  parameters:
-    jobName: macOs_Build
-    jobDisplayName: "Build and test : macOS"
-    agentOs: macOS
- template: jobs/default-build.yml
-  parameters:
-    jobName: Linux_Build
-    jobDisplayName: "Build and test : Linux"
-    agentOs: Linux
+variables:
+- name: DOTNET_SKIP_FIRST_TIME_EXPERIENCE
+  value: true
+- name: _TeamName
+  value:  AspNetCore
+- name: _DotNetPublishToBlobFeed
+  value: true
+- name: _PublishUsingPipelines
+  value: true
+- name: _DotNetArtifactsCategory
+  value: .NETCORE
+- name: _DotNetValidationArtifactsCategory
+  value: .NETCORE
+- ${{ if ne(variables['System.TeamProject'], 'internal') }}:
+  - name: _BuildArgs
+    value: ''
+  - name: _PublishArgs
+    value: ''
+  - name: _SignType
+    value: ''
+  - name: _InternalRuntimeDownloadArgs
+    value: ''
+  - name: _InternalRuntimeDownloadCodeSignArgs
+    value: ''
+- ${{ if eq(variables['System.TeamProject'], 'internal') }}:
+  - group: DotNet-MSRC-Storage
+  - name: _InternalRuntimeDownloadArgs
+    value: -DotNetRuntimeSourceFeed https://dotnetclimsrc.blob.core.windows.net/dotnet -DotNetRuntimeSourceFeedKey $(dotnetclimsrc-read-sas-token-base64) /p:DotNetAssetRootAccessTokenSuffix='$(dotnetclimsrc-read-sas-token-base64)'
+  # The code signing doesn't use the aspnet build scripts, so the msbuild parameers have
+  # to be passed directly. This is awkward, since we pass the same info above, but we have
+  # to have it in two different forms
+  - name: _InternalRuntimeDownloadCodeSignArgs
+    value: /p:DotNetRuntimeSourceFeed=https://dotnetclimsrc.blob.core.windows.net/dotnet /p:DotNetRuntimeSourceFeedKey=$(dotnetclimsrc-read-sas-token-base64)
+  - ${{ if notin(variables['Build.Reason'], 'PullRequest') }}:
+    # DotNet-Blob-Feed provides: dotnetfeed-storage-access-key-1
+    # Publish-Build-Assets provides: MaestroAccessToken, BotAccount-dotnet-maestro-bot-PAT
+    - group: DotNet-Blob-Feed
+    - group: Publish-Build-Assets
+
+    - name: _BuildArgs
+      value: /p:TeamName=$(_TeamName)
+             /p:OfficialBuildId=$(Build.BuildNumber)
+    - name: _SignType
+      value: real
+
+    # The following extra properties are not set when testing. Use with final build.[cmd,sh] of asset-producing jobs.
+    - name: _PublishArgs
+      value: /p:Publish=true
+             /p:GenerateChecksums=true
+             /p:DotNetPublishBlobFeedKey=$(dotnetfeed-storage-access-key-1)
+             /p:DotNetPublishBlobFeedUrl=https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json
+             /p:DotNetPublishToBlobFeed=$(_DotNetPublishToBlobFeed)
+             /p:DotNetPublishUsingPipelines=$(_PublishUsingPipelines)
+             /p:DotNetArtifactsCategory=$(_DotNetArtifactsCategory)
+
+  - ${{ if in(variables['Build.Reason'], 'PullRequest') }}:
+    - name: _BuildArgs
+      value: ''
+    - name: _SignType
+      value: test
+    - name: _PublishArgs
+      value: ''
+
+stages:
+- stage: build
+  displayName: Build
+  jobs:
+  # Code check
+  - ${{ if or(eq(variables['System.TeamProject'], 'public'), in(variables['Build.Reason'], 'PullRequest')) }}:
+    - template: jobs/default-build.yml
+      parameters:
+        jobName: Code_check
+        jobDisplayName: Code check
+        agentOs: Windows
+        steps:
+        - ${{ if ne(variables['System.TeamProject'], 'public') }}:
+          - task: PowerShell@2
+            displayName: Setup Private Feeds Credentials
+            inputs:
+              filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.ps1
+              arguments: -ConfigFile $(Build.SourcesDirectory)/NuGet.config -Password $Env:Token
+            env:
+              Token: $(dn-bot-dnceng-artifact-feeds-rw)
+        - powershell: ./eng/scripts/CodeCheck.ps1 -ci $(_InternalRuntimeDownloadArgs)
+          displayName: Run eng/scripts/CodeCheck.ps1
+        artifacts:
+        - name: Code_Check_Logs
+          path: artifacts/log/
+          publishOnError: true
+          includeForks: true
+
+  # Build Windows (x64/x86)
+  - template: jobs/default-build.yml
+    parameters:
+      codeSign: true
+      jobName: Windows_build
+      jobDisplayName: "Build: Windows x64/x86"
+      agentOs: Windows
+      steps:
+      - script: "echo ##vso[build.addbuildtag]daily-build"
+        condition: and(notin(variables['Build.Reason'], 'PullRequest'), notin(variables['DotNetFinalVersionKind'], 'release', 'prerelease'))
+        displayName: 'Set CI tags'
+      - script: "echo ##vso[build.addbuildtag]release-candidate"
+        condition: and(notin(variables['Build.Reason'], 'PullRequest'), in(variables['DotNetFinalVersionKind'], 'release', 'prerelease'))
+        displayName: 'Set CI tags'
+
+      # !!! NOTE !!! Some of these steps have disabled code signing.
+      # This is intentional to workaround https://github.com/dotnet/arcade/issues/1957 which always re-submits for code-signing, even
+      # if they have already been signed. This results in slower builds due to re-submitting the same .nupkg many times for signing.
+      # The sign settings have been configured to
+      - ${{ if ne(variables['System.TeamProject'], 'public') }}:
+        - task: PowerShell@2
+          displayName: Setup Private Feeds Credentials
+          inputs:
+            filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.ps1
+            arguments: -ConfigFile $(Build.SourcesDirectory)/NuGet.config -Password $Env:Token
+          env:
+            Token: $(dn-bot-dnceng-artifact-feeds-rw)
+
+      - script: ./build.cmd
+                -ci
+                -arch x64
+                -pack
+                -all
+                -buildNative
+                /bl:artifacts/log/build.x64.binlog
+                $(_BuildArgs)
+                $(_InternalRuntimeDownloadArgs)
+        displayName: Build x64
+
+      # Build the x86 shared framework
+      # TODO: make it possible to build for one Windows architecture at a time
+      # This is going to actually build x86 native assets. See https://github.com/aspnet/AspNetCore/issues/7196
+      - script: ./build.cmd
+                -ci
+                -arch x86
+                -pack
+                -all
+                -buildNative
+                -noBuildJava
+                /p:OnlyPackPlatformSpecificPackages=true
+                /bl:artifacts/log/build.x86.binlog
+                $(_BuildArgs)
+                $(_InternalRuntimeDownloadArgs)
+        displayName: Build x86
+
+      # This is in a separate build step with -forceCoreMsbuild to workaround MAX_PATH limitations - https://github.com/Microsoft/msbuild/issues/53
+      - script: .\src\SiteExtensions\build.cmd
+                -ci
+                -pack
+                -noBuildDeps
+                $(_BuildArgs)
+                $(_InternalRuntimeDownloadArgs)
+        displayName: Build SiteExtension
+
+      # This runs code-signing on all packages, zips, and jar files as defined in build/CodeSign.targets. If https://github.com/dotnet/arcade/issues/1957 is resolved,
+      # consider running code-signing inline with the other previous steps.
+      # Sign check is disabled because it is run in a separate step below, after installers are built.
+      - script: ./build.cmd
+                -ci
+                -noBuild
+                -noRestore
+                -sign
+                /bl:artifacts/log/build.codesign.binlog
+                /p:DotNetSignType=$(_SignType)
+                $(_BuildArgs)
+        displayName: Code sign packages
+
+      # Windows installers bundle both x86 and x64 assets
+      - script: ./build.cmd
+                -ci
+                -sign
+                -buildInstallers
+                /bl:artifacts/log/installers.msbuild.binlog
+                /p:DotNetSignType=$(_SignType)
+                /p:AssetManifestFileName=aspnetcore-win-x64-x86.xml
+                $(_BuildArgs)
+                $(_PublishArgs)
+                $(_InternalRuntimeDownloadArgs)
+                /p:PublishInstallerBaseVersion=true
+        displayName: Build Installers
+
+      # A few files must also go to the VS package feed.
+      - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+        - task: NuGetCommand@2
+          displayName: Push Visual Studio packages
+          inputs:
+            command: push
+            packagesToPush: 'artifacts/packages/**/VS.Redist.Common.AspNetCore.*.nupkg'
+            nuGetFeedType: external
+            publishFeedCredentials: 'DevDiv - VS package feed'
+
+      artifacts:
+      - name: Windows_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: Windows_Packages
+        path: artifacts/packages/
+
+  # Build Windows ARM
+  - template: jobs/default-build.yml
+    parameters:
+      codeSign: true
+      jobName: Windows_arm_build
+      jobDisplayName: "Build: Windows ARM"
+      agentOs: Windows
+      buildArgs:
+        -arch arm
+        -sign
+        -pack
+        -noBuildNodeJS
+        -noBuildJava
+        /bl:artifacts/log/build.win-arm.binlog
+        /p:DotNetSignType=$(_SignType)
+        /p:OnlyPackPlatformSpecificPackages=true
+        /p:AssetManifestFileName=aspnetcore-win-arm.xml
+        $(_BuildArgs)
+        $(_PublishArgs)
+        $(_InternalRuntimeDownloadArgs)
+      installNodeJs: false
+      installJdk: false
+      artifacts:
+      - name: Windows_arm_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: Windows_arm_Packages
+        path: artifacts/packages/
+
+  # Build Windows ARM64
+  - template: jobs/default-build.yml
+    parameters:
+      codeSign: true
+      jobName: Windows_64_build
+      jobDisplayName: "Build: Windows ARM64"
+      agentOs: Windows
+      buildArgs:
+        -arch arm64
+        -sign
+        -pack
+        -noBuildNodeJS
+        -noBuildJava
+        /bl:artifacts/log/build.win-arm64.binlog
+        /p:DotNetSignType=$(_SignType)
+        /p:OnlyPackPlatformSpecificPackages=true
+        /p:AssetManifestFileName=aspnetcore-win-arm64.xml
+        $(_BuildArgs)
+        $(_PublishArgs)
+        $(_InternalRuntimeDownloadArgs)
+      installNodeJs: false
+      installJdk: false
+      artifacts:
+      - name: Windows_arm64_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: Windows_arm64_Packages
+        path: artifacts/packages/
+      - name: Windows_arm64_Installers
+        path: artifacts/installers/
+
+  # Build MacOS
+  - template: jobs/default-build.yml
+    parameters:
+      jobName: MacOs_x64_build
+      jobDisplayName: "Build: macOS"
+      agentOs: macOs
+      buildArgs:
+        --pack
+        --all
+        --no-build-nodejs
+        --no-build-java
+        -p:OnlyPackPlatformSpecificPackages=true
+        -bl:artifacts/log/build.macos.binlog
+        -p:AssetManifestFileName=aspnetcore-MacOS_x64.xml
+        $(_BuildArgs)
+        $(_PublishArgs)
+        $(_InternalRuntimeDownloadArgs)
+      installNodeJs: false
+      installJdk: false
+      artifacts:
+      - name: MacOS_x64_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: MacOS_x64_Packages
+        path: artifacts/packages/
+  - template: jobs/codesign-xplat.yml
+    parameters:
+      inputName: MacOS_x64
+
+  # Build Linux x64
+  - template: jobs/default-build.yml
+    parameters:
+      jobName: Linux_x64_build
+      jobDisplayName: "Build: Linux x64"
+      agentOs: Linux
+      steps:
+      - ${{ if ne(variables['System.TeamProject'], 'public') }}:
+        - task: Bash@3
+          displayName: Setup Private Feeds Credentials
+          inputs:
+            filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.sh
+            arguments: $(Build.SourcesDirectory)/NuGet.config $Token
+          env:
+            Token: $(dn-bot-dnceng-artifact-feeds-rw)
+      - script: ./build.sh
+            --ci
+            --arch x64
+            --pack
+            --all
+            --no-build-nodejs
+            --no-build-java
+            -p:OnlyPackPlatformSpecificPackages=true
+            -bl:artifacts/log/build.linux-x64.binlog
+            $(_BuildArgs)
+            $(_InternalRuntimeDownloadArgs)
+        displayName: Run build.sh
+      - script: |
+          git clean -xfd src/**/obj/
+          ./dockerbuild.sh bionic \
+            --ci \
+            --arch x64 \
+            --build-installers \
+            --no-build-deps \
+            --no-build-nodejs \
+            -p:OnlyPackPlatformSpecificPackages=true \
+            -p:BuildRuntimeArchive=false \
+            -p:LinuxInstallerType=deb \
+            -bl:artifacts/log/build.deb.binlog \
+            $(_BuildArgs) \
+            $(_InternalRuntimeDownloadArgs)
+        displayName: Build Debian installers
+      - script: |
+          git clean -xfd src/**/obj/
+          ./dockerbuild.sh rhel \
+            --ci \
+            --arch x64 \
+            --build-installers \
+            --no-build-deps \
+            --no-build-nodejs \
+            -p:OnlyPackPlatformSpecificPackages=true \
+            -p:BuildRuntimeArchive=false \
+            -p:LinuxInstallerType=rpm \
+            -bl:artifacts/log/build.rpm.binlog \
+            -p:AssetManifestFileName=aspnetcore-Linux_x64.xml \
+            $(_BuildArgs) \
+            $(_PublishArgs) \
+            $(_InternalRuntimeDownloadArgs)
+        displayName: Build RPM installers
+      installNodeJs: false
+      installJdk: false
+      artifacts:
+      - name: Linux_x64_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: Linux_x64_Packages
+        path: artifacts/packages/
+  - template: jobs/codesign-xplat.yml
+    parameters:
+      inputName: Linux_x64
+
+  # Build Linux ARM
+  - template: jobs/default-build.yml
+    parameters:
+      jobName: Linux_arm_build
+      jobDisplayName: "Build: Linux ARM"
+      agentOs: Linux
+      buildArgs:
+        --arch arm
+        --pack
+        --all
+        --no-build-nodejs
+        --no-build-java
+        -p:OnlyPackPlatformSpecificPackages=true
+        -bl:artifacts/log/build.linux-arm.binlog
+        -p:AssetManifestFileName=aspnetcore-Linux_arm.xml
+        $(_BuildArgs)
+        $(_PublishArgs)
+        $(_InternalRuntimeDownloadArgs)
+      installNodeJs: false
+      installJdk: false
+      artifacts:
+      - name: Linux_arm_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: Linux_arm_Packages
+        path: artifacts/packages/
+  - template: jobs/codesign-xplat.yml
+    parameters:
+      inputName: Linux_arm
+
+  # Build Linux ARM64
+  - template: jobs/default-build.yml
+    parameters:
+      jobName: Linux_arm64_build
+      jobDisplayName: "Build: Linux ARM64"
+      agentOs: Linux
+      buildArgs:
+        --arch arm64
+        --all
+        --pack
+        --no-build-nodejs
+        --no-build-java
+        -p:OnlyPackPlatformSpecificPackages=true
+        -bl:artifacts/log/build.arm64.binlog
+        -p:AssetManifestFileName=aspnetcore-Linux_arm64.xml
+        $(_BuildArgs)
+        $(_PublishArgs)
+        $(_InternalRuntimeDownloadArgs)
+      installNodeJs: false
+      installJdk: false
+      artifacts:
+      - name: Linux_arm64_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: Linux_arm64_Packages
+        path: artifacts/packages/
+  - template: jobs/codesign-xplat.yml
+    parameters:
+      inputName: Linux_arm64
+
+  # Build Linux Musl x64
+  - template: jobs/default-build.yml
+    parameters:
+      jobName: Linux_musl_x64_build
+      jobDisplayName: "Build: Linux Musl x64"
+      agentOs: Linux
+      buildScript: ./dockerbuild.sh alpine
+      buildArgs:
+        --ci
+        --arch x64
+        --os-name linux-musl
+        --pack
+        --all
+        --no-build-nodejs
+        --no-build-java
+        -p:OnlyPackPlatformSpecificPackages=true
+        -bl:artifacts/log/build.musl.binlog
+        -p:AssetManifestFileName=aspnetcore-Linux_musl_x64.xml
+        $(_BuildArgs)
+        $(_PublishArgs)
+        $(_InternalRuntimeDownloadArgs)
+      installNodeJs: false
+      installJdk: false
+      artifacts:
+      - name: Linux_musl_x64_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: Linux_musl_x64_Packages
+        path: artifacts/packages/
+  - template: jobs/codesign-xplat.yml
+    parameters:
+      inputName: Linux_musl_x64
+
+  # Build Linux Musl ARM64
+  - template: jobs/default-build.yml
+    parameters:
+      jobName: Linux_musl_arm64_build
+      jobDisplayName: "Build: Linux Musl ARM64"
+      agentOs: Linux
+      buildScript: ./dockerbuild.sh ubuntu-alpine37
+      buildArgs:
+        --ci
+        --arch arm64
+        --os-name linux-musl
+        --pack
+        --all
+        --no-build-nodejs
+        --no-build-java
+        -p:OnlyPackPlatformSpecificPackages=true
+        -bl:artifacts/log/build.musl.binlog
+        -p:AssetManifestFileName=aspnetcore-Linux_musl_arm64.xml
+        $(_BuildArgs)
+        $(_PublishArgs)
+        $(_InternalRuntimeDownloadArgs)
+      installNodeJs: false
+      installJdk: false
+      artifacts:
+      - name: Linux_musl_arm64_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: Linux_musl_arm64_Packages
+        path: artifacts/packages/
+  - template: jobs/codesign-xplat.yml
+    parameters:
+      inputName: Linux_musl_arm64
+
+  # Test jobs
+  - template: jobs/default-build.yml
+    parameters:
+      condition: ne(variables['SkipTests'], 'true')
+      jobName: Windows_Test
+      jobDisplayName: "Test: Windows Server 2016 x64"
+      agentOs: Windows
+      isTestingJob: true
+      buildArgs: -all -pack -test -BuildNative "/p:SkipIISNewHandlerTests=true /p:SkipIISTests=true /p:SkipIISExpressTests=true /p:SkipIISNewShimTests=true /p:RunTemplateTests=false" $(_InternalRuntimeDownloadArgs)
+      beforeBuild:
+      - powershell: "& ./src/Servers/IIS/tools/UpdateIISExpressCertificate.ps1; & ./src/Servers/IIS/tools/update_schema.ps1"
+        displayName: Setup IISExpress test certificates and schema
+      afterBuild:
+      - powershell: "& ./build.ps1 -CI -NoBuild -Test /p:RunFlakyTests=true"
+        displayName: Run Flaky Tests
+        continueOnError: true
+      - task: PublishTestResults@2
+        displayName: Publish Flaky Test Results
+        inputs:
+          testResultsFormat: 'xUnit'
+          testResultsFiles: '*.xml'
+          searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)/Flaky'
+      artifacts:
+      - name: Windows_Test_Dumps
+        path: artifacts/dumps/
+        publishOnError: true
+        includeForks: false
+      - name: Windows_Test_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: Windows_Test_Results
+        path: artifacts/TestResults/
+        publishOnError: true
+        includeForks: true
+
+  - template: jobs/default-build.yml
+    parameters:
+      condition: ne(variables['SkipTests'], 'true')
+      jobName: Windows_Templates_Test
+      jobDisplayName: "Test: Templates - Windows Server 2016 x64"
+      agentOs: Windows
+      isTestingJob: true
+      steps:
+      - ${{ if ne(variables['System.TeamProject'], 'public') }}:
+        - task: PowerShell@2
+          displayName: Setup Private Feeds Credentials
+          inputs:
+            filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.ps1
+            arguments: -ConfigFile $(Build.SourcesDirectory)/NuGet.config -Password $Env:Token
+          env:
+            Token: $(dn-bot-dnceng-artifact-feeds-rw)
+      - script: ./build.cmd -ci -all -pack $(_InternalRuntimeDownloadArgs)
+        displayName: Build Repo
+      - script: ./src/ProjectTemplates/build.cmd -ci -pack -NoRestore -NoBuilddeps "/p:RunTemplateTests=true /bl:artifacts/log/template.pack.binlog"
+        displayName: Pack Templates
+      - script: ./src/ProjectTemplates/build.cmd -ci -test -NoRestore -NoBuild -NoBuilddeps "/p:RunTemplateTests=true /bl:artifacts/log/template.test.binlog"
+        displayName: Test Templates
+      artifacts:
+      - name: Windows_Test_Templates_Dumps
+        path: artifacts/dumps/
+        publishOnError: true
+        includeForks: false
+      - name: Windows_Test_Templates_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: Windows_Test_Templates_Results
+        path: artifacts/TestResults/
+        publishOnError: true
+        includeForks: true
+
+  - template: jobs/default-build.yml
+    parameters:
+      condition: ne(variables['SkipTests'], 'true')
+      jobName: MacOS_Test
+      jobDisplayName: "Test: macOS 10.14"
+      agentOs: macOS
+      isTestingJob: true
+      buildArgs: --all --test "/p:RunTemplateTests=false" $(_InternalRuntimeDownloadArgs)
+      beforeBuild:
+      - bash: "./eng/scripts/install-nginx-mac.sh"
+        displayName: Installing Nginx
+      afterBuild:
+      - bash: ./build.sh --ci --pack --no-build --no-restore --no-build-deps "/bl:artifacts/log/packages.pack.binlog"
+        displayName: Pack Packages (for Template tests)
+      - bash: ./src/ProjectTemplates/build.sh --ci --pack --no-restore --no-build-deps "/bl:artifacts/log/template.pack.binlog"
+        displayName: Pack Templates (for Template tests)
+      - bash: ./build.sh --no-build --ci --test -p:RunFlakyTests=true
+        displayName: Run Flaky Tests
+        continueOnError: true
+      - task: PublishTestResults@2
+        displayName: Publish Flaky Test Results
+        inputs:
+          testResultsFormat: 'xUnit'
+          testResultsFiles: '*.xml'
+          searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)/Flaky'
+      artifacts:
+      - name: MacOS_Test_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: MacOS_Test_Results
+        path: artifacts/TestResults/
+        publishOnError: true
+        includeForks: true
+
+  - template: jobs/default-build.yml
+    parameters:
+      condition: ne(variables['SkipTests'], 'true')
+      jobName: Linux_Test
+      jobDisplayName: "Test: Ubuntu 16.04 x64"
+      agentOs: Linux
+      isTestingJob: true
+      buildArgs: --all --test "/p:RunTemplateTests=false"  $(_InternalRuntimeDownloadArgs)
+      beforeBuild:
+      - bash: "./eng/scripts/install-nginx-linux.sh"
+        displayName: Installing Nginx
+      - bash: "echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p"
+        displayName: Increase inotify limit
+      afterBuild:
+      - bash: ./build.sh --ci --pack --no-build --no-restore --no-build-deps "/bl:artifacts/log/packages.pack.binlog"
+        displayName: Pack Packages (for Template tests)
+      - bash: ./src/ProjectTemplates/build.sh --ci --pack --no-restore --no-build-deps "/bl:artifacts/log/template.pack.binlog"
+        displayName: Pack Templates (for Template tests)
+      - bash: ./build.sh --no-build --ci --test -p:RunFlakyTests=true
+        displayName: Run Flaky Tests
+        continueOnError: true
+      - task: PublishTestResults@2
+        displayName: Publish Flaky Test Results
+        inputs:
+          testResultsFormat: 'xUnit'
+          testResultsFiles: '*.xml'
+          searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)/Flaky'
+      artifacts:
+      - name: Linux_Test_Logs
+        path: artifacts/log/
+        publishOnError: true
+        includeForks: true
+      - name: Linux_Test_Results
+        path: artifacts/TestResults/
+        publishOnError: true
+        includeForks: true
+
+  # Source build
+  - job: Source_Build
+    displayName: 'Test: Linux Source Build'
+    container: centos:7
+    pool:
+      vmImage: 'ubuntu-16.04'
+    variables:
+      DotNetCoreSdkDir: $(Agent.ToolsDirectory)/dotnet
+      DOTNET_SYSTEM_GLOBALIZATION_INVARIANT: true
+    steps:
+    - script: |
+        source eng/common/native/common-library.sh
+        mkdir -p $HOME/bin
+        GetFile https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64 $HOME/bin/jq
+        chmod +x $HOME/bin/jq
+        echo "##vso[task.prependpath]$HOME/bin"
+      displayName: Install jq
+    - task: UseDotNet@2
+      displayName: 'Use .NET Core sdk'
+      inputs:
+        packageType: sdk
+        # The SDK version selected here is intentionally supposed to use the latest release
+        # For the purpose of building Linux distros, we can't depend on features of the SDK
+        # which may not exist in pre-built versions of the SDK
+        # Pinning to preview 8 since preview 9 has breaking changes
+        version: 3.1.100
+        installationPath: $(DotNetCoreSdkDir)
+        includePreviewVersions: true
+    - ${{ if ne(variables['System.TeamProject'], 'public') }}:
+        - task: Bash@3
+          displayName: Setup Private Feeds Credentials
+          inputs:
+            filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.sh
+            arguments: $(Build.SourcesDirectory)/NuGet.config $Token
+          env:
+            Token: $(dn-bot-dnceng-artifact-feeds-rw)
+    - script: ./eng/scripts/ci-source-build.sh --ci --configuration Release /p:BuildManaged=true /p:BuildNodeJs=false
+      displayName: Run ci-source-build.sh
+    - task: PublishBuildArtifacts@1
+      displayName: Upload logs
+      condition: always()
+      continueOnError: true
+      inputs:
+        pathtoPublish: artifacts/log/
+        artifactName: Source_Build_Logs
+        artifactType: Container
+        parallel: true
+    - task: PublishBuildArtifacts@1
+      displayName: Upload package artifacts
+      # Only capture source build artifacts in PRs for the sake of inspecting
+      # changes that impact source-build. The artifacts from this build pipeline are never actually used.
+      condition: and(succeeded(), in(variables['Build.Reason'], 'PullRequest'))
+      inputs:
+        pathtoPublish: artifacts/packages/
+        artifactName: Source_Build_Packages
+        artifactType: Container
+        parallel: true
+
+  # Publish to the BAR
+  - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - template: /eng/common/templates/job/publish-build-assets.yml
+      parameters:
+        dependsOn:
+          - Windows_build
+          - Windows_arm_build
+          - CodeSign_Xplat_MacOS_x64
+          - CodeSign_Xplat_Linux_x64
+          - CodeSign_Xplat_Linux_arm
+          - CodeSign_Xplat_Linux_arm64
+          - CodeSign_Xplat_Linux_musl_x64
+          - CodeSign_Xplat_Linux_musl_arm64
+          # In addition to the dependencies above, ensure the build was successful overall.
+          - Linux_Test
+          - MacOS_Test
+          - Source_Build
+          - Windows_Templates_Test
+          - Windows_Test
+        pool:
+          vmImage: vs2017-win2016
+        publishUsingPipelines: ${{ variables._PublishUsingPipelines }}
+        enablePublishBuildArtifacts: true # publish artifacts/log files
+
+- ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+  - template: /eng/common/templates/post-build/post-build.yml
+    parameters:
+      # See https://github.com/dotnet/arcade/issues/2871
+      enableSymbolValidation: false
+      publishInstallersAndChecksums: true
--- a/.azure/pipelines/e2e-tests.yml
+++ b/.azure/pipelines/e2e-tests.yml
@ -1,131 +0,0 @@
-trigger: none
-
-jobs:
- job: Host_Windows
-  pool:
-    vmImage: vs2017-win2016
-  strategy:
-    maxParallel: 8
-    matrix:
-      Portable_Node8:
-        Test.RuntimeIdentifier: none
-        Node.Version: 8.x
-      Portable_Node10:
-        Test.RuntimeIdentifier: none
-        Node.Version: 10.x
-      SelfContainedWindows_Node8:
-        Test.RuntimeIdentifier: win-x64
-        Node.Version: 8.x
-      SelfContainedWindows_Node10:
-        Test.RuntimeIdentifier: win-x64
-        Node.Version: 10.x
-      SelfContainedLinux_Node8:
-        Test.RuntimeIdentifier: linux-x64
-        Node.Version: 8.x
-      SelfContainedLinux_Node10:
-        Test.RuntimeIdentifier: linux-x64
-        Node.Version: 10.x
-      SelfContainedMacOs_Node8:
-        Test.RuntimeIdentifier: osx-x64
-        Node.Version: 8.x
-      SelfContainedMacOs_Node10:
-        Test.RuntimeIdentifier: osx-x64
-        Node.Version: 10.x
-  steps:
-  - task: NodeTool@0
-    displayName: Install Node $(Node.Version)
-    inputs:
-      versionSpec: $(Node.Version)
-  - powershell: |
-      test/Cli.FunctionalTests/run-tests.ps1 -ci -CliManifestName $(CliManifestName) -RestoreSources $(PB_RestoreSource) -AccessTokenSuffix '$(AccessTokenSuffix)' -AssetRootUrl $(PB_AssetRootUrl) -ProdConManifestUrl $env:PRODCONMANIFESTURL -TestRuntimeIdentifier $(Test.RuntimeIdentifier) -AdditionalRestoreSources $env:ADDITIONALRESTORESOURCES
-
-    condition: ne(variables['PB_SkipTests'], 'true')
-    displayName: Run E2E tests
-  - task: PublishTestResults@2
-    displayName: Publish test results
-    condition: always()
-    inputs:
-      testRunner: vstest
-      testResultsFiles: 'artifacts/logs/**/*.trx'
- job: Host_macOS
-  pool:
-    vmImage: macOS-10.14
-  strategy:
-    maxParallel: 4
-    # The ASP.NET Core 2.1.X templates are incompatible with Node10 on macOS
-    # https://github.com/aspnet/Templating/issues/608
-    matrix:
-      Portable_Node8:
-        Test.RuntimeIdentifier: none
-        Node.Version: 8.x
-      SelfContainedWindows_Node8:
-        Test.RuntimeIdentifier: win-x64
-        Node.Version: 8.x
-      SelfContainedLinux_Node8:
-        Test.RuntimeIdentifier: linux-x64
-        Node.Version: 8.x
-      SelfContainedMacOs_Node8:
-        Test.RuntimeIdentifier: osx-x64
-        Node.Version: 8.x
-  steps:
-  - task: NodeTool@0
-    displayName: Install Node $(Node.Version)
-    inputs:
-      versionSpec: $(Node.Version)
-  - powershell: |
-      test/Cli.FunctionalTests/run-tests.ps1 -ci -CliManifestName $(CliManifestName) -RestoreSources $(PB_RestoreSource) -AccessTokenSuffix '$(AccessTokenSuffix)' -AssetRootUrl $(PB_AssetRootUrl) -ProdConManifestUrl $env:PRODCONMANIFESTURL -TestRuntimeIdentifier $(Test.RuntimeIdentifier) -AdditionalRestoreSources $env:ADDITIONALRESTORESOURCES
-
-    condition: ne(variables['PB_SkipTests'], 'true')
-    displayName: Run E2E tests
-  - task: PublishTestResults@2
-    displayName: Publish test results
-    condition: always()
-    inputs:
-      testRunner: vstest
-      testResultsFiles: 'artifacts/logs/**/*.trx'
- job: Host_Linux
-  pool:
-    vmImage: ubuntu-16.04
-  strategy:
-    maxParallel: 8
-    matrix:
-      Portable_Node8:
-        Test.RuntimeIdentifier: none
-        Node.Version: 8.x
-      Portable_Node10:
-        Test.RuntimeIdentifier: none
-        Node.Version: 10.x
-      SelfContainedWindows_Node8:
-        Test.RuntimeIdentifier: win-x64
-        Node.Version: 8.x
-      SelfContainedWindows_Node10:
-        Test.RuntimeIdentifier: win-x64
-        Node.Version: 10.x
-      SelfContainedLinux_Node8:
-        Test.RuntimeIdentifier: linux-x64
-        Node.Version: 8.x
-      SelfContainedLinux_Node10:
-        Test.RuntimeIdentifier: linux-x64
-        Node.Version: 10.x
-      SelfContainedMacOs_Node8:
-        Test.RuntimeIdentifier: osx-x64
-        Node.Version: 8.x
-      SelfContainedMacOs_Node10:
-        Test.RuntimeIdentifier: osx-x64
-        Node.Version: 10.x
-  steps:
-  - task: NodeTool@0
-    displayName: Install Node $(Node.Version)
-    inputs:
-      versionSpec: $(Node.Version)
-  - powershell: |
-      test/Cli.FunctionalTests/run-tests.ps1 -ci -CliManifestName $(CliManifestName) -RestoreSources $(PB_RestoreSource) -AccessTokenSuffix '$(AccessTokenSuffix)' -AssetRootUrl $(PB_AssetRootUrl) -ProdConManifestUrl $env:PRODCONMANIFESTURL -TestRuntimeIdentifier $(Test.RuntimeIdentifier) -AdditionalRestoreSources $env:ADDITIONALRESTORESOURCES
-
-    condition: ne(variables['PB_SkipTests'], 'true')
-    displayName: Run E2E tests
-  - task: PublishTestResults@2
-    displayName: Publish test results
-    condition: always()
-    inputs:
-      testRunner: vstest
-      testResultsFiles: 'artifacts/logs/**/*.trx'
--- a/.azure/pipelines/helix-test.yml
+++ b/.azure/pipelines/helix-test.yml
@ -0,0 +1,27 @@
+# Don't run CI for this config yet. We're not ready to move official builds on to Azure Pipelines
+trigger: none
+
+# Run PR validation on all branches
+pr:
+  branches:
+    include:
+    - '*'
+
+jobs:
+- template: jobs/default-build.yml
+  parameters:
+    jobName: Helix_x64
+    jobDisplayName: 'Tests: Helix x64'
+    agentOs: Windows
+    timeoutInMinutes: 240
+    steps:
+    - script: .\restore.cmd -ci
+      displayName: Restore
+    - script: .\build.cmd -ci -NoRestore -test -projects eng\helix\helix.proj /p:IsHelixJob=true /p:BuildAllProjects=true /p:BuildNative=true -bl
+      displayName: Run build.cmd helix target
+      env:
+        SYSTEM_ACCESSTOKEN: $(System.AccessToken) # We need to set this env var to publish helix results to Azure Dev Ops
+    artifacts:
+    - name: Helix_logs
+      path: artifacts/log/
+      publishOnError: true
--- a/.azure/pipelines/jobs/codesign-xplat.yml
+++ b/.azure/pipelines/jobs/codesign-xplat.yml
@ -0,0 +1,58 @@
+# This runs code signing for .nupkg files built on MacOS or Linux
+parameters:
+  inputName: ''
+
+jobs:
+- template: default-build.yml
+  parameters:
+    codeSign: true
+    dependsOn:
+    - ${{ parameters.inputName }}_build
+    condition: and(in(variables['_SignType'], 'test', 'real'), in(dependencies.${{ parameters.inputName }}_build.result, 'Succeeded', 'SucceededWithIssues'))
+    jobName: CodeSign_Xplat_${{ parameters.inputName }}
+    jobDisplayName: "Code-sign ${{ parameters.inputName }} packages"
+    agentOs: Windows
+    installNodeJs: false
+    installJdk: false
+    steps:
+    - task: DownloadBuildArtifacts@0
+      displayName: Download ${{ parameters.inputName }} artifacts
+      inputs:
+        artifactName: ${{ parameters.inputName }}_Packages
+        downloadPath: $(Build.StagingDirectory)/downloaded_packages/
+        itemPattern: '**/*.nupkg'
+    - task: CopyFiles@2
+      displayName: Copy packages to ArtifactsShippingPackagesDir
+      inputs:
+        sourceFolder: $(Build.StagingDirectory)/downloaded_packages/
+        contents: '**/*.nupkg'
+        targetFolder: $(Build.SourcesDirectory)/artifacts/packages/$(BuildConfiguration)/shipping/
+        flattenFolders: true
+    - ${{ if ne(variables['System.TeamProject'], 'public') }}:
+      - task: PowerShell@2
+        displayName: Setup Private Feeds Credentials
+        inputs:
+          filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.ps1
+          arguments: -ConfigFile $(Build.SourcesDirectory)/NuGet.config -Password $Env:Token
+        env:
+          Token: $(dn-bot-dnceng-artifact-feeds-rw)
+    - powershell: .\eng\common\build.ps1
+        -ci
+        -restore
+        -sign
+        -publish
+        -configuration $(BuildConfiguration)
+        -projects $(Build.SourcesDirectory)/eng/empty.proj
+        /p:AssetManifestFileName=aspnetcore-${{ parameters.inputName }}-signed.xml
+        /p:DotNetSignType=$(_SignType)
+        $(_BuildArgs)
+        $(_PublishArgs)
+        $(_InternalRuntimeDownloadCodeSignArgs)
+      displayName: Sign and publish packages
+    artifacts:
+    - name: CodeSign_Xplat_${{ parameters.inputName }}_Logs
+      path: artifacts/log/
+      publishOnError: true
+      includeForks: true
+    - name: ${{ parameters.inputName }}_Packages_Signed
+      path: artifacts/packages/
--- a/.azure/pipelines/jobs/default-build.yml
+++ b/.azure/pipelines/jobs/default-build.yml
@ -5,8 +5,6 @@
 #       The name of the job. Defaults to the name of the OS. No spaces allowed
 #   jobDisplayName: string
 #       The friendly job name to display in the UI. Defaults to the name of the OS.
-#   poolName: string
-#       The name of the Azure DevOps agent pool to use.
 #   agentOs: string
 #       Used in templates to define variables which are OS specific. Typically from the set { Windows, Linux, macOS }
 #   buildArgs: string
@ -14,25 +12,29 @@
 #       Note: -ci is always passed
 #   beforeBuild: [steps]
 #       Additional steps to run before build.sh/cmd
+#   steps: [steps]
+#       Instead of running build.cmd/sh, run these build steps.
 #   afterBuild: [steps]
 #       Additional steps to run after build.sh/cmd
-#   artifacts:
-#      publish: boolean
-#           Should artifacts be published
-#      path: string
-#           The file path to artifacts output
-#      name: string
+#   artifacts: [array]
+#       name: string
 #           The name of the artifact container
-#   variables: { string: string }
-#     A map of custom variables
-#   matrix: { string: { string: string } }
-#     A map of matrix configurations and variables. https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=azure-devops&tabs=schema#job
+#    -  path: string
+#           The file path to artifacts output
+#       includeForks: boolean
+#           Should artifacts from forks be published?
+#       publishOnError: boolean
+#           Should artifacts be published if previous step failed?
 #   dependsOn: string | [ string ]
-#     For fan-out/fan-in. https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=azure-devops&tabs=schema#job
+#       For fan-out/fan-in. https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=azure-devops&tabs=schema#job
+#   condition: string
+#       A condition which can be used to skip the job completely
 #   codeSign: boolean
 #       This build definition is enabled for code signing. (Only applies to Windows)
 #   buildDirectory: string
 #       Specifies what directory to run build.sh/cmd
+#   buildScript: string
+#       Specifies the build script to run. Defaults to build.sh or build.cmd.

 #
 # See https://docs.microsoft.com/en-us/vsts/pipelines/yaml-schema for details
@ -40,129 +42,215 @@

 parameters:
  agentOs: 'Windows'
-  poolName: ''
  buildArgs: ''
  configuration: 'Release'
  beforeBuild: []
+  # steps: []  don't define an empty object default because there is no way in template expression yet to check "if isEmpty(parameters.steps)"
  afterBuild: []
  codeSign: false
-  variables: {}
  dependsOn: ''
+  condition: ''
  # jobName: '' - use agentOs by default.
  # jobDisplayName: '' - use agentOs by default.
-  # matrix: {} - don't define an empty object default because there is no way in template expression yet to check "if isEmpty(parameters.matrix)"
-  artifacts:
-    publish: true
-    path: 'artifacts/'
+  artifacts:  []
  buildDirectory: ''
+  buildScript: ''
+  installTar: true
+  installNodeJs: true
+  installJdk: true
+  timeoutInMinutes: 180
+
+  # We need longer than the default amount of 5 minutes to upload our logs/artifacts. (We currently take around 5 mins in the best case).
+  # This makes sure we have time to upload everything in the case of a build timeout - really important for investigating a build
+  # timeout due to test hangs.
+  cancelTimeoutInMinutes: 15

 jobs:
- job: ${{ coalesce(parameters.jobName, parameters.agentOs) }}
-  displayName: ${{ coalesce(parameters.jobDisplayName, parameters.agentOs) }}
-  dependsOn: ${{ parameters.dependsOn }}
-  timeoutInMinutes: 90
-  workspace:
-    clean: all
-  strategy:
-    ${{ if ne(parameters.matrix, '') }}:
-      maxParallel: 8
-      matrix: ${{ parameters.matrix }}
-  # Map friendly OS names to the right queue
-  # See https://github.com/dotnet/arcade/blob/master/Documentation/ChoosingAMachinePool.md
-  pool:
-    ${{ if ne(parameters.poolName, '') }}:
-      name: ${{ parameters.poolName }}
-    ${{ if and(eq(parameters.poolName, ''), eq(parameters.agentOs, 'macOS')) }}:
-      vmImage: macOS-10.14
-    ${{ if and(eq(parameters.poolName, ''), eq(parameters.agentOs, 'Linux')) }}:
-      vmImage: ubuntu-16.04
-    ${{ if and(eq(parameters.poolName, ''), eq(parameters.agentOs, 'Windows')) }}:
-      ${{ if eq(variables['System.TeamProject'], 'public') }}:
-        name: NetCorePublic-Pool
-        queue: BuildPool.Server.Amd64.VS2017.Open
-      ${{ if ne(variables['System.TeamProject'], 'public') }}:
-        name: NetCoreInternal-Pool
-        queue: BuildPool.Server.Amd64.VS2017
-  variables:
-    AgentOsName: ${{ parameters.agentOs }}
-    ASPNETCORE_TEST_LOG_MAXPATH: "200" # Keep test log file name length low enough for artifact zipping
-    DOTNET_HOME: $(Agent.BuildDirectory)/.dotnet
-    BuildScript: ${{ parameters.buildScript }}
-    BuildScriptArgs: ${{ parameters.buildArgs }}
-    BuildConfiguration: ${{ parameters.configuration }}
-    BuildDirectory: ${{ parameters.buildDirectory }}
-    TeamName: AspNetCore
-    ${{ if eq(parameters.agentOs, 'Windows') }}:
-      JAVA_HOME: $(Agent.BuildDirectory)\.tools\jdk
-    ${{ if or(ne(parameters.codeSign, 'true'), ne(variables['System.TeamProject'], 'internal'), in(variables['Build.Reason'], 'PullRequest')) }}:
-      _SignType:
-    ${{ if and(eq(parameters.codeSign, 'true'), eq(variables['System.TeamProject'], 'internal'), notin(variables['Build.Reason'], 'PullRequest')) }}:
-      _SignType: real
-    ${{ insert }}: ${{ parameters.variables }}
-  steps:
-  - checkout: self
-    clean: true
-  - task: NodeTool@0
-    displayName: Install Node 10.x
-    inputs:
-      versionSpec: 10.x
-  - ${{ if eq(parameters.agentOs, 'Windows') }}:
-    - powershell: ./eng/scripts/InstallJdk.ps1 '11.0.1'
-      displayName: Install JDK 11
-    - task: NuGetCommand@2
-      displayName: 'Clear NuGet caches'
-      condition: succeeded()
-      inputs:
-        command: custom
-        arguments: 'locals all -clear'
-  - ${{ if and(eq(variables['System.TeamProject'], 'internal'), eq(parameters.agentOs, 'Windows'), eq(parameters.codeSign, 'true')) }}:
-    - task: MicroBuildSigningPlugin@1
-      displayName: Install MicroBuild Signing plugin
-      condition: and(succeeded(), in(variables['_SignType'], 'test', 'real'))
-      inputs:
-        signType: $(_SignType)
-        zipSources: false
-        feedSource: https://dnceng.pkgs.visualstudio.com/_packaging/MicroBuildToolset/nuget/v3/index.json
-  - ${{ parameters.beforeBuild }}
-  - ${{ if eq(parameters.agentOs, 'Windows') }}:
-    - script: .\$(BuildDirectory)\build.cmd -ci /p:SignType=$(_SignType) /p:Configuration=$(BuildConfiguration) $(BuildScriptArgs)
-      displayName: Run build.cmd
-    - powershell: eng\scripts\KillProcesses.ps1
-      displayName: Kill processes
-      condition: always()
-  - ${{ if ne(parameters.agentOs, 'Windows') }}:
-    - script: ./$(BuildDirectory)/build.sh -ci -p:Configuration=$(BuildConfiguration) $(BuildScriptArgs)
-      displayName: Run build.sh
-    - script: eng/scripts/KillProcesses.sh
-      displayName: Kill processes
-      condition: always()
-  - task: PublishTestResults@2
-    displayName: Publish test results
-    condition: always()
-    continueOnError: true
-    inputs:
-      testRunTitle: $(AgentOsName)-$(BuildConfiguration)
-      testRunner: vstest
-      testResultsFiles: 'artifacts/logs/**/*.trx'
-      mergeTestResults: true
-  - ${{ if eq(parameters.artifacts.publish, 'true') }}:
-    - task: PublishBuildArtifacts@1
-      displayName: Upload artifacts
-      condition: eq(variables['system.pullrequest.isfork'], false)
-      continueOnError: true
-      inputs:
-        ${{ if eq(parameters.buildDirectory, '') }}:
-          pathtoPublish: ${{ parameters.artifacts.path }}
-        ${{ if ne(parameters.artifacts.name, '') }}:
-          pathtoPublish: ${{ parameters.buildDirectory }}\${{ parameters.artifacts.path }}
-        ${{ if eq(parameters.artifacts.name, '') }}:
-          artifactName: artifacts-$(AgentOsName)-$(BuildConfiguration)
-        ${{ if ne(parameters.artifacts.name, '') }}:
-          artifactName: ${{ parameters.artifacts.name }}
-        artifactType: Container
-        parallel: true
-  - ${{ parameters.afterBuild }}
-  - ${{ if and(eq(variables['System.TeamProject'], 'internal'), eq(parameters.agentOs, 'Windows')) }}:
-    - task: MicroBuildCleanup@1
-      displayName: Cleanup MicroBuild tasks
-      condition: always()
+- template: /eng/common/templates/job/job.yml
+  parameters:
+    name: ${{ coalesce(parameters.jobName, parameters.agentOs) }}
+    displayName: ${{ coalesce(parameters.jobDisplayName, parameters.agentOs) }}
+    dependsOn: ${{ parameters.dependsOn }}
+    ${{ if ne(parameters.condition, '') }}:
+      condition: ${{ parameters.condition }}
+    timeoutInMinutes: ${{ parameters.timeoutInMinutes }}
+    cancelTimeoutInMinutes: ${{ parameters.cancelTimeoutInMinutes }}
+    ${{ if and(eq(variables['System.TeamProject'], 'internal'), eq(parameters.agentOs, 'Windows'), eq(parameters.codeSign, 'true')) }}:
+      enableMicrobuild: true
+      enablePublishBuildAssets: true
+      enablePublishUsingPipelines: ${{ variables._PublishUsingPipelines }}
+    enablePublishTestResults: true # publish test results to AzDO (populates AzDO Tests tab)
+    enableTelemetry: true
+    helixRepo: aspnet/AspNetCore
+    helixType: build.product/
+    workspace:
+      clean: all
+    # Map friendly OS names to the right queue
+    # See https://github.com/dotnet/arcade/blob/master/Documentation/ChoosingAMachinePool.md
+    pool:
+      ${{ if eq(parameters.agentOs, 'macOS') }}:
+        vmImage: macOS-10.14
+      ${{ if eq(parameters.agentOs, 'Linux') }}:
+        vmImage: ubuntu-16.04
+      ${{ if eq(parameters.agentOs, 'Windows') }}:
+        ${{ if eq(variables['System.TeamProject'], 'public') }}:
+          name: NetCorePublic-Pool
+          ${{ if ne(parameters.isTestingJob, true) }}:
+            # Visual Studio Build Tools
+            queue: BuildPool.Server.Amd64.VS2019.BT.Open
+          ${{ if eq(parameters.isTestingJob, true) }}:
+            # Visual Studio Enterprise - contains some stuff, like SQL Server and IIS Express, that we use for testing
+            queue: BuildPool.Server.Amd64.VS2019.Open
+        ${{ if eq(variables['System.TeamProject'], 'internal') }}:
+          name: NetCoreInternal-Pool
+          # Visual Studio Enterprise - contains some stuff, like SQL Server and IIS Express, that we use for testing
+          queue: BuildPool.Server.Amd64.VS2019
+    variables:
+    - AgentOsName: ${{ parameters.agentOs }}
+    - ASPNETCORE_TEST_LOG_MAXPATH: "200" # Keep test log file name length low enough for artifact zipping
+    - BuildScript: ${{ parameters.buildScript }}
+    - BuildScriptArgs: ${{ parameters.buildArgs }}
+    - _BuildConfig: ${{ parameters.configuration }}
+    - BuildConfiguration: ${{ parameters.configuration }}
+    - BuildDirectory: ${{ parameters.buildDirectory }}
+    - DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
+    - TeamName: AspNetCore
+    - ${{ if and(eq(parameters.installJdk, 'true'), eq(parameters.agentOs, 'Windows')) }}:
+      - JAVA_HOME: $(Agent.BuildDirectory)\.tools\jdk\win-x64
+    - ${{ if or(ne(parameters.codeSign, true), ne(variables['System.TeamProject'], 'internal')) }}:
+      - _SignType: ''
+    - ${{ if and(eq(parameters.codeSign, true), eq(variables['System.TeamProject'], 'internal')) }}:
+      - ${{ if notin(variables['Build.Reason'], 'PullRequest') }}:
+        - _SignType: real
+      - ${{ if in(variables['Build.Reason'], 'PullRequest') }}:
+        - _SignType: test
+    steps:
+    - checkout: self
+      clean: true
+    - ${{ if and(eq(parameters.agentOs, 'Windows'), eq(parameters.isTestingJob, true)) }}:
+      - powershell: ./eng/scripts/InstallProcDump.ps1
+        displayName: Install ProcDump
+      - powershell: ./eng/scripts/StartDumpCollectionForHangingBuilds.ps1 $(ProcDumpPath)procdump.exe artifacts/dumps/ (Get-Date).AddMinutes(160) dotnet
+        displayName: Start background dump collection
+    - ${{ if eq(parameters.installNodeJs, 'true') }}:
+      - task: NodeTool@0
+        displayName: Install Node 10.x
+        inputs:
+          versionSpec: 10.x
+    - ${{ if eq(parameters.agentOs, 'Windows') }}:
+      - task: NuGetCommand@2
+        displayName: 'Clear NuGet caches'
+        condition: succeeded()
+        inputs:
+          command: custom
+          arguments: 'locals all -clear'
+    - ${{ if and(eq(parameters.installJdk, 'true'), eq(parameters.agentOs, 'Windows')) }}:
+      - powershell: ./eng/scripts/InstallJdk.ps1
+        displayName: Install JDK 11
+      - ${{ if eq(parameters.isTestingJob, true) }}:
+        - powershell: |
+            Write-Host "##vso[task.setvariable variable=SeleniumProcessTrackingFolder]$(BuildDirectory)\artifacts\tmp\selenium\"
+            ./eng/scripts/InstallGoogleChrome.ps1
+          displayName: Install Chrome
+    - ${{ if and(eq(parameters.installTar, 'true'), eq(parameters.agentOs, 'Windows')) }}:
+      - powershell: ./eng/scripts/InstallTar.ps1
+        displayName: Find or install Tar
+
+    - ${{ parameters.beforeBuild }}
+
+    - ${{ if ne(parameters.steps, '')}}:
+      - ${{ parameters.steps }}
+    - ${{ if eq(parameters.steps, '')}}:
+      - ${{ if ne(variables['System.TeamProject'], 'public') }}:
+        - ${{ if eq(parameters.agentOs, 'Windows') }}:
+          - ${{ if ne(variables['System.TeamProject'], 'public') }}:
+            - task: PowerShell@2
+              displayName: Setup Private Feeds Credentials
+              inputs:
+                filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.ps1
+                arguments: -ConfigFile $(Build.SourcesDirectory)/NuGet.config -Password $Env:Token
+              env:
+                Token: $(dn-bot-dnceng-artifact-feeds-rw)
+        - ${{ if ne(parameters.agentOs, 'Windows') }}:
+          - task: Bash@3
+            displayName: Setup Private Feeds Credentials
+            inputs:
+              filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.sh
+              arguments: $(Build.SourcesDirectory)/NuGet.config $Token
+            env:
+              Token: $(dn-bot-dnceng-artifact-feeds-rw)
+      - ${{ if eq(parameters.buildScript, '') }}:
+        - ${{ if eq(parameters.agentOs, 'Windows') }}:
+          - script: .\$(BuildDirectory)\build.cmd -ci /p:DotNetSignType=$(_SignType) -Configuration $(BuildConfiguration) $(BuildScriptArgs)
+            displayName: Run build.cmd
+        - ${{ if ne(parameters.agentOs, 'Windows') }}:
+          - script: ./$(BuildDirectory)/build.sh -ci -configuration $(BuildConfiguration) $(BuildScriptArgs)
+            displayName: Run build.sh
+      - ${{ if ne(parameters.buildScript, '') }}:
+        - script: $(BuildScript) -Configuration $(BuildConfiguration) $(BuildScriptArgs)
+          displayName: run $(BuildScript)
+
+    - ${{ parameters.afterBuild }}
+
+    - ${{ if and(eq(parameters.agentOs, 'Windows'), eq(parameters.isTestingJob, true)) }}:
+      - powershell: ./eng/scripts/FinishDumpCollectionForHangingBuilds.ps1 artifacts/dumps/
+        displayName: Finish background dump collection
+        continueOnError: true
+        condition: always()
+
+    - ${{ if eq(parameters.agentOs, 'Windows') }}:
+      - powershell: eng\scripts\KillProcesses.ps1
+        displayName: Kill processes
+        continueOnError: true
+        condition: always()
+    - ${{ if ne(parameters.agentOs, 'Windows') }}:
+      - script: eng/scripts/KillProcesses.sh
+        displayName: Kill processes
+        continueOnError: true
+        condition: always()
+
+    - ${{ each artifact in parameters.artifacts }}:
+      - task: PublishBuildArtifacts@1
+        displayName: Upload artifacts from ${{ artifact.path }}
+        condition: and(or(succeeded(), eq('${{ artifact.publishOnError }}', 'true')), or(eq(variables['system.pullrequest.isfork'], false), eq('${{ artifact.includeForks }}', 'true')))
+        continueOnError: true
+        inputs:
+          ${{ if eq(parameters.buildDirectory, '') }}:
+            pathtoPublish: ${{ artifact.path }}
+          ${{ if ne(parameters.buildDirectory, '') }}:
+            pathtoPublish: ${{ parameters.buildDirectory }}\${{ artifact.path }}
+          ${{ if eq(artifact.name, '') }}:
+            artifactName: artifacts-$(AgentOsName)-$(BuildConfiguration)
+          ${{ if ne(artifact.name, '') }}:
+            artifactName: ${{ artifact.name }}
+          artifactType: Container
+          parallel: true
+
+    - ${{ if eq(parameters.isTestingJob, true) }}:
+      - task: PublishTestResults@2
+        displayName: Publish VSTest test results
+        condition: always()
+        continueOnError: true
+        inputs:
+          testRunTitle: $(AgentOsName)-$(BuildConfiguration)
+          testRunner: vstest
+          testResultsFiles: '**/artifacts/**/*.trx'
+          mergeTestResults: true
+          buildConfiguration: $(BuildConfiguration)
+          buildPlatform: $(AgentOsName)
+      - task: PublishTestResults@2
+        displayName: Publish js test results
+        condition: always()
+        inputs:
+          testRunner: junit
+          testResultsFiles: '**/artifacts/log/**/*.junit.xml'
+          buildConfiguration: $(BuildConfiguration)
+          buildPlatform: $(AgentOsName)
+      - task: PublishTestResults@2
+        displayName: Publish Java test results
+        condition: always()
+        inputs:
+          testRunner: junit
+          testResultsFiles: '**/TEST-com.microsoft.signalr*.xml'
+          buildConfiguration: $(BuildConfiguration)
+          buildPlatform: $(AgentOsName)
--- a/.azure/pipelines/jobs/iisintegration-job.yml
+++ b/.azure/pipelines/jobs/iisintegration-job.yml
@ -1,20 +0,0 @@
-jobs:
- template: default-build.yml
-  parameters:
-    jobName: 'IISIntegration'
-    jobDisplayName: 'IISIntegration'
-    beforeBuild:
-      - powershell: "& ./src/servers/IIS/tools/UpdateIISExpressCertificate.ps1; & ./src/servers/IIS/tools/SetupTestEnvironment.ps1 Setup"
-        displayName: Prepare repo
-    afterBuild:
-      - powershell: "& ./src/servers/IIS/tools/SetupTestEnvironment.ps1 Shutdown"
-        displayName: Stop AppVerifier
-        condition: always()
-      - task: PublishBuildArtifacts@1
-        displayName: Upload logs
-        condition: eq(variables['system.pullrequest.isfork'], false)
-        inputs:
-          artifactName: logs
-          artifactType: Container
-          pathtoPublish: src/servers/IIS/artifacts/logs
-    buildDirectory: src/servers/IIS
--- a/.azure/pipelines/pr-validation-temp.yml
+++ b/.azure/pipelines/pr-validation-temp.yml
@ -1,38 +0,0 @@
-# This configuration is temporary while we work on getting all unit tests to pass on PR checks
-
-# Don't run CI for this config
-trigger: none
-
-# Run PR validation on all branches
-pr:
-  branches:
-    include:
-    - '*'
-
-jobs:
- template: jobs/default-build.yml
-  parameters:
-    jobName: Windows_Build
-    jobDisplayName: "Build only : Windows"
-    agentOs: Windows
-    buildArgs: '/p:SkipTests=true'
- template: jobs/default-build.yml
-  parameters:
-    jobName: macOs_Build
-    jobDisplayName: "Build only : macOS"
-    agentOs: macOS
-    buildArgs: '/p:SkipTests=true'
- template: jobs/default-build.yml
-  parameters:
-    jobName: Linux_Build
-    jobDisplayName: "Build only : Linux"
-    agentOs: Linux
-    buildArgs: '/p:SkipTests=true'
- job: Code_check
-  displayName: Code check
-  workspace:
-    clean: all
-  pool:
-    vmImage: vs2017-win2016
-  steps:
-  - powershell: ./eng/scripts/CodeCheck.ps1 -ci
--- a/.azure/pipelines/project-ci.yml
+++ b/.azure/pipelines/project-ci.yml
@ -1,60 +0,0 @@
-# Description: Runs build.cmd/sh on macOS, Linux, and Windows
-# Parameters:
-#   buildArgs: string
-#       Additional arguments to pass to the build.sh/cmd script.
-#       Note: -ci is always passed
-#   beforeBuild: [steps]
-#       Additional steps to run before build.sh/cmd
-#   afterBuild: [steps]
-#       Additional steps to run after build.sh/cmd
-#   variables: {}
-#       VSTS build and environment variables
-#   matrix: {}
-#       The matrix of configurations to run. By default, it runs a Debug and Release build on all platforms
-#   codeSign: boolean
-#       This build definition is enabled for code signing. (Only applies to Windows)
-#   buildDirectory: string
-#       Specifies what directory to run build.sh/cmd
-
-parameters:
-  buildArgs: ''
-  beforeBuild: []
-  afterBuild: []
-  codeSign: false
-  variables: {}
-  matrix:
-    Release:
-      BuildConfiguration: Release
-    Debug:
-      BuildConfiguration: Debug
-  buildDirectory: ''
-
-jobs:
- template: jobs/default-build.yml
-  parameters:
-    agentOs: Windows
-    matrix: ${{ parameters.matrix }}
-    buildArgs: ${{ parameters.buildArgs }}
-    beforeBuild: ${{ parameters.beforeBuild }}
-    afterBuild: ${{ parameters.afterBuild }}
-    codeSign: ${{ parameters.codeSign }}
-    variables: ${{ parameters.variables }}
-    buildDirectory: ${{ parameters.buildDirectory }}
- template: jobs/default-build.yml
-  parameters:
-    agentOs: macOS
-    matrix: ${{ parameters.matrix }}
-    buildArgs: ${{ parameters.buildArgs }}
-    beforeBuild: ${{ parameters.beforeBuild }}
-    afterBuild: ${{ parameters.afterBuild }}
-    variables: ${{ parameters.variables }}
-    buildDirectory: ${{ parameters.buildDirectory }}
- template: jobs/default-build.yml
-  parameters:
-    agentOs: Linux
-    matrix: ${{ parameters.matrix }}
-    buildArgs: ${{ parameters.buildArgs }}
-    beforeBuild: ${{ parameters.beforeBuild }}
-    afterBuild: ${{ parameters.afterBuild }}
-    variables: ${{ parameters.variables }}
-    buildDirectory: ${{ parameters.buildDirectory }}
--- a/.azure/pipelines/signalr-daily-tests.yml
+++ b/.azure/pipelines/signalr-daily-tests.yml
@ -0,0 +1,20 @@
+# Uses Scheduled Triggers, which aren't supported in YAML yet.
+# https://docs.microsoft.com/en-us/azure/devops/pipelines/build/triggers?view=vsts&tabs=yaml#scheduled
+
+# Daily Tests for ASP.NET Core SignalR
+# These use Sauce Labs resources, hence they run daily rather than per-commit.
+
+# The only Daily Tests we have run in Sauce Labs and only need to run on one machine (because they just trigger SauceLabs)
+# Hence we use the 'default-build.yml' template because it represents a single phase
+jobs:
+- template: jobs/default-build.yml
+  parameters:
+    buildDirectory: src/SignalR
+    buildArgs: "/p:DailyTests=true /p:SauceUser='$(asplab-sauce-labs-username)' /p:SauceKey='$(asplab-sauce-labs-access-key)' -t"
+    agentOs: Windows
+    jobName: SignalRDailyTests
+    jobDisplayName: "SignalR Daily Tests"
+    artifacts:
+    - name: Windows_Logs
+      path: ../../artifacts/log/
+      publishOnError: true
--- a/.azure/pipelines/stress.yml
+++ b/.azure/pipelines/stress.yml
@ -0,0 +1,35 @@
+# This configuration builds the repository and runs stress
+pr: none
+
+# Don't run CI for this config
+trigger: none
+
+variables:
+- name: DOTNET_SKIP_FIRST_TIME_EXPERIENCE
+  value: true
+- name: _TeamName
+  value:  AspNetCore
+- ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+  - name: _BuildArgs
+    value: /p:TeamName=$(_TeamName)
+      /p:OfficialBuildId=$(Build.BuildNumber)
+- ${{ if or(eq(variables['System.TeamProject'], 'public'), in(variables['Build.Reason'], 'PullRequest')) }}:
+  - name: _BuildArgs
+    value: ''
+jobs:
+- template: jobs/default-build.yml
+  parameters:
+    condition: ne(variables['SkipTests'], 'true')
+    jobName: Windows_Stress_Test
+    jobDisplayName: "Windows Stress test"
+    agentOs: Windows
+    isTestingJob: true
+    steps:
+    - script: .\src\Servers\Kestrel\stress\build.cmd -ci -c Release
+      displayName: Build Repo
+    - script: .\.dotnet\dotnet.exe run --project .\src\Servers\Kestrel\stress\HttpStress.csproj -c Release -aspnetlog
+      displayName: Run stress
+    artifacts:
+    - name: Windows_Test_Stress_Logs
+      path: artifacts/log/
+      publishOnError: true
--- a/.azure/pipelines/tools/SetupTestEnvironment.ps1
+++ b/.azure/pipelines/tools/SetupTestEnvironment.ps1
@ -1,9 +1,11 @@
-param($Mode)
+param(
+    [string]$Mode,
+    [string[]]$exes
+)

-$DumpFolder = "$env:ASPNETCORE_TEST_LOG_DIR\dumps"
 if (!($DumpFolder))
 {
-    $DumpFolder = "$PSScriptRoot\..\artifacts\dumps"
+    $DumpFolder = "$PSScriptRoot\..\..\..\artifacts\log\dumps"
 }
 if (!(Test-Path $DumpFolder))
 {
@ -11,17 +13,9 @@ if (!(Test-Path $DumpFolder))
 }
 $DumpFolder = Resolve-Path $DumpFolder

-$LogsFolder = "$PSScriptRoot\..\artifacts\logs"
-if (!(Test-Path $LogsFolder))
-{
-    New-Item $LogsFolder -ItemType Directory;
-}
-$LogsFolder = Resolve-Path $LogsFolder
-
 $werHive = "HKLM:\SOFTWARE\Microsoft\Windows\Windows Error Reporting";
 $ldHive = "$werHive\LocalDumps";

-
 function Setup-appverif($application)
 {
    appverif.exe -enable Exceptions Handles Heaps Leak Locks Memory Threadpool TLS SRWLock -for $application
@ -65,17 +59,17 @@ function Shutdown-appverif($application)

 function Setup-Dumps()
 {
-    if (!(Test-Path $ldHive ))
+    if (!(Test-Path $ldHive))
    {
        New-Item -Path $werHive -Name LocalDumps
    }

-    Move-Item $env:windir\System32\vsjitdebugger.exe $env:windir\System32\_vsjitdebugger.exe;
+    Move-Item $env:windir\System32\vsjitdebugger.exe $env:windir\System32\_vsjitdebugger.exe -ErrorAction Ignore;

    New-ItemProperty $werHive -Name "DontShowUI" -Value 1 -PropertyType "DWORD" -Force;

    New-ItemProperty $ldHive -Name "DumpFolder" -Value $DumpFolder -PropertyType "ExpandString" -Force;
-    New-ItemProperty $ldHive -Name "DumpCount" -Value 15 -PropertyType "DWORD" -Force;
+    New-ItemProperty $ldHive -Name "DumpCount" -Value 5 -PropertyType "DWORD" -Force;
    New-ItemProperty $ldHive -Name "DumpType" -Value 2 -PropertyType "DWORD" -Force;

    Restart-Service WerSvc
@ -83,13 +77,13 @@ function Setup-Dumps()

 function Shutdown-Dumps()
 {
-    Move-Item $env:windir\System32\_vsjitdebugger.exe $env:windir\System32\vsjitdebugger.exe;
+    Move-Item $env:windir\System32\_vsjitdebugger.exe $env:windir\System32\vsjitdebugger.exe -ErrorAction Ignore;

    Remove-Item $ldHive -Recurse -Force

    New-ItemProperty $werHive -Name "DontShowUI" -Value 0 -PropertyType "DWORD" -Force;

-    $cdb = "c:\Program Files (x86)\Windows Kits\10\Debuggers\x64\cdb.exe"
+    $cdb = "${env:ProgramFiles(x86)}\Windows Kits\10\Debuggers\x64\cdb.exe"
    if (!(Test-Path $cdb))
    {
        $downloadedFile = [System.IO.Path]::GetTempFileName();
@ -103,7 +97,7 @@ function Shutdown-Dumps()
    {
        if (Test-Path $cdb)
        {
-            & $cdb -z $dump.FullName -y "https://msdl.microsoft.com/download/symbols" -c ".loadby sos coreclr;!sym noisy;.reload /f;.dumpcab -a $($dump.FullName).cab;q;"
+            & $cdb -z $dump.FullName -y "cache*;srv*https://msdl.microsoft.com/download/symbols" -c ".loadby sos coreclr;!sym noisy;.reload /f;.dumpcab -a $($dump.FullName).cab;q;"
            Remove-Item $dump.FullName
        }
    }
@ -111,24 +105,27 @@ function Shutdown-Dumps()

 if ($Mode -eq "Setup")
 {
-    Setup-appverif w3wp.exe
-    Setup-appverif iisexpress.exe
+    foreach ($element in $exes) {
+        Setup-appverif $element
+    }

    Setup-Dumps;
 }

 if ($Mode -eq "SetupDumps")
 {
-    Shutdown-appverif w3wp.exe
-    Shutdown-appverif iisexpress.exe
+    foreach ($element in $exes) {
+        Shutdown-appverif $element
+    }

    Setup-Dumps;
 }

 if ($Mode -eq "Shutdown")
 {
-    Shutdown-appverif w3wp.exe
-    Shutdown-appverif iisexpress.exe
+    foreach ($element in $exes) {
+        Shutdown-appverif $element
+    }

    Shutdown-Dumps;
 }
--- a/.editorconfig
+++ b/.editorconfig
@ -1,6 +1,14 @@
 ; EditorConfig to support per-solution formatting.
 ; Use the EditorConfig VS add-in to make this work.
 ; http://editorconfig.org/
+;
+; Here are some resources for what's supported for .NET/C#
+; https://kent-boogaart.com/blog/editorconfig-reference-for-c-developers
+; https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2017
+;
+; Be **careful** editing this because some of the rules don't support adding a severity level
+; For instance if you change to `dotnet_sort_system_directives_first = true:warning` (adding `:warning`)
+; then the rule will be silently ignored.

 ; This is the default for the codeline.
 root = true
@ -11,9 +19,9 @@ charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true

-[*.{cs}]
+[*.cs]
 indent_size = 4
-dotnet_sort_system_directives_first = true:warning
+dotnet_sort_system_directives_first = true

 [*.{xml,config,*proj,nuspec,props,resx,targets,yml,tasks}]
 indent_size = 2
--- a/.gitattributes
+++ b/.gitattributes
@ -22,7 +22,7 @@
 #
 # Merging from the command prompt will add diff markers to the files if there
 # are conflicts (Merging from VS is not affected by the settings below, in VS
-# the diff markers are never inserted). Diff markers may cause the following 
+# the diff markers are never inserted). Diff markers may cause the following
 # file extensions to fail to load in VS. An alternative would be to treat
 # these files as binary and thus will always conflict and require user
 # intervention with every merge. To do so, just uncomment the entries below
@ -51,9 +51,9 @@

 ###############################################################################
 # diff behavior for common document formats
-# 
+#
 # Convert binary document formats to text before diffing them. This feature
-# is only available from the command line. Turn it on by uncommenting the 
+# is only available from the command line. Turn it on by uncommenting the
 # entries below.
 ###############################################################################
 #*.doc   diff=astextplain
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@ -0,0 +1,22 @@
+# Users referenced in this file will automatically be requested as reviewers for PRs that modify the given paths.
+# See https://help.github.com/articles/about-code-owners/
+
+/global.json                    @aspnet/build
+/.azure/                        @aspnet/build
+/.config/                       @aspnet/build
+/build/                         @aspnet/build
+/eng/                           @aspnet/build
+/eng/common/                    @dotnet-maestro-bot
+/eng/Versions.props             @dotnet-maestro-bot @dougbu
+/eng/Version.Details.xml        @dotnet-maestro-bot @dougbu
+/src/Components/                @SteveSandersonMS
+/src/DefaultBuilder/            @tratcher @anurse
+/src/Hosting/                   @tratcher @anurse
+/src/Http/                      @tratcher @jkotalik @anurse
+/src/Middleware/                @tratcher @anurse
+/src/ProjectTemplates/          @ryanbrandenburg
+/src/Security/                  @tratcher @anurse
+/src/Servers/                   @tratcher @jkotalik @anurse @halter73
+/src/Middleware/Rewrite         @jkotalik @anurse
+/src/Middleware/HttpsPolicy     @jkotalik @anurse
+/src/SignalR/                   @BrennanConroy @halter73 @anurse
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -0,0 +1,26 @@
+---
+name: Bug report
+about: Create a report about something that is not working
+---
+
+### If you believe you have an issue that affects the security of the platform please do NOT create an issue and instead email your issue details to secure@microsoft.com. Your report may be eligible for our [bug bounty](https://technet.microsoft.com/en-us/mt764065.aspx) but ONLY if it is reported through email.
+
+### Describe the bug
+A clear and concise description of what the bug is.
+
+### To Reproduce
+Steps to reproduce the behavior:
+1. Using this version of ASP.NET Core '...'
+2. Run this code '....'
+3. With these arguments '....'
+4. See error
+
+### Expected behavior
+A clear and concise description of what you expected to happen.
+
+### Screenshots
+If applicable, add screenshots to help explain your problem.
+
+### Additional context
+Add any other context about the problem here.
+Include the output of `dotnet --info`
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@ -0,0 +1,14 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+---
+
+### Is your feature request related to a problem? Please describe.
+A clear and concise description of what the problem is.
+Example: I am trying to do [...] but [...]
+
+### Describe the solution you'd like
+A clear and concise description of what you want to happen. Include any alternative solutions you've considered.
+
+### Additional context
+Add any other context or screenshots about the feature request here.
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@ -0,0 +1,5 @@
+Summary of the changes (Less than 80 chars)
+ - Detail 1
+ - Detail 2
+
+Addresses #bugnumber (in this specific format)
--- a/.gitignore
+++ b/.gitignore
@ -1,31 +1,42 @@
+# Folders
+artifacts/
 bin/
 obj/
-.vs/
-*.suo
-*.user
-_ReSharper.*
-*.DS_Store
-*.userprefs
-*.pidb
-*.vspx
-*.psess
-*.binlog
-*.log
-artifacts/
-StyleCop.Cache
-node_modules/
-*.snk
-.nuget
-.r
-.w
-.deps
-global.json
-msbuild.ProjectImports.zip
-.env
-scripts/tmp/
 .dotnet/
+.nuget/
+.packages/
 .tools/
-launchSettings.json
-korebuild-lock.txt
+.vs/
+.vscode/
+node_modules/
+BenchmarkDotNet.Artifacts/
 .gradle/
 src/SignalR/clients/**/dist/
+modules/
+
+# File extensions
+*.aps
+*.binlog
+*.dll
+*.DS_Store
+*.exe
+*.idb
+*.lib
+*.log
+*.pch
+*.pdb
+*.pidb
+*.psess
+*.res
+*.snk
+*.suo
+*.tlog
+*.user
+*.userprefs
+*.vspx
+
+# Specific files, typically generated by tools
+launchSettings.json
+msbuild.ProjectImports.zip
+StyleCop.Cache
+UpgradeLog.htm
--- a/.gitmodules
+++ b/.gitmodules
@ -1,4 +1,7 @@
-[submodule "modules/EntityFrameworkCore"]
-       path = modules/EntityFrameworkCore
-       url = https://github.com/dotnet/efcore.git
-       branch = release/2.1
+[submodule "googletest"]
+	path = src/submodules/googletest
+	url = https://github.com/google/googletest
+
+[submodule "src/submodules/MessagePack-CSharp"]
+	path = src/submodules/MessagePack-CSharp
+	url = https://github.com/aspnet/MessagePack-CSharp.git
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@ -1,9 +1,9 @@
 {
-    "files.trimTrailingWhitespace": true,
-    "files.associations": {
-        "*.*proj": "xml",
-        "*.props": "xml",
-        "*.targets": "xml",
-        "*.tasks": "xml"
-    }
+  "files.trimTrailingWhitespace": true,
+  "files.associations": {
+    "*.*proj": "xml",
+    "*.props": "xml",
+    "*.targets": "xml",
+    "*.tasks": "xml"
+  }
 }
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -1,4 +1,60 @@
-Contributing
-======
+# How to contribute

-Information on contributing to this repo is in the [Contributing Guide](https://github.com/aspnet/Home/blob/dev/CONTRIBUTING.md) in the Home repo.
+One of the easiest ways to contribute is to participate in discussions on GitHub issues. You can also contribute by submitting pull requests with code changes.
+
+## General feedback and discussions?
+Start a discussion on the [repository issue tracker](https://github.com/aspnet/AspNetCore/issues).
+
+## Bugs and feature requests?
+For non-security related bugs, log a new issue in the appropriate GitHub repository. Here are some of the most common repositories:
+
+* [Docs](https://github.com/aspnet/Docs)
+* [AspNetCore](https://github.com/aspnet/AspNetCore)
+* [Entity Framework Core](https://github.com/aspnet/EntityFrameworkCore)
+* [Tooling](https://github.com/aspnet/Tooling)
+* [Extensions](https://github.com/aspnet/Extensions)
+
+Or browse the full list of repositories in the [aspnet](https://github.com/aspnet/) organization.
+
+## Reporting security issues and bugs
+Security issues and bugs should be reported privately, via email, to the Microsoft Security Response Center (MSRC)  secure@microsoft.com. You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Further information, including the MSRC PGP key, can be found in the [Security TechCenter](https://technet.microsoft.com/en-us/security/ff852094.aspx).
+
+
+## Other discussions
+Our team members also monitor several other discussion forums:
+
+* [ASP.NET Core forum](https://forums.asp.net/1255.aspx/1?ASP+NET+5)
+* [Stack Overflow](https://stackoverflow.com/) with the [`asp.net-core`](https://stackoverflow.com/questions/tagged/asp.net-core), [`asp.net-core-mvc`](https://stackoverflow.com/questions/tagged/asp.net-core-mvc), or [`entity-framework-core`](https://stackoverflow.com/questions/tagged/entity-framework-core) tags.
+
+## Contributing code and content
+
+We accept fixes and features! Here are some resources to help you get started on how to contribute code or new content.
+
+* Look at the [Contributor documentation](/docs/) to get started on building the source code on your own.
+* ["Help wanted" issues](https://github.com/aspnet/AspNetCore/labels/help%20wanted) - these issues are up for grabs. Comment on an issue if you want to create a fix.
+* ["Good first issue" issues](https://github.com/aspnet/AspNetCore/labels/good%20first%20issue) - we think these are a good for newcomers.
+
+### Identifying the scale
+
+If you would like to contribute to one of our repositories, first identify the scale of what you would like to contribute. If it is small (grammar/spelling or a bug fix) feel free to start working on a fix. If you are submitting a feature or substantial code contribution, please discuss it with the team and ensure it follows the product roadmap. You might also read these two blogs posts on contributing code: [Open Source Contribution Etiquette](http://tirania.org/blog/archive/2010/Dec-31.html) by Miguel de Icaza and [Don't "Push" Your Pull Requests](https://www.igvita.com/2011/12/19/dont-push-your-pull-requests/) by Ilya Grigorik. All code submissions will be rigorously reviewed and tested by the ASP.NET and Entity Framework teams, and only those that meet an extremely high bar for both quality and design/roadmap appropriateness will be merged into the source.
+
+### Submitting a pull request
+
+You will need to sign a [Contributor License Agreement](https://cla.dotnetfoundation.org/) when submitting your pull request. To complete the Contributor License Agreement (CLA), you will need to follow the instructions provided by the CLA bot when you send the pull request. This needs to only be done once for any .NET Foundation OSS project.
+
+If you don't know what a pull request is read this article: https://help.github.com/articles/using-pull-requests. Make sure the repository can build and all tests pass. Familiarize yourself with the project workflow and our coding conventions. The coding, style, and general engineering guidelines are published on the [Engineering guidelines](https://github.com/aspnet/AspNetCore/wiki/Engineering-guidelines) page.
+
+### Tests
+
+-  Tests need to be provided for every bug/feature that is completed.
+-  Tests only need to be present for issues that need to be verified by QA (for example, not tasks)
+-  If there is a scenario that is far too hard to test there does not need to be a test for it.
+  - "Too hard" is determined by the team as a whole.
+
+### Feedback
+
+Your pull request will now go through extensive checks by the subject matter experts on our team. Please be patient; we have hundreds of pull requests across all of our repositories. Update your pull request according to feedback until it is approved by one of the ASP.NET team members. After that, one of our team members may adjust the branch you merge into based on the expected release schedule.
+
+## Code of conduct
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).  For more information, see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
--- a/Directory.Build.props
+++ b/Directory.Build.props
@ -1,53 +1,186 @@
-<Project>
-  <Import Project="version.props" />
+<Project>
+  <PropertyGroup>
+    <RepoRoot>$(MSBuildThisFileDirectory)</RepoRoot>
+    <RepositoryUrl>https://github.com/aspnet/AspNetCore</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+  </PropertyGroup>
+
+  <!-- Defines project type conventions. -->
+  <PropertyGroup>
+    <RepoRelativeProjectDir>$([MSBuild]::MakeRelative($(RepoRoot), $(MSBuildProjectDirectory)))</RepoRelativeProjectDir>
+
+    <IsReferenceAssemblyProject>false</IsReferenceAssemblyProject>
+    <IsReferenceAssemblyProject Condition="$(MSBuildProjectDirectory.EndsWith('ref'))">true</IsReferenceAssemblyProject>
+    <OutDirName Condition="'$(IsReferenceAssemblyProject)' == 'true'">$(MSBuildProjectName)-ref</OutDirName>
+
+    <IsBenchmarkProject Condition="$(MSBuildProjectName.EndsWith('.Performance')) OR $(RepoRelativeProjectDir.Contains('perf'))">true</IsBenchmarkProject>
+    <IsSpecificationTestProject Condition="$(MSBuildProjectName.EndsWith('.Specification.Tests'))">true</IsSpecificationTestProject>
+    <IsUnitTestProject>false</IsUnitTestProject>
+    <IsUnitTestProject Condition="'$(IsSpecificationTestProject)' != 'true' and ( $(MSBuildProjectName.EndsWith('Tests')) or $(MSBuildProjectName.EndsWith('.Test')) or $(MSBuildProjectName.EndsWith('.FunctionalTest')) )">true</IsUnitTestProject>
+    <IsTestAssetProject Condition="$(RepoRelativeProjectDir.Contains('testassets'))">true</IsTestAssetProject>
+    <IsSampleProject Condition="$(RepoRelativeProjectDir.Contains('sample'))">true</IsSampleProject>
+    <IsAnalyzersProject Condition="$(MSBuildProjectName.EndsWith('.Analyzers'))">true</IsAnalyzersProject>
+    <IsShipping Condition="'$(IsSampleProject)' == 'true' or '$(IsTestAssetProject)' == 'true' or '$(IsBenchmarkProject)' == 'true' or '$(IsUnitTestProject)' == 'true'">false</IsShipping>
+
+    <!--
+      Following logic mimics core-setup approach as well as
+      https://github.com/dotnet/arcade/blob/694d59f090b743f894779d04a7ffe11cbaf352e7/src/Microsoft.DotNet.Arcade.Sdk/tools/Publish.proj#L30-L31
+      $(DotNetFinalVersionKind) is set globally when doing final aka stable builds. Arcade infrastructure should pick
+      up $(IsStableBuild) automatically; property is also used to control prerelease branding.
+    -->
+    <IsStableBuild>false</IsStableBuild>
+    <IsStableBuild Condition=" '$(DotNetFinalVersionKind)' == 'release' ">true</IsStableBuild>
+  </PropertyGroup>
+
+  <Import Project="eng\FlakyTests.BeforeArcade.props" />
+  <Import Project="Sdk.props" Sdk="Microsoft.DotNet.Arcade.Sdk" />
+  <Import Project="eng\FlakyTests.AfterArcade.props" />

  <PropertyGroup>
    <Product>Microsoft ASP.NET Core</Product>
-    <RepositoryRoot>$(MSBuildThisFileDirectory)</RepositoryRoot>
-    <RepositoryUrl>https://github.com/aspnet/AspNetCore</RepositoryUrl>
-    <RepositoryType>git</RepositoryType>
-    <AssemblyOriginatorKeyFile>$(MSBuildThisFileDirectory)eng\AspNetCore.snk</AssemblyOriginatorKeyFile>
-    <SignAssembly>true</SignAssembly>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-  </PropertyGroup>
+    <StrongNameKeyId>MicrosoftAspNetCore</StrongNameKeyId>

-  <Import Project="build\external-dependencies.props" />
-  <Import Project="build\sources.props" />
+    <!-- The SPDX name for the source license. See https://spdx.org/licenses/. -->
+    <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>

-  <PropertyGroup>
-    <ArtifactsDir Condition="'$(ArtifactsDir)' == ''">$(RepositoryRoot)artifacts\</ArtifactsDir>
-    <ArtifactsObjDir>$(ArtifactsDir)obj\</ArtifactsObjDir>
-    <ArtifactsConfigurationDir>$(ArtifactsDir)$(Configuration)\</ArtifactsConfigurationDir>
-    <ArtifactsBinDir>$(ArtifactsConfigurationDir)bin\</ArtifactsBinDir>
-    <PackageOutputPath>$(ArtifactsDir)build\</PackageOutputPath>
+    <!-- Contact email address for NuGet packages and Linux installers. -->
+    <MaintainerEmail>nugetaspnet@microsoft.com</MaintainerEmail>

-    <RepoRelativeProjectDir>$([MSBuild]::MakeRelative($(RepositoryRoot), $(MSBuildProjectDirectory)))</RepoRelativeProjectDir>
+    <PackageProjectUrl>https://asp.net</PackageProjectUrl>
+    <NuspecBasePath>$(MSBuildProjectDirectory)</NuspecBasePath>

-    <IsBenchmarkProject Condition="$(MSBuildProjectName.EndsWith('.Performance')) OR $(RepoRelativeProjectDir.Contains('perf'))">true</IsBenchmarkProject>
-    <IsTestProject Condition="$(MSBuildProjectName.EndsWith('Tests')) OR $(MSBuildProjectName.EndsWith('.Test'))">true</IsTestProject>
-    <IsTestAssetProject Condition="$(RepoRelativeProjectDir.Contains('testassets'))">true</IsTestAssetProject>
-    <IsSampleProject Condition="$(RepoRelativeProjectDir.Contains('sample'))">true</IsSampleProject>
-
-    <IncludeSource>false</IncludeSource>
    <IncludeSymbols>true</IncludeSymbols>

-    <SharedSourceRoot>$(MSBuildThisFileDirectory)src\Shared\</SharedSourceRoot>
+    <DefaultNetCoreTargetFramework>netcoreapp3.1</DefaultNetCoreTargetFramework>
+  </PropertyGroup>

-    <SuppressNETCoreSdkPreviewMessage>true</SuppressNETCoreSdkPreviewMessage>
-    <DisableDeterministicSourceRoot Condition="'$(IsSampleProject)' == 'true' OR '$(IsTestAssetProject)' == 'true'">true</DisableDeterministicSourceRoot>
+  <!-- Warnings and errors -->
+  <PropertyGroup>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <!-- Don't make missing XML docs a fatal build error, but still surface so we have visibility into undocumented APIs. -->
+    <WarningsNotAsErrors>$(WarningsNotAsErrors);CS1591</WarningsNotAsErrors>
+    <!-- xUnit1004 = warns about skipped tests. Make this a non-fatal build warning. -->
+    <WarningsNotAsErrors>$(WarningsNotAsErrors);xUnit1004</WarningsNotAsErrors>
+  </PropertyGroup>
+
+  <!-- Source code settings -->
+  <PropertyGroup>
+    <SharedSourceRoot>$(MSBuildThisFileDirectory)src\Shared\</SharedSourceRoot>
+    <GoogleTestSubmoduleRoot>$(RepoRoot)src\submodules\googletest\</GoogleTestSubmoduleRoot>
+
+    <!-- Embed source files that are not tracked by the source control manager in the PDB. -->
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
  </PropertyGroup>

  <PropertyGroup>
-    <!-- Projects which reference Microsoft.AspNetCore.Mvc.Testing should import this targets file to ensure dependency .deps.json files are copied into test output. -->
-    <MvcTestingTargets>$(MSBuildThisFileDirectory)src\Mvc\Mvc.Testing\src\build\netstandard2.0\Microsoft.AspNetCore.Mvc.Testing.targets</MvcTestingTargets>
+    <SharedFxName>Microsoft.AspNetCore.App</SharedFxName>
+    <SharedFxDescription>Shared Framework for hosting of Microsoft ASP.NET Core applications. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub ($(RepositoryUrl)). We happily accept issues and PRs.</SharedFxDescription>
+
+    <NETCoreAppFrameworkIdentifier>.NETCoreApp</NETCoreAppFrameworkIdentifier>
+    <NETCoreAppFramework>netcoreapp$(AspNetCoreMajorMinorVersion)</NETCoreAppFramework>
+    <AspNetCoreAppFrameworkBrandName>ASP.NET Core $(AspNetCoreMajorMinorVersion)</AspNetCoreAppFrameworkBrandName>
+
+    <TargetingPackName>Microsoft.AspNetCore.App.Ref</TargetingPackName>
+    <RuntimeInstallerBaseName>aspnetcore-runtime</RuntimeInstallerBaseName>
+    <TargetingPackInstallerBaseName>aspnetcore-targeting-pack</TargetingPackInstallerBaseName>
+
+    <!-- Produce targeting pack installers/packages once per major.minor except in extraordinary cases i.e. 3.1.3. -->
+    <IsTargetingPackBuilding Condition=" '$(DotNetBuildFromSource)' == 'true' ">false</IsTargetingPackBuilding>
+    <IsTargetingPackBuilding
+        Condition=" '$(IsTargetingPackBuilding)' == '' AND '$(AspNetCorePatchVersion)' != '0' ">false</IsTargetingPackBuilding>
+    <IsTargetingPackBuilding Condition=" '$(IsTargetingPackBuilding)' == '' ">true</IsTargetingPackBuilding>
+
+    <!--
+      Archives and installers using this prefix are intended for internal-use only.
+      For example, this .zip is used to handoff bits to partner teams who then incorporate our shared frameworks
+      into their own installers.
+    -->
+    <InternalInstallerBaseName>$(RuntimeInstallerBaseName)-internal</InternalInstallerBaseName>
  </PropertyGroup>

+  <ItemGroup Condition="'$(DisablePubternalApiCheck)' != 'true' AND '$(IsTestProject)' != 'true' AND '$(IsBenchmarkProject)' != 'true' AND '$(IsTestAssetProject)' != 'true'">
+    <PackageReference Include="Internal.AspNetCore.Analyzers" PrivateAssets="All" Version="$(InternalAspNetCoreAnalyzersPackageVersion)" IsImplicitlyDefined="true" />
+  </ItemGroup>
+
+  <!-- Compilation options which apply to all languages. Language-specific options should be set in eng/targets/$(lang).Common.props -->
+  <PropertyGroup>
+    <TargetOsName Condition=" '$(TargetOsName)' == '' AND $([MSBuild]::IsOSPlatform('Windows'))">win</TargetOsName>
+    <TargetOsName Condition=" '$(TargetOsName)' == '' AND $([MSBuild]::IsOSPlatform('OSX'))">osx</TargetOsName>
+    <TargetOsName Condition=" '$(TargetOsName)' == '' AND $([MSBuild]::IsOSPlatform('Linux'))">linux</TargetOsName>
+    <TargetArchitecture Condition="'$(TargetArchitecture)' == ''">x64</TargetArchitecture>
+    <TargetRuntimeIdentifier>$(TargetOsName)-$(TargetArchitecture)</TargetRuntimeIdentifier>
+
+    <!-- This defines the list of RIDs supported by the ASP.NET Core shared framework. -->
+    <SupportedRuntimeIdentifiers>
+      win-x64;
+      win-x86;
+      win-arm;
+      win-arm64;
+      osx-x64;
+      linux-musl-x64;
+      linux-musl-arm64;
+      linux-x64;
+      linux-arm;
+      linux-arm64
+    </SupportedRuntimeIdentifiers>
+
+    <!-- Make error messages clickable in VS Code's console -->
+    <GenerateFullPaths Condition="'$(VSCODE_CWD)' != '' OR '$(TERM_PROGRAM)' == 'vscode'">true</GenerateFullPaths>
+
+    <!-- Fixes a common error in targets implementing a NoBuild mode. -->
+    <BuildProjectReferences Condition=" '$(NoBuild)' == 'true' ">false</BuildProjectReferences>
+  </PropertyGroup>
+
+  <!-- Artifacts layout. Keep these values consistent with items defined in eng/Publishing.props. -->
+  <PropertyGroup>
+    <InstallersOutputPath>$(ArtifactsDir)installers\$(Configuration)\</InstallersOutputPath>
+    <SymbolsOutputPath>$(ArtifactsDir)symbols\$(Configuration)\</SymbolsOutputPath>
+  </PropertyGroup>
+
+  <!-- Ensure these output paths exist. -->
+  <ItemGroup>
+    <CreateDirectory Include="$(InstallersOutputPath)" />
+    <CreateDirectory Include="$(VisualStudioSetupOutputPath)" />
+  </ItemGroup>
+
+  <!-- The location of the local installation of the .NET Core shared framework. -->
+  <PropertyGroup>
+    <LocalDotNetRoot>$(RepoRoot).dotnet\</LocalDotNetRoot>
+    <!-- Override the SDK default and point to local .dotnet folder. -->
+    <NetCoreTargetingPackRoot>$(LocalDotNetRoot)packs\</NetCoreTargetingPackRoot>
+  </PropertyGroup>
+
+  <Import Project="eng\tools\RepoTasks\RepoTasks.tasks" Condition="'$(MSBuildProjectName)' != 'RepoTasks' AND '$(DesignTimeBuild)' != 'true'" />
+
+  <PropertyGroup>
+    <!--
+      Disable deterministic source paths in test assets and samples.
+      In order for the debugger to find source files when debugging a locally built binary the PDB must contain original, unmapped local paths
+    -->
+    <DeterministicSourcePaths Condition="'$(IsSampleProject)' == 'true' OR '$(IsTestAssetProject)' == 'true'">false</DeterministicSourcePaths>
+    <!-- Projects which reference Microsoft.AspNetCore.Mvc.Testing should import this targets file to ensure dependency .deps.json files are copied into test output. -->
+    <MvcTestingTargets>$(MSBuildThisFileDirectory)src\Mvc\Mvc.Testing\src\Microsoft.AspNetCore.Mvc.Testing.targets</MvcTestingTargets>
+    <!-- IIS native projects can only be built on Windows for x86 and x64. -->
+    <BuildIisNativeProjects Condition="'$(BuildNative)' == 'true' AND '$(TargetOsName)' == 'win' AND ('$(TargetArchitecture)' == 'x86' OR '$(TargetArchitecture)' == 'x64')">true</BuildIisNativeProjects>
+    <!-- This property is shared by several projects to layout the AspNetCore.App targeting pack for installers -->
+    <TargetingPackLayoutRoot>$(ArtifactsObjDir)TargetingPack.Layout\$(Configuration)\</TargetingPackLayoutRoot>
+    <!-- This property is shared by several projects to layout the AspNetCore.App shared framework for installers -->
+    <SharedFrameworkLayoutRoot>$(ArtifactsObjDir)SharedFx.Layout\$(Configuration)\$(TargetRuntimeIdentifier)\</SharedFrameworkLayoutRoot>
+    <!-- This property points to a folder which includes both Microsoft.NETCore.App and AspNetCore.App. -->
+    <RedistSharedFrameworkLayoutRoot>$(ArtifactsObjDir)RedistSharedFx.Layout\$(Configuration)\$(TargetRuntimeIdentifier)\</RedistSharedFrameworkLayoutRoot>
+
+    <ArchiveExtension>.tar.gz</ArchiveExtension>
+    <ArchiveExtension Condition="'$(TargetOsName)' == 'win'">.zip</ArchiveExtension>
+  </PropertyGroup>
+
+  <Import Project="eng\Workarounds.props" />
  <Import Project="eng\Dependencies.props" />
-  <Import Project="eng\PatchConfig.props" />
  <Import Project="eng\ProjectReferences.props" />
-  <Import Project="eng\targets\Wix.Common.props"  Condition="'$(MSBuildProjectExtension)' == '.wixproj'" />
-  <Import Project="eng\targets\CSharp.Common.props"  Condition="'$(MSBuildProjectExtension)' == '.csproj'" />
+  <Import Project="eng\SharedFramework.Local.props" />
+  <Import Project="eng\SharedFramework.External.props" />
  <Import Project="eng\targets\Cpp.Common.props"  Condition="'$(MSBuildProjectExtension)' == '.vcxproj'" />
+  <Import Project="eng\targets\CSharp.Common.props"  Condition="'$(MSBuildProjectExtension)' == '.csproj'" />
+  <Import Project="eng\targets\Wix.Common.props"  Condition="'$(MSBuildProjectExtension)' == '.wixproj'" />
  <Import Project="eng\targets\Npm.Common.props"  Condition="'$(MSBuildProjectExtension)' == '.npmproj'" />

 </Project>
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@ -1,31 +1,78 @@
 <Project>
+
+  <PropertyGroup>
+    <!-- Only build Microsoft.AspNetCore.App and ref/ assemblies in source build. -->
+    <!-- Analyzer package are needed in source build for WebSDK -->
+    <ExcludeFromSourceBuild
+        Condition="'$(ExcludeFromSourceBuild)' == '' and '$(DotNetBuildFromSource)' == 'true' and '$(IsAspNetCoreApp)' != 'true' and '$(IsReferenceAssemblyProject)' != 'true' and '$(IsAnalyzersProject)' != 'true'">true</ExcludeFromSourceBuild>
+  </PropertyGroup>
+
+  <PropertyGroup Label="Resx settings">
+    <GenerateResxSource Condition="$(GenerateResxSource) == ''">true</GenerateResxSource>
+    <GenerateResxSourceEmitFormatMethods Condition="$(GenerateResxSourceEmitFormatMethods) == ''">true</GenerateResxSourceEmitFormatMethods>
+  </PropertyGroup>
+
+  <Import Project="Sdk.targets" Sdk="Microsoft.DotNet.Arcade.Sdk" />
  <!-- Properties which should be set after the project has been evaluated -->
-  <PropertyGroup Condition=" '$(MSBuildProjectExtension)' == '.csproj'">
+
+  <PropertyGroup Label="Versioning settings">
+    <!-- The 'human friendly' version to display in installers. In pre-release builds, this might be "2.0.7 Preview 2 Build 12356". In final builds, it should be "2.0.7" -->
+    <BrandingVersionSuffix>$(PreReleaseBrandingLabel) Build $(VersionSuffix)</BrandingVersionSuffix>
+    <PackageBrandingVersion>$(VersionPrefix)</PackageBrandingVersion>
+    <PackageBrandingVersion Condition=" '$(VersionSuffix)' != '' ">$(PackageBrandingVersion) $(BrandingVersionSuffix.Trim())</PackageBrandingVersion>
+
+    <SiteExtensionPackageVersion>$(VersionPrefix)</SiteExtensionPackageVersion>
+    <SiteExtensionPackageVersion Condition=" '$(VersionSuffix)' != '' ">$(VersionPrefix)-$(VersionSuffix.Replace('.','-'))</SiteExtensionPackageVersion>
+
+    <PackageVersion Condition=" '$(PackageVersion)' == '' ">$(Version)</PackageVersion>
+    <PackageVersion Condition=" '$(NoSemVer20)' == 'true' ">$(SiteExtensionPackageVersion)</PackageVersion>
+    <SharedFxVersion>$(PackageVersion)</SharedFxVersion>
+
+    <TargetingPackVersion>$(TargetingPackVersionPrefix)</TargetingPackVersion>
+    <TargetingPackVersion Condition=" '$(VersionSuffix)' != '' ">$(TargetingPackVersionPrefix)-$(VersionSuffix)</TargetingPackVersion>
+
+    <SharedFxProductName>$(Product) $(PackageVersion) Shared Framework</SharedFxProductName>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <!-- Analyzers package are special. In general, they should not have dependencies in the nuspec. Analyzer assemblies are not meant to be used for compilation or runtime. -->
+    <SuppressDependenciesWhenPacking Condition="'$(SuppressDependenciesWhenPacking)' == '' AND '$(IsAnalyzersProject)' == 'true'">true</SuppressDependenciesWhenPacking>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(PackAsTool)' == 'true' AND '$(IsShippingPackage)' == 'true'">
+    <!-- This is a requirement for Microsoft tool packages only. -->
+    <PackAsToolShimRuntimeIdentifiers>win-x64;win-x86</PackAsToolShimRuntimeIdentifiers>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(MSBuildProjectExtension)' == '.csproj' ">
    <PackageId Condition=" '$(PackageId)' == '' ">$(AssemblyName)</PackageId>
-    <IsPackable Condition="'$(IsPackable)' == '' AND ( '$(IsTestProject)' == 'true' OR '$(IsTestAssetProject)' == 'true' OR '$(IsBenchmarkProject)' == 'true' OR '$(IsSampleProject)' == 'true' ) ">false</IsPackable>
+    <IsPackable Condition="'$(IsPackable)' == '' AND ( '$(IsTestProject)' == 'true' OR '$(IsTestAssetProject)' == 'true' OR '$(IsBenchmarkProject)' == 'true' OR '$(IsSampleProject)' == 'true' OR '$(IsReferenceAssemblyProject)' == 'true' ) ">false</IsPackable>
  </PropertyGroup>

  <Import Project="eng\Baseline.Designer.props" />

-  <PropertyGroup Condition=" '$(IsPackable)' != 'false' AND '$(AspNetCorePatchVersion)' != '0' ">
-    <!-- Always include framework metapackages in patch updates. -->
-    <IsPackageInThisPatch Condition="'$(IsFrameworkMetapackage)' == 'true' OR '$(IsSharedSourcePackage)' == 'true' ">true</IsPackageInThisPatch>
-    <IsPackageInThisPatch Condition="'$(IsPackageInThisPatch)' == ''">$(PackagesInPatch.Contains(' $(PackageId);'))</IsPackageInThisPatch>
-    
-    <!-- ANCM always builds every patch as we don't push temporary nuget packages anymore and that ANCM itself is a global singleton -->
-    <IsPackageInThisPatch Condition="'$(IsANCMPackage)' == 'true'">true</IsPackageInThisPatch>
-  </PropertyGroup>
-
  <PropertyGroup Condition=" '$(IsPackable)' != 'false' AND '$(IsServicingBuild)' == 'true' ">
+    <IsPackageInThisPatch Condition="'$(IsPackageInThisPatch)' == ''">true</IsPackageInThisPatch>
    <!-- Used to distinguish between packages building -->
    <IsPackableInNonServicingBuild>true</IsPackableInNonServicingBuild>
-    <!-- Suppress creation of .nupkg for servicing builds. -->
+    <!-- Suppress creation of .nupkg for servicing builds of non-shipping projects. -->
    <IsPackable Condition=" '$(IsPackageInThisPatch)' != 'true' ">false</IsPackable>
  </PropertyGroup>

-  <PropertyGroup Condition=" '$(IsPackageInThisPatch)' != 'true' AND '$(BaselinePackageVersion)' != '' ">
+  <PropertyGroup>
+    <!-- When OnlyPackPlatformSpecificPackages is set, only produce packages for projects which set RuntimeIdentifier. -->
+    <!-- Keep this below where we set "IsPackageInThisPatch" -->
+    <IsPackable Condition=" '$(OnlyPackPlatformSpecificPackages)' == 'true' AND '$(RuntimeIdentifier)' == '' ">false</IsPackable>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <PackageVersionForPackageVersionInfo>$(PackageVersion)</PackageVersionForPackageVersionInfo>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(IsPackageInThisPatch)' != 'true' AND '$(BaselinePackageVersion)' != '' AND '$(IsServicingBuild)' == 'true' ">
    <!-- This keeps assembly and package versions consistent across patches. If a package is not included in a patch, its version should stay at the baseline. -->
-    <AssemblyVersion>$(BaselinePackageVersion).0</AssemblyVersion>
+    <AssemblyVersion Condition="$(BaselinePackageVersion.Contains('-'))">$(BaselinePackageVersion.Substring(0, $(BaselinePackageVersion.IndexOf('-')))).0</AssemblyVersion>
+    <AssemblyVersion Condition="! $(BaselinePackageVersion.Contains('-'))">$(BaselinePackageVersion).0</AssemblyVersion>
    <!--
      Ideally, we would also set the project version to match the baseline in case NuGet turns a ProjectReference into a nuspec depenendency, but
      NuGet does not currently handle conflicts between packages and projects which have the same package id/version.
@ -35,31 +82,95 @@
    -->
    <Version Condition="'$(NoBuild)' == 'true' AND '$(DesignTimeBuild)' == 'true'">$(BaselinePackageVersion)</Version>
    <PackageVersion Condition="'$(NoBuild)' == 'true' AND '$(DesignTimeBuild)' == 'true'">$(BaselinePackageVersion)</PackageVersion>
+
+    <!-- For servicing builds, we want to resolve baseline versions of project packages that aren't building, always -->
+    <PackageVersionForPackageVersionInfo>$(BaselinePackageVersion)</PackageVersionForPackageVersionInfo>
  </PropertyGroup>

  <PropertyGroup>
    <!-- Implementation projects are the projects which produce nuget packages or shipping assemblies. -->
-    <IsImplementationProject Condition=" '$(IsImplementationProject)' == '' AND '$(IsTestAssetProject)' != 'true' AND '$(IsTestProject)' != 'true' AND '$(IsBenchmarkProject)' != 'true' AND '$(IsSampleProject)' != 'true' ">true</IsImplementationProject>
+    <IsImplementationProject Condition=" '$(IsImplementationProject)' == '' AND '$(IsAnalyzersProject)' != 'true' AND '$(IsTestAssetProject)' != 'true' AND '$(IsTestProject)' != 'true' AND '$(IsBenchmarkProject)' != 'true' AND '$(IsSampleProject)' != 'true' AND '$(IsReferenceAssemblyProject)' != 'true' ">true</IsImplementationProject>

    <!-- This determines whether a project is available as a <Reference> to other projects in this repo. -->
    <IsProjectReferenceProvider Condition=" '$(IsProjectReferenceProvider)' == '' AND '$(IsImplementationProject)' == 'true' AND '$(PackAsTool)' != 'true' ">true</IsProjectReferenceProvider>

-    <!-- Suppress KoreBuild warnings about the mismatch of repo version and local project version. The versioning in this mega repo is sufficiently complicated that KoreBuild's validation isn't helpful. -->
-    <VerifyVersion>false</VerifyVersion>
+    <HasReferenceAssembly
+        Condition=" '$(HasReferenceAssembly)' == '' AND '$(IsProjectReferenceProvider)' == 'true' AND '$(IsAspNetCoreApp)' == 'true' ">true</HasReferenceAssembly>
+    <HasReferenceAssembly Condition="'$(HasReferenceAssembly)' == ''">false</HasReferenceAssembly>

-    <EnableApiCheck Condition=" '$(EnableApiCheck)' != '' ">$(IsImplementationProject)</EnableApiCheck>
-    <IsPackable Condition="'$(IsPackable)' == '' AND '$(IsImplementationProject)' == 'true' ">true</IsPackable>
+    <IsPackable Condition="'$(IsPackable)' == '' AND ('$(IsImplementationProject)' == 'true' OR '$(IsAnalyzersProject)' == 'true') ">true</IsPackable>
    <IsPackable Condition="'$(IsPackable)' == '' ">false</IsPackable>

-    <RuntimeFrameworkVersion Condition=" '$(TargetFramework)' == 'netcoreapp2.0' ">$(MicrosoftNETCoreApp20PackageVersion)</RuntimeFrameworkVersion>
-    <RuntimeFrameworkVersion Condition=" '$(TargetFramework)' == 'netcoreapp2.1' ">$(MicrosoftNETCoreApp21PackageVersion)</RuntimeFrameworkVersion>
-    <NETStandardImplicitPackageVersion Condition=" '$(TargetFramework)' == 'netstandard2.0' ">$(NETStandardLibrary20PackageVersion)</NETStandardImplicitPackageVersion>
+    <BuildHelixPayload Condition="'$(BuildHelixPayload)' == '' AND '$(IsTestProject)' == 'true'">true</BuildHelixPayload>
  </PropertyGroup>

-  <Import Project="eng\targets\Wix.Common.targets"  Condition="'$(MSBuildProjectExtension)' == '.wixproj'" />
+  <PropertyGroup>
+    <PackageThirdPartyNoticesFile Condition="'$(PackageThirdPartyNoticesFile)' == ''">$(RepoRoot)THIRD-PARTY-NOTICES.TXT</PackageThirdPartyNoticesFile>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(IsPackable)' == 'true'">
+    <None Include="$(PackageThirdPartyNoticesFile)" Pack="true" PackagePath="." />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(Language)' == 'C#' AND '$(IsReferenceAssemblyProject)' == 'true'">
+    <Compile Include="$(SharedSourceRoot)ReferenceAssemblyInfo.cs" LinkBase="Properties" />
+  </ItemGroup>
+
+  <PropertyGroup Condition="'$(Language)' == 'C#' AND '$(IsReferenceAssemblyProject)' == 'true'">
+    <!-- Reference assemblies should always use Major.Minor.0.0 for assembly versions even during servicing. Only the package version should be updated. -->
+    <AssemblyVersion>$(AspNetCoreMajorVersion).$(AspNetCoreMinorVersion).0.0</AssemblyVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <KnownFrameworkReference Update="Microsoft.NETCore.App">
+      <!-- Always update the 'latest version', whether the repo is servicing or not. -->
+      <LatestRuntimeFrameworkVersion Condition="'%(TargetFramework)' == '$(DefaultNetCoreTargetFramework)'">$(MicrosoftNETCoreAppRuntimeVersion)</LatestRuntimeFrameworkVersion>
+      <!-- Only update the default runtime version for preview builds. -->
+      <DefaultRuntimeFrameworkVersion Condition="'%(TargetFramework)' == '$(DefaultNetCoreTargetFramework)' and '$(IsServicingBuild)' != 'true'">$(MicrosoftNETCoreAppRuntimeVersion)</DefaultRuntimeFrameworkVersion>
+      <!-- Only update the targeting pack version for preview builds. -->
+      <TargetingPackVersion Condition="'%(TargetFramework)' == '$(DefaultNetCoreTargetFramework)' and '$(IsServicingBuild)' != 'true'">$(MicrosoftNETCoreAppRefPackageVersion)</TargetingPackVersion>
+    </KnownFrameworkReference>
+
+    <KnownFrameworkReference Condition="'$(UseAspNetCoreSharedRuntime)' != 'true'" Remove="Microsoft.AspNetCore.App" />
+    <KnownFrameworkReference Remove="Microsoft.WindowsDesktop.App" />
+
+    <KnownFrameworkReference Condition="'$(UseAspNetCoreSharedRuntime)' == 'true'" Update="Microsoft.AspNetCore.App">
+      <LatestRuntimeFrameworkVersion>$(SharedFxVersion)</LatestRuntimeFrameworkVersion>
+      <DefaultRuntimeFrameworkVersion Condition="'$(IsServicingBuild)' != 'true'">$(SharedFxVersion)</DefaultRuntimeFrameworkVersion>
+      <TargetingPackVersion Condition="'$(IsServicingBuild)' != 'true'">$(SharedFxVersion)</TargetingPackVersion>
+    </KnownFrameworkReference>
+
+    <KnownFrameworkReference Update="NETStandard.Library">
+      <TargetingPackVersion Condition="'%(TargetFramework)' == 'netstandard2.1' and '$(IsServicingBuild)' != 'true'">$(NETStandardLibraryRefPackageVersion)</TargetingPackVersion>
+    </KnownFrameworkReference>
+
+    <!-- Track compiler separately from Arcade.-->
+    <PackageReference Include="Microsoft.Net.Compilers.Toolset"
+        Version="$(MicrosoftNetCompilersToolsetPackageVersion)"
+        PrivateAssets="all"
+        IsImplicitlyDefined="true" />
+  </ItemGroup>
+
+  <PropertyGroup Condition=" '$(CopySymbolsToArtifacts)' == 'true' AND '$(TargetFramework)' != '' ">
+    <BuildDependsOn>$(BuildDependsOn);_CopySymbolsToArtifacts</BuildDependsOn>
+  </PropertyGroup>
+
+  <Target Name="_CopySymbolsToArtifacts">
+    <Copy SourceFiles="$([System.IO.Path]::ChangeExtension('$(TargetPath)', 'pdb'))"
+        DestinationFolder="$(SymbolsOutputPath)$(TargetFramework)"
+        OverwriteReadOnlyFiles="$(OverwriteReadOnlyFiles)"
+        Retries="$(CopyRetryCount)"
+        RetryDelayMilliseconds="$(CopyRetryDelayMilliseconds)"
+        SkipUnchangedFiles="$(SkipCopyUnchangedFiles)" />
+  </Target>
+
+  <Import Project="eng\Workarounds.targets" />
+  <Import Project="eng\targets\ResolveIisReferences.targets" Condition=" '$(MSBuildProjectExtension)' != '.vcxproj' " />
+  <Import Project="eng\targets\Cpp.Common.targets"  Condition="'$(MSBuildProjectExtension)' == '.vcxproj'" />
  <Import Project="eng\targets\CSharp.Common.targets"  Condition="'$(MSBuildProjectExtension)' == '.csproj'" />
  <Import Project="eng\targets\FSharp.Common.targets"  Condition="'$(MSBuildProjectExtension)' == '.fsproj'" />
-  <Import Project="eng\targets\Cpp.Common.targets"  Condition="'$(MSBuildProjectExtension)' == '.vcxproj'" />
+  <Import Project="eng\targets\Wix.Common.targets"  Condition="'$(MSBuildProjectExtension)' == '.wixproj'" />
  <Import Project="eng\targets\Npm.Common.targets"  Condition="'$(MSBuildProjectExtension)' == '.npmproj'" />
-  <Import Project="eng\targets\ResolveIisReferences.targets" Condition=" '$(MSBuildProjectExtension)' != '.vcxproj' " />
+  <Import Project="eng\targets\ReferenceAssembly.targets" Condition=" $(HasReferenceAssembly) " />
+
 </Project>
--- a/LICENSE.txt
+++ b/LICENSE.txt
@ -1,12 +1,201 @@
-Copyright (c) .NET Foundation. All rights reserved.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/

-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-these files except in compliance with the License. You may obtain a copy of the
-License at
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

-http://www.apache.org/licenses/LICENSE-2.0
+   1. Definitions.

-Unless required by applicable law or agreed to in writing, software distributed
-under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-CONDITIONS OF ANY KIND, either express or implied. See the License for the
-specific language governing permissions and limitations under the License.
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
--- a/NuGet.config
+++ b/NuGet.config
@ -1,7 +1,14 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
  <packageSources>
    <clear />
-    <!-- Restore sources should be defined in build/sources.props. -->
+    <!--Begin: Package sources managed by Dependency Flow automation. Do not edit the sources below.-->
+    <add key="darc-pub-dotnet-corefx-8a3ffed" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/darc-pub-dotnet-corefx-8a3ffed5/nuget/v3/index.json" />
+    <!--End: Package sources managed by Dependency Flow automation. Do not edit the sources above.-->
+    <add key="dotnet-core" value="https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json" />
+    <add key="dotnet-eng" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json" />
+    <add key="dotnet3.1" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet3.1/nuget/v3/index.json" />
+    <add key="dotnet3.1-transport" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet3.1-transport/nuget/v3/index.json" />
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
  </packageSources>
 </configuration>
--- a/README.md
+++ b/README.md
@ -16,7 +16,7 @@ and make pull-requests.

 * [Download our latest daily builds](./docs/DailyBuilds.md)
 * Follow along with the development of ASP.NET Core:
-    * [Community Standup](http://live.asp.net): The community standup is held every week and streamed live to YouTube. You can view past standups in the linked playlist.
+    * [Community Standup](https://live.asp.net): The community standup is held every week and streamed live to YouTube. You can view past standups in the linked playlist.
    * [Roadmap](https://github.com/aspnet/AspNetCore/wiki/Roadmap): The schedule and milestone themes for ASP.NET Core.
 * [Build ASP.NET Core source code](./docs/BuildFromSource.md)
 * Check out the [contributing](CONTRIBUTING.md) page to see the best places to log issues and start discussions.
--- a/SECURITY.md
+++ b/SECURITY.md
@ -0,0 +1,15 @@
+# Security Policy
+
+## Supported Versions
+
+The .NET Core and ASP.NET Core support policy, including supported versions can be found at the [.NET Core Support Policy Page](https://dotnet.microsoft.com/platform/support/policy/dotnet-core).
+
+## Reporting a Vulnerability
+
+Security issues and bugs should be reported privately, via email, to the Microsoft Security Response Center (MSRC) secure@microsoft.com. 
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your 
+original message. Further information, including the MSRC PGP key, can be found in the [Security TechCenter](https://technet.microsoft.com/en-us/security/ff852094.aspx).
+
+Reports via MSRC may qualify for the .NET Core Bug Bounty. Details of the .NET Core Bug Bounty including terms and conditions are at [https://aka.ms/corebounty](https://aka.ms/corebounty).
+
+Please do not open issues for anything you think might have a security implication.
--- a/86
+++ b/86
@ -1,86 +0,0 @@
-.NET Core uses third-party libraries or other resources that may be
-distributed under licenses different than the .NET Core software.
-
-In the event that we accidentally failed to list a required notice, please
-bring it to our attention. Post an issue or email us:
-
-           dotnet@microsoft.com
-
-The attached notices are provided for information only.
-
-License notice for dotnet-deb-tool
------------------------------------
-
-The MIT License (MIT)
-
-Copyright (c) .NET Foundation and Contributors
-
-All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-License notice for IIS-Common
------------------------------------
-
-MIT License
-
-Copyright (c) Microsoft Corporation. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE
-
-License notice for IIS-Setup
------------------------------------
-
-MIT License
-
-Copyright (c) Microsoft Corporation. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE
--- a/THIRD-PARTY-NOTICES.txt
+++ b/THIRD-PARTY-NOTICES.txt
@ -0,0 +1,191 @@
+.NET Core uses third-party libraries or other resources that may be
+distributed under licenses different than the .NET Core software.
+
+In the event that we accidentally failed to list a required notice, please
+bring it to our attention. Post an issue or email us:
+
+           dotnet@microsoft.com
+
+The attached notices are provided for information only.
+
+License notice for dotnet-deb-tool
+------------------------------------
+
+The MIT License (MIT)
+
+Copyright (c) .NET Foundation and Contributors
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+License notice for IIS-Common
+------------------------------------
+
+MIT License
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE
+
+License notice for IIS-Setup
+------------------------------------
+
+MIT License
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE
+
+License notice for viz.js
+------------------------------------
+
+Copyright (c) 2014-2018 Michael Daines
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+License notice for MessagePack-CSharp
+-------------------------------------
+
+MessagePack for C#
+
+MIT License
+
+Copyright (c) 2017 Yoshifumi Kawai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+lz4net
+
+Copyright (c) 2013-2017, Milosz Krajewski
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+License notice for Nerdbank.Streams
+-----------------------------------
+
+The MIT License (MIT)
+
+Copyright (c) Andrew Arnott
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+License notice for Angular v8.0
+--------------------------------------------
+The MIT License (MIT)
+=====================
+
+Copyright (c) 2010-2019 Google LLC. http://angular.io/license
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
--- a/activate.ps1
+++ b/activate.ps1
@ -0,0 +1,65 @@
+#
+# This file must be used by invoking ". .\activate.ps1" from the command line.
+# You cannot run it directly. See https://docs.microsoft.com/powershell/module/microsoft.powershell.core/about/about_scripts#script-scope-and-dot-sourcing
+#
+# To exit from the environment this creates, execute the 'deactivate' function.
+#
+
+if ($MyInvocation.CommandOrigin -eq 'runspace') {
+    Write-Host -f Red "This script cannot be invoked directly."
+    Write-Host -f Red "To function correctly, this script file must be 'dot sourced' by calling `". $PSCommandPath`" (notice the dot at the beginning)."
+    exit 1
+}
+
+function deactivate ([switch]$init) {
+
+    # reset old environment variables
+    if (Test-Path variable:_OLD_PATH) {
+        $env:PATH = $_OLD_PATH
+        Remove-Item variable:_OLD_PATH
+    }
+
+    if (test-path function:_old_prompt) {
+        Set-Item Function:prompt -Value $function:_old_prompt -ea ignore
+        remove-item function:_old_prompt
+    }
+
+    Remove-Item env:DOTNET_ROOT -ea ignore
+    Remove-Item env:DOTNET_MULTILEVEL_LOOKUP -ea ignore
+    if (-not $init) {
+        # Remove the deactivate function
+        Remove-Item function:deactivate
+    }
+}
+
+# Cleanup the environment
+deactivate -init
+
+$_OLD_PATH = $env:PATH
+# Tell dotnet where to find itself
+$env:DOTNET_ROOT = "$PSScriptRoot\.dotnet"
+${env:DOTNET_ROOT(x86)} = "$PSScriptRoot\.dotnet\x86"
+# Tell dotnet not to look beyond the DOTNET_ROOT folder for more dotnet things
+$env:DOTNET_MULTILEVEL_LOOKUP = 0
+# Put dotnet first on PATH
+$env:PATH = "${env:DOTNET_ROOT};${env:PATH}"
+
+# Set the shell prompt
+if (-not $env:DISABLE_CUSTOM_PROMPT) {
+    $function:_old_prompt = $function:prompt
+    function dotnet_prompt {
+        # Add a prefix to the current prompt, but don't discard it.
+        write-host "($( split-path $PSScriptRoot -leaf )) " -nonewline
+        & $function:_old_prompt
+    }
+
+    Set-Item Function:prompt -Value $function:dotnet_prompt -ea ignore
+}
+
+Write-Host -f Magenta "Enabled the .NET Core environment. Execute 'deactivate' to exit."
+if (-not (Test-Path "${env:DOTNET_ROOT}\dotnet.exe")) {
+    Write-Host -f Yellow ".NET Core has not been installed yet. Run $PSScriptRoot\restore.cmd to install it."
+}
+else {
+    Write-Host "dotnet = ${env:DOTNET_ROOT}\dotnet.exe"
+}
--- a/activate.sh
+++ b/activate.sh
@ -0,0 +1,94 @@
+#
+# This file must be used by invoking "source activate.sh" from the command line.
+# You cannot run it directly.
+# To exit from the environment this creates, execute the 'deactivate' function.
+
+_RED="\033[0;31m"
+_MAGENTA="\033[0;95m"
+_YELLOW="\033[0;33m"
+_RESET="\033[0m"
+
+# This detects if a script was sourced or invoked directly
+# See https://stackoverflow.com/a/28776166/2526265
+sourced=0
+if [ -n "$ZSH_EVAL_CONTEXT" ]; then
+  case $ZSH_EVAL_CONTEXT in *:file) sourced=1;; esac
+  THIS_SCRIPT="${0:-}"
+elif [ -n "$KSH_VERSION" ]; then
+  [ "$(cd $(dirname -- $0) && pwd -P)/$(basename -- $0)" != "$(cd $(dirname -- ${.sh.file}) && pwd -P)/$(basename -- ${.sh.file})" ] && sourced=1
+  THIS_SCRIPT="${0:-}"
+elif [ -n "$BASH_VERSION" ]; then
+  (return 2>/dev/null) && sourced=1
+  THIS_SCRIPT="$BASH_SOURCE"
+else # All other shells: examine $0 for known shell binary filenames
+  # Detects `sh` and `dash`; add additional shell filenames as needed.
+  case ${0##*/} in sh|dash) sourced=1;; esac
+  THIS_SCRIPT="${0:-}"
+fi
+
+if [ $sourced -eq 0 ]; then
+    printf "${_RED}This script cannot be invoked directly.${_RESET}\n"
+    printf "${_RED}To function correctly, this script file must be sourced by calling \"source $0\".${_RESET}\n"
+    exit 1
+fi
+
+deactivate () {
+
+    # reset old environment variables
+    if [ ! -z "${_OLD_PATH:-}" ] ; then
+        export PATH="$_OLD_PATH"
+        unset _OLD_PATH
+    fi
+
+    if [ ! -z "${_OLD_PS1:-}" ] ; then
+        export PS1="$_OLD_PS1"
+        unset _OLD_PS1
+    fi
+
+    # This should detect bash and zsh, which have a hash command that must
+    # be called to get it to forget past commands.  Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    if [ -n "${BASH:-}" ] || [ -n "${ZSH_VERSION:-}" ] ; then
+        hash -r 2>/dev/null
+    fi
+
+    unset DOTNET_ROOT
+    unset DOTNET_MULTILEVEL_LOOKUP
+    if [ ! "${1:-}" = "init" ] ; then
+        # Remove the deactivate function
+        unset -f deactivate
+    fi
+}
+
+# Cleanup the environment
+deactivate init
+
+DIR="$( cd "$( dirname "$THIS_SCRIPT" )" && pwd )"
+_OLD_PATH="$PATH"
+# Tell dotnet where to find itself
+export DOTNET_ROOT="$DIR/.dotnet"
+# Tell dotnet not to look beyond the DOTNET_ROOT folder for more dotnet things
+export DOTNET_MULTILEVEL_LOOKUP=0
+# Put dotnet first on PATH
+export PATH="$DOTNET_ROOT:$PATH"
+
+# Set the shell prompt
+if [ -z "${DISABLE_CUSTOM_PROMPT:-}" ] ; then
+    _OLD_PS1="$PS1"
+    export PS1="(`basename \"$DIR\"`) $PS1"
+fi
+
+# This should detect bash and zsh, which have a hash command that must
+# be called to get it to forget past commands.  Without forgetting
+# past commands the $PATH changes we made may not be respected
+if [ -n "${BASH:-}" ] || [ -n "${ZSH_VERSION:-}" ] ; then
+    hash -r 2>/dev/null
+fi
+
+printf "${_MAGENTA}Enabled the .NET Core environment. Execute 'deactivate' to exit.${_RESET}\n"
+
+if [ ! -f "$DOTNET_ROOT/dotnet" ]; then
+    printf "${_YELLOW}.NET Core has not been installed yet. Run $DIR/restore.sh to install it.${_RESET}\n"
+else
+    printf "dotnet = $DOTNET_ROOT/dotnet\n"
+fi
--- a/build.cmd
+++ b/build.cmd
@ -1,2 +1,6 @@
@ECHO OFF
-PowerShell -NoProfile -NoLogo -ExecutionPolicy unrestricted -Command "[System.Threading.Thread]::CurrentThread.CurrentCulture = ''; [System.Threading.Thread]::CurrentThread.CurrentUICulture = '';& '%~dp0run.ps1' default-build %*; exit $LASTEXITCODE"
+SETLOCAL
+PowerShell -NoProfile -NoLogo -ExecutionPolicy Bypass -Command "[System.Threading.Thread]::CurrentThread.CurrentCulture = ''; [System.Threading.Thread]::CurrentThread.CurrentUICulture = ''; try { & '%~dp0build.ps1' %*; exit $LASTEXITCODE } catch { write-host $_; exit 1 }"
+SET exit_code=%ERRORLEVEL%
+ECHO build.cmd completed
+EXIT /b %exit_code%
--- a/build.ps1
+++ b/build.ps1
@ -0,0 +1,433 @@
+#requires -version 5
+
+<#
+.SYNOPSIS
+Builds this repository.
+
+.DESCRIPTION
+This build script installs required tools and runs an MSBuild command on this repository.
+This script can be used to invoke various targets, such as targets to produce packages,
+build projects, run tests, and generate code.
+
+.PARAMETER CI
+Sets up CI specific settings and variables.
+
+.PARAMETER Restore
+Run restore.
+
+.PARAMETER NoRestore
+Suppress running restore on projects.
+
+.PARAMETER NoBuild
+Suppress re-compile projects. (Implies -NoRestore)
+
+.PARAMETER NoBuildDeps
+Do not build project-to-project references and only build the specified project.
+
+.PARAMETER NoBuildRepoTasks
+Skip building eng/tools/RepoTasks/
+
+.PARAMETER Pack
+Produce packages.
+
+.PARAMETER Test
+Run tests.
+
+.PARAMETER Sign
+Run code signing.
+
+.PARAMETER Configuration
+Debug or Release
+
+.PARAMETER Architecture
+The CPU architecture to build for (x64, x86, arm). Default=x64
+
+.PARAMETER Projects
+A list of projects to build. Globbing patterns are supported, such as "$(pwd)/**/*.csproj"
+
+.PARAMETER All
+Build all project types.
+
+.PARAMETER BuildManaged
+Build managed projects (C#, F#, VB).
+You can also use -NoBuildManaged to suppress this project type.
+
+.PARAMETER BuildNative
+Build native projects (C++).
+You can also use -NoBuildNative to suppress this project type.
+
+.PARAMETER BuildNodeJS
+Build NodeJS projects (TypeScript, JS).
+You can also use -NoBuildNodeJS to suppress this project type.
+
+.PARAMETER BuildJava
+Build Java projects.
+You can also use -NoBuildJava to suppress this project type.
+
+.PARAMETER BuildInstallers
+Build Windows Installers. Required .NET 3.5 to be installed (WiX toolset requirement).
+You can also use -NoBuildInstallers to suppress this project type.
+
+.PARAMETER BinaryLog
+Enable the binary logger
+
+.PARAMETER Verbosity
+MSBuild verbosity: q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic]
+
+.PARAMETER MSBuildArguments
+Additional MSBuild arguments to be passed through.
+
+.PARAMETER DotNetRuntimeSourceFeed
+Additional feed that can be used when downloading .NET runtimes
+
+.PARAMETER DotNetRuntimeSourceFeedKey
+Key for feed that can be used when downloading .NET runtimes
+
+.EXAMPLE
+Building both native and managed projects.
+
+    build.ps1 -BuildManaged -BuildNative
+
+.EXAMPLE
+Building a subfolder of code.
+
+    build.ps1 -projects "$(pwd)/src/SomeFolder/**/*.csproj"
+
+.EXAMPLE
+Running tests.
+
+    build.ps1 -test
+
+.LINK
+Online version: https://github.com/aspnet/AspNetCore/blob/master/docs/BuildFromSource.md
+#>
+[CmdletBinding(PositionalBinding = $false, DefaultParameterSetName='Groups')]
+param(
+    [switch]$CI,
+
+    # Build lifecycle options
+    [switch]$Restore,
+    [switch]$NoRestore, # Suppress restore
+    [switch]$NoBuild, # Suppress compiling
+    [switch]$NoBuildDeps, # Suppress project to project dependencies
+    [switch]$Pack, # Produce packages
+    [switch]$Test, # Run tests
+    [switch]$Sign, # Code sign
+
+    [Alias('c')]
+    [ValidateSet('Debug', 'Release')]
+    $Configuration,
+
+    [ValidateSet('x64', 'x86', 'arm', 'arm64')]
+    $Architecture = 'x64',
+
+    # A list of projects which should be built.
+    [string]$Projects,
+
+    # Project selection
+    [switch]$All,  # Build everything
+
+    # Build a specified set of project groups
+    [switch]$BuildManaged,
+    [switch]$BuildNative,
+    [switch]$BuildNodeJS,
+    [switch]$BuildJava,
+    [switch]$BuildInstallers,
+
+    # Inverse of the previous switches because specifying '-switch:$false' is not intuitive for most command line users
+    [switch]$NoBuildManaged,
+    [switch]$NoBuildNative,
+    [switch]$NoBuildNodeJS,
+    [switch]$NoBuildJava,
+    [switch]$NoBuildInstallers,
+
+    [switch]$NoBuildRepoTasks,
+
+    # By default, Windows builds will use MSBuild.exe. Passing this will force the build to run on
+    # dotnet.exe instead, which may cause issues if you invoke build on a project unsupported by
+    # MSBuild for .NET Core
+    [switch]$ForceCoreMsbuild,
+
+    # Diagnostics
+    [Alias('bl')]
+    [switch]$BinaryLog,
+    [Alias('v')]
+    [string]$Verbosity = 'minimal',
+    [switch]$DumpProcesses, # Capture all running processes and dump them to a file.
+
+    # Other lifecycle targets
+    [switch]$Help, # Show help
+
+    # Optional arguments that enable downloading an internal
+    # runtime or runtime from a non-default location
+    [string]$DotNetRuntimeSourceFeed,
+    [string]$DotNetRuntimeSourceFeedKey,
+
+    # Capture the rest
+    [Parameter(ValueFromRemainingArguments = $true)]
+    [string[]]$MSBuildArguments
+)
+
+Set-StrictMode -Version 2
+$ErrorActionPreference = 'Stop'
+
+if ($Help) {
+    Get-Help $PSCommandPath
+    exit 1
+}
+
+if ($DumpProcesses -or $CI) {
+    # Dump running processes
+    Start-Job -Name DumpProcesses -FilePath $PSScriptRoot\eng\scripts\dump_process.ps1 -ArgumentList $PSScriptRoot
+}
+
+# Project selection
+if ($All) {
+    $MSBuildArguments += '/p:BuildAllProjects=true'
+}
+elseif ($Projects) {
+    if (![System.IO.Path]::IsPathRooted($Projects))
+    {
+        $Projects = Join-Path (Get-Location) $Projects
+    }
+    $MSBuildArguments += "/p:ProjectToBuild=$Projects"
+}
+# When adding new sub-group build flags, add them to this check.
+elseif((-not $BuildNative) -and (-not $BuildManaged) -and (-not $BuildNodeJS) -and (-not $BuildInstallers) -and (-not $BuildJava)) {
+    Write-Warning "No default group of projects was specified, so building the 'managed' and its dependent subsets of projects. Run ``build.cmd -help`` for more details."
+
+    # This goal of this is to pick a sensible default for `build.cmd` with zero arguments.
+    # Now that we support subfolder invokations of build.cmd, we will be pushing to have build.cmd build everything (-all) by default
+
+    $BuildManaged = $true
+}
+
+if ($BuildManaged -or ($All -and (-not $NoBuildManaged))) {
+    if ((-not $BuildNodeJS) -and (-not $NoBuildNodeJS)) {
+        $node = Get-Command node -ErrorAction Ignore -CommandType Application
+
+        if ($node) {
+            $nodeHome = Split-Path -Parent (Split-Path -Parent $node.Path)
+            Write-Host -f Magenta "Building of C# project is enabled and has dependencies on NodeJS projects. Building of NodeJS projects is enabled since node is detected in $nodeHome."
+        }
+        else {
+            Write-Host -f Magenta "Building of NodeJS projects is disabled since node is not detected on Path and no BuildNodeJs or NoBuildNodeJs setting is set explicitly."
+            $NoBuildNodeJS = $true
+        }
+    }
+
+    if ($NoBuildNodeJS){
+        Write-Warning "Some managed projects depend on NodeJS projects. Building NodeJS is disabled so the managed projects will fallback to using the output from previous builds. The output may not be correct or up to date."
+    }
+}
+
+if ($BuildInstallers) { $MSBuildArguments += "/p:BuildInstallers=true" }
+if ($BuildManaged) { $MSBuildArguments += "/p:BuildManaged=true" }
+if ($BuildNative) { $MSBuildArguments += "/p:BuildNative=true" }
+if ($BuildNodeJS) { $MSBuildArguments += "/p:BuildNodeJS=true" }
+if ($BuildJava) { $MSBuildArguments += "/p:BuildJava=true" }
+
+if ($NoBuildDeps) { $MSBuildArguments += "/p:BuildProjectReferences=false" }
+
+if ($NoBuildInstallers) { $MSBuildArguments += "/p:BuildInstallers=false" }
+if ($NoBuildManaged) { $MSBuildArguments += "/p:BuildManaged=false" }
+if ($NoBuildNative) { $MSBuildArguments += "/p:BuildNative=false" }
+if ($NoBuildNodeJS) { $MSBuildArguments += "/p:BuildNodeJS=false" }
+if ($NoBuildJava) { $MSBuildArguments += "/p:BuildJava=false" }
+
+$RunBuild = if ($NoBuild) { $false } else { $true }
+
+# Run restore by default unless -NoRestore is set.
+# -NoBuild implies -NoRestore, unless -Restore is explicitly set (as in restore.cmd)
+$RunRestore = if ($NoRestore) { $false }
+    elseif ($Restore) { $true }
+    elseif ($NoBuild) { $false }
+    else { $true }
+
+# Target selection
+$MSBuildArguments += "/p:Restore=$RunRestore"
+$MSBuildArguments += "/p:Build=$RunBuild"
+if (-not $RunBuild) {
+    $MSBuildArguments += "/p:NoBuild=true"
+}
+$MSBuildArguments += "/p:Pack=$Pack"
+$MSBuildArguments += "/p:Test=$Test"
+$MSBuildArguments += "/p:Sign=$Sign"
+
+$MSBuildArguments += "/p:TargetArchitecture=$Architecture"
+$MSBuildArguments += "/p:TargetOsName=win"
+
+if (-not $Configuration) {
+    $Configuration = if ($CI) { 'Release' } else { 'Debug' }
+}
+$MSBuildArguments += "/p:Configuration=$Configuration"
+
+[string[]]$ToolsetBuildArguments = @()
+if ($DotNetRuntimeSourceFeed -or $DotNetRuntimeSourceFeedKey) {
+    $runtimeFeedArg = "/p:DotNetRuntimeSourceFeed=$DotNetRuntimeSourceFeed"
+    $runtimeFeedKeyArg = "/p:DotNetRuntimeSourceFeedKey=$DotNetRuntimeSourceFeedKey"
+    $MSBuildArguments += $runtimeFeedArg
+    $MSBuildArguments += $runtimeFeedKeyArg
+    $ToolsetBuildArguments += $runtimeFeedArg
+    $ToolsetBuildArguments += $runtimeFeedKeyArg
+}
+
+$foundJdk = $false
+$javac = Get-Command javac -ErrorAction Ignore -CommandType Application
+$localJdkPath = "$PSScriptRoot\.tools\jdk\win-x64\"
+if (Test-Path "$localJdkPath\bin\javac.exe") {
+    $foundJdk = $true
+    Write-Host -f Magenta "Detected JDK in $localJdkPath (via local repo convention)"
+    $env:JAVA_HOME = $localJdkPath
+}
+elseif ($env:JAVA_HOME) {
+    if (-not (Test-Path "${env:JAVA_HOME}\bin\javac.exe")) {
+        Write-Error "The environment variable JAVA_HOME was set, but ${env:JAVA_HOME}\bin\javac.exe does not exist. Remove JAVA_HOME or update it to the correct location for the JDK. See https://www.bing.com/search?q=java_home for details."
+    }
+    else {
+        Write-Host -f Magenta "Detected JDK in ${env:JAVA_HOME} (via JAVA_HOME)"
+        $foundJdk = $true
+    }
+}
+elseif ($javac) {
+    $foundJdk = $true
+    $javaHome = Split-Path -Parent (Split-Path -Parent $javac.Path)
+    $env:JAVA_HOME = $javaHome
+    Write-Host -f Magenta "Detected JDK in $javaHome (via PATH)"
+}
+else {
+    try {
+        $jdkRegistryKeys = @(
+            "HKLM:\SOFTWARE\JavaSoft\JDK",  # for JDK 10+
+            "HKLM:\SOFTWARE\JavaSoft\Java Development Kit"  # fallback for JDK 8
+        )
+        $jdkRegistryKey = $jdkRegistryKeys | Where-Object { Test-Path $_ } | Select-Object -First 1
+        if ($jdkRegistryKey) {
+            $jdkVersion = (Get-Item $jdkRegistryKey | Get-ItemProperty -name CurrentVersion).CurrentVersion
+            $javaHome = (Get-Item $jdkRegistryKey\$jdkVersion | Get-ItemProperty -Name JavaHome).JavaHome
+            if (Test-Path "${javaHome}\bin\javac.exe") {
+                $env:JAVA_HOME = $javaHome
+                Write-Host -f Magenta "Detected JDK $jdkVersion in $env:JAVA_HOME (via registry)"
+                $foundJdk = $true
+            }
+        }
+    }
+    catch {
+        Write-Verbose "Failed to detect Java: $_"
+    }
+}
+
+if ($env:PATH -notlike "*${env:JAVA_HOME}*") {
+    $env:PATH = "$(Join-Path $env:JAVA_HOME bin);${env:PATH}"
+}
+
+if (-not $foundJdk -and $RunBuild -and ($All -or $BuildJava) -and -not $NoBuildJava) {
+    Write-Error "Could not find the JDK. Either run $PSScriptRoot\eng\scripts\InstallJdk.ps1 to install for this repo, or install the JDK globally on your machine (see $PSScriptRoot\docs\BuildFromSource.md for details)."
+}
+
+# Initialize global variables need to be set before the import of Arcade is imported
+$restore = $RunRestore
+
+# Though VS Code may indicate $nodeReuse, $warnAsError and $msbuildEngine are unused, tools.ps1 uses them.
+
+# Disable node reuse - Workaround perpetual issues in node reuse and custom task assemblies
+$nodeReuse = $false
+$env:MSBUILDDISABLENODEREUSE=1
+
+# Our build often has warnings that we can't fix, like "MSB3026: Could not copy" due to race
+# conditions in building C++
+# Fixing this is tracked by https://github.com/aspnet/AspNetCore-Internal/issues/601
+$warnAsError = $false
+
+if ($ForceCoreMsbuild) {
+    $msbuildEngine = 'dotnet'
+}
+
+# Workaround Arcade check which asserts BinaryLog is true on CI.
+# We always use binlogs on CI, but we customize the name of the log file
+$tmpBinaryLog = $BinaryLog
+if ($CI) {
+    $BinaryLog = $true
+}
+
+# tools.ps1 corrupts global state, so reset these values in case they carried over from a previous build
+Remove-Item variable:global:_BuildTool -ea Ignore
+Remove-Item variable:global:_DotNetInstallDir -ea Ignore
+Remove-Item variable:global:_ToolsetBuildProj -ea Ignore
+Remove-Item variable:global:_MSBuildExe -ea Ignore
+
+# Import Arcade
+. "$PSScriptRoot/eng/common/tools.ps1"
+
+if ($tmpBinaryLog) {
+    $MSBuildArguments += "/bl:$LogDir/Build.binlog"
+}
+
+# Capture MSBuild crash logs
+$env:MSBUILDDEBUGPATH = $LogDir
+
+$local:exit_code = $null
+try {
+    # Import custom tools configuration, if present in the repo.
+    # Note: Import in global scope so that the script set top-level variables without qualification.
+    $configureToolsetScript = Join-Path $EngRoot "configure-toolset.ps1"
+    if (Test-Path $configureToolsetScript) {
+      . $configureToolsetScript
+    }
+
+    # Set this global property so Arcade will always initialize the toolset. The error message you get when you build on a clean machine
+    # with -norestore is not obvious about what to do to fix it. As initialization takes very little time, we think always initializing
+    # the toolset is a better default behavior.
+    $tmpRestore = $restore
+    $restore = $true
+
+    $toolsetBuildProj = InitializeToolset
+
+    $restore = $tmpRestore
+
+    if ($ci) {
+        $global:VerbosePreference = 'Continue'
+    }
+
+    if (-not $NoBuildRepoTasks) {
+        MSBuild $toolsetBuildProj `
+            /p:RepoRoot=$RepoRoot `
+            /p:Projects=$EngRoot\tools\RepoTasks\RepoTasks.csproj `
+            /p:Configuration=Release `
+            /p:Restore=$RunRestore `
+            /p:Build=true `
+            /clp:NoSummary `
+            @ToolsetBuildArguments
+    }
+
+    MSBuild $toolsetBuildProj `
+        /p:RepoRoot=$RepoRoot `
+        @MSBuildArguments
+}
+catch {
+    Write-Host $_.ScriptStackTrace
+    Write-PipelineTaskError -Message $_
+    $exit_code = 1
+}
+finally {
+    if (! $exit_code) {
+        $exit_code = $LASTEXITCODE
+    }
+
+    # tools.ps1 corrupts global state, so reset these values so they don't carry between invocations of build.ps1
+    Remove-Item variable:global:_BuildTool -ea Ignore
+    Remove-Item variable:global:_DotNetInstallDir -ea Ignore
+    Remove-Item variable:global:_ToolsetBuildProj -ea Ignore
+    Remove-Item variable:global:_MSBuildExe -ea Ignore
+
+    if ($DumpProcesses -or $ci) {
+        Stop-Job -Name DumpProcesses
+        Remove-Job -Name DumpProcesses
+    }
+
+    if ($ci) {
+        & "$PSScriptRoot/eng/scripts/KillProcesses.ps1"
+    }
+}
+
+ExitWithExitCode $exit_code
--- a/build.sh
+++ b/build.sh
@ -1,8 +1,362 @@
 #!/usr/bin/env bash

 set -euo pipefail
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"

-# Call "sync" between "chmod" and execution to prevent "text file busy" error in Docker (aufs)
-chmod +x "$DIR/run.sh"; sync
-"$DIR/run.sh" default-build "$@"
+#
+# variables
+#
+
+RESET="\033[0m"
+RED="\033[0;31m"
+YELLOW="\033[0;33m"
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+target_os_name=''
+ci=false
+use_default_binary_log=false
+verbosity='minimal'
+run_restore=''
+run_build=true
+run_pack=false
+run_tests=false
+build_all=false
+build_deps=true
+build_repo_tasks=true
+build_managed=''
+build_native=''
+build_nodejs=''
+build_java=''
+build_installers=''
+build_projects=''
+target_arch='x64'
+configuration=''
+dotnet_runtime_source_feed=''
+dotnet_runtime_source_feed_key=''
+
+if [ "$(uname)" = "Darwin" ]; then
+    target_os_name='osx'
+else
+    target_os_name='linux'
+fi
+
+msbuild_args=()
+
+#
+# Functions
+#
+__usage() {
+    echo "Usage: $(basename "${BASH_SOURCE[0]}") [options] [[--] <Arguments>...]
+
+Arguments:
+    <Arguments>...                    Arguments passed to the command. Variable number of arguments allowed.
+
+Options:
+    --configuration|-c                The build configuration (Debug, Release). Default=Debug
+    --arch                            The CPU architecture to build for (x64, arm, arm64). Default=$target_arch
+    --os-name                         The base runtime identifier to build for (linux, osx, linux-musl). Default=$target_os_name
+
+    --[no-]restore                    Run restore.
+    --[no-]build                      Compile projects. (Implies --no-restore)
+    --[no-]pack                       Produce packages.
+    --[no-]test                       Run tests.
+
+    --projects                        A list of projects to build. (Must be an absolute path.)
+                                      Globbing patterns are supported, such as \"$(pwd)/**/*.csproj\".
+    --no-build-deps                   Do not build project-to-project references and only build the specified project.
+    --no-build-repo-tasks             Suppress building RepoTasks.
+
+    --all                             Build all project types.
+    --[no-]build-native               Build native projects (C, C++).
+    --[no-]build-managed              Build managed projects (C#, F#, VB).
+    --[no-]build-nodejs               Build NodeJS projects (TypeScript, JS).
+    --[no-]build-java                 Build Java projects.
+    --[no-]build-installers           Build Java projects.
+
+    --ci                              Apply CI specific settings and environment variables.
+    --binarylog|-bl                   Use a binary logger
+    --verbosity|-v                    MSBuild verbosity: q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic]
+    
+    --dotnet-runtime-source-feed      Additional feed that can be used when downloading .NET runtimes
+    --dotnet-runtime-source-feed-key  Key for feed that can be used when downloading .NET runtimes
+
+Description:
+    This build script installs required tools and runs an MSBuild command on this repository
+    This script can be used to invoke various targets, such as targets to produce packages
+    build projects, run tests, and generate code.
+"
+
+    if [[ "${1:-}" != '--no-exit' ]]; then
+        exit 2
+    fi
+}
+
+__error() {
+    echo -e "${RED}error: $*${RESET}" 1>&2
+}
+
+__warn() {
+    echo -e "${YELLOW}warning: $*${RESET}"
+}
+
+#
+# main
+#
+
+while [[ $# -gt 0 ]]; do
+    opt="$(echo "${1/#--/-}" | awk '{print tolower($0)}')"
+    case "$opt" in
+        -\?|-h|-help)
+            __usage --no-exit
+            exit 0
+            ;;
+        -configuration|-c)
+            shift
+            configuration="${1:-}"
+            [ -z "$configuration" ] && __error "Missing value for parameter --configuration" && __usage
+            ;;
+        -arch)
+            shift
+            target_arch="${1:-}"
+            [ -z "$target_arch" ] && __error "Missing value for parameter --arch" && __usage
+            ;;
+        -os-name|-osname)
+            shift
+            target_os_name="${1:-}"
+            [ -z "$target_os_name" ] && __error "Missing value for parameter --os-name" && __usage
+            ;;
+        -restore|-r)
+            run_restore=true
+            ;;
+        -no-restore|-norestore)
+            run_restore=false
+            ;;
+        -build|-b)
+            run_build=true
+            ;;
+        -no-build|-nobuild)
+            run_build=false
+            # --no-build implies --no-restore
+            [ -z "$run_restore" ] && run_restore=false
+            ;;
+        -no-build-deps|-nobuilddeps)
+            build_deps=false
+            ;;
+        -pack)
+            run_pack=true
+            ;;
+        -no-pack|-nopack)
+            run_pack=false
+            ;;
+        -test|-t)
+            run_tests=true
+            ;;
+        -no-test|-notest)
+            run_tests=false
+            ;;
+        -projects)
+            shift
+            build_projects="${1:-}"
+            [ -z "$build_projects" ] && __error "Missing value for parameter --projects" && __usage
+            ;;
+        -all)
+            build_all=true
+            ;;
+        -build-managed|-buildmanaged)
+            build_managed=true
+            ;;
+        -no-build-managed|-nobuildmanaged)
+            build_managed=false
+            ;;
+        -build-nodejs|-buildnodejs)
+            build_nodejs=true
+            ;;
+        -no-build-nodejs|-nobuildnodejs)
+            build_nodejs=false
+            ;;
+        -build-java|-buildjava)
+            build_java=true
+            ;;
+        -no-build-java|-nobuildjava)
+            build_java=false
+            ;;
+        -build-native|-buildnative)
+            build_native=true
+            ;;
+        -no-build-native|-nobuildnative)
+            build_native=false
+            ;;
+        -build-installers|-buildinstallers)
+            build_installers=true
+            ;;
+        -no-build-installers|-nobuildinstallers)
+            build_installers=false
+            ;;
+        -no-build-repo-tasks|-nobuildrepotasks)
+            build_repo_tasks=false
+            ;;
+        -arch)
+            shift
+            target_arch="${1:-}"
+            [ -z "$target_arch" ] && __error "Missing value for parameter --arch" && __usage
+            ;;
+        -ci)
+            ci=true
+            ;;
+        -binarylog|-bl)
+            use_default_binary_log=true
+            ;;
+        -dotnet-runtime-source-feed|-dotnetruntimesourcefeed)
+            shift
+            [ -z "${1:-}" ] && __error "Missing value for parameter --dotnet-runtime-source-feed" && __usage
+            dotnet_runtime_source_feed="${1:-}"
+            ;;
+        -dotnet-runtime-source-feed-key|-dotnetruntimesourcefeedkey)
+            shift
+            [ -z "${1:-}" ] && __error "Missing value for parameter --dotnet-runtime-source-feed-key" && __usage
+            dotnet_runtime_source_feed_key="${1:-}"
+            ;;
+        *)
+            msbuild_args[${#msbuild_args[*]}]="$1"
+            ;;
+    esac
+    shift
+done
+
+if [ "$build_all" = true ]; then
+    msbuild_args[${#msbuild_args[*]}]="-p:BuildAllProjects=true"
+elif [ ! -z "$build_projects" ]; then
+    msbuild_args[${#msbuild_args[*]}]="-p:ProjectToBuild=$build_projects"
+elif [ -z "$build_managed" ] && [ -z "$build_nodejs" ] && [ -z "$build_java" ] && [ -z "$build_native" ] && [ -z "$build_installers" ]; then
+    # This goal of this is to pick a sensible default for `build.sh` with zero arguments.
+    # We believe the most common thing our contributors will work on is C#, so if no other build group was picked, build the C# projects.
+    __warn "No default group of projects was specified, so building the 'managed' and its dependent subset of projects. Run ``build.sh --help`` for more details."
+    build_managed=true
+fi
+
+if [ "$build_deps" = false ]; then
+    msbuild_args[${#msbuild_args[*]}]="-p:BuildProjectReferences=false"
+fi
+
+if [ "$build_managed" = true ] || ([ "$build_all" = true ] && [ "$build_managed" != false ]); then
+    if [ -z "$build_nodejs" ]; then
+        if [ -x "$(command -v node)" ]; then
+            __warn "Building of C# project is enabled and has dependencies on NodeJS projects. Building of NodeJS projects is enabled since node is detected on PATH."
+        else
+            __warn "Building of NodeJS projects is disabled since node is not detected on Path and no BuildNodeJs or NoBuildNodeJs setting is set explicitly."
+            build_nodejs=false
+        fi
+    fi
+
+    if [ "$build_nodejs" = false ]; then
+        __warn "Some managed projects depend on NodeJS projects. Building NodeJS is disabled so the managed projects will fallback to using the output from previous builds. The output may not be correct or up to date."
+    fi
+fi
+
+# Only set these MSBuild properties if they were explicitly set by build parameters.
+[ ! -z "$build_java" ] && msbuild_args[${#msbuild_args[*]}]="-p:BuildJava=$build_java"
+[ ! -z "$build_native" ] && msbuild_args[${#msbuild_args[*]}]="-p:BuildNative=$build_native"
+[ ! -z "$build_nodejs" ] && msbuild_args[${#msbuild_args[*]}]="-p:BuildNodeJS=$build_nodejs"
+[ ! -z "$build_managed" ] && msbuild_args[${#msbuild_args[*]}]="-p:BuildManaged=$build_managed"
+[ ! -z "$build_installers" ] && msbuild_args[${#msbuild_args[*]}]="-p:BuildInstallers=$build_installers"
+
+# Run restore by default unless --no-restore or --no-build was specified.
+[ -z "$run_restore" ] && run_restore=true
+
+msbuild_args[${#msbuild_args[*]}]="-p:Restore=$run_restore"
+msbuild_args[${#msbuild_args[*]}]="-p:Build=$run_build"
+if [ "$run_build" = false ]; then
+    msbuild_args[${#msbuild_args[*]}]="-p:NoBuild=true"
+fi
+msbuild_args[${#msbuild_args[*]}]="-p:Pack=$run_pack"
+msbuild_args[${#msbuild_args[*]}]="-p:Test=$run_tests"
+
+msbuild_args[${#msbuild_args[*]}]="-p:TargetArchitecture=$target_arch"
+msbuild_args[${#msbuild_args[*]}]="-p:TargetOsName=$target_os_name"
+
+if [ -z "$configuration" ]; then
+    if [ "$ci" = true ]; then
+        configuration='Release'
+    else
+        configuration='Debug'
+    fi
+fi
+msbuild_args[${#msbuild_args[*]}]="-p:Configuration=$configuration"
+
+# Set verbosity
+echo "Setting msbuild verbosity to $verbosity"
+msbuild_args[${#msbuild_args[*]}]="-verbosity:$verbosity"
+
+# Set up additional runtime args
+toolset_build_args=()
+if [ ! -z "$dotnet_runtime_source_feed" ] || [ ! -z "$dotnet_runtime_source_feed_key" ]; then
+    runtimeFeedArg="/p:DotNetRuntimeSourceFeed=$dotnet_runtime_source_feed"
+    runtimeFeedKeyArg="/p:DotNetRuntimeSourceFeedKey=$dotnet_runtime_source_feed_key"
+    msbuild_args[${#msbuild_args[*]}]=$runtimeFeedArg
+    msbuild_args[${#msbuild_args[*]}]=$runtimeFeedKeyArg
+    toolset_build_args[${#toolset_build_args[*]}]=$runtimeFeedArg
+    toolset_build_args[${#toolset_build_args[*]}]=$runtimeFeedKeyArg
+fi
+
+# Initialize global variables need to be set before the import of Arcade is imported
+restore=$run_restore
+
+# Disable node reuse - Workaround perpetual issues in node reuse and custom task assemblies
+nodeReuse=false
+export MSBUILDDISABLENODEREUSE=1
+
+# Our build often has warnings that we can't fix
+# Fixing this is tracked by https://github.com/aspnet/AspNetCore-Internal/issues/601
+warn_as_error=false
+
+# Workaround Arcade check which asserts BinaryLog is true on CI.
+# We always use binlogs on CI, but we customize the name of the log file
+if [ "$ci" = true ]; then
+  binary_log=true
+fi
+
+# increase file descriptor limit on macOS
+if [ "$(uname)" = "Darwin" ]; then
+    ulimit -n 10000
+fi
+
+# Import Arcade
+. "$DIR/eng/common/tools.sh"
+
+if [ "$use_default_binary_log" = true ]; then
+    msbuild_args[${#msbuild_args[*]}]="-bl:\"$log_dir/Build.binlog\""
+fi
+
+# Capture MSBuild crash logs
+export MSBUILDDEBUGPATH="$log_dir"
+
+# Import custom tools configuration, if present in the repo.
+configure_toolset_script="$eng_root/configure-toolset.sh"
+if [[ -a "$configure_toolset_script" ]]; then
+  . "$configure_toolset_script"
+fi
+
+# Set this global property so Arcade will always initialize the toolset. The error message you get when you build on a clean machine
+# with -norestore is not obvious about what to do to fix it. As initialization takes very little time, we think always initializing
+# the toolset is a better default behavior.
+_tmp_restore=$restore
+restore=true
+
+InitializeToolset
+
+restore=$_tmp_restore=
+
+if [ "$build_repo_tasks" = true ]; then
+    MSBuild $_InitializeToolset \
+        -p:RepoRoot="$repo_root" \
+        -p:Projects="$DIR/eng/tools/RepoTasks/RepoTasks.csproj" \
+        -p:Configuration=Release \
+        -p:Restore=$run_restore \
+        -p:Build=true \
+        -clp:NoSummary \
+        ${toolset_build_args[@]+"${toolset_build_args[@]}"}
+fi
+
+# This incantation avoids unbound variable issues if msbuild_args is empty
+# https://stackoverflow.com/questions/7577052/bash-empty-array-expansion-with-set-u
+MSBuild $_InitializeToolset -p:RepoRoot="$repo_root" ${msbuild_args[@]+"${msbuild_args[@]}"}
+
+ExitWithExitCode 0
--- a/build/PackageArchive.targets
+++ b/build/PackageArchive.targets
@ -1,36 +0,0 @@
-<Project>
-  <Target Name="CheckForPreviousReleaseArchiveBaseline" BeforeTargets="FastCheck">
-    <MSBuild Projects="@(ArchiveProjects)"
-             Targets="CheckForPreviousReleaseArchiveBaseline" />
-  </Target>
-
-  <ItemGroup>
-    <ArchiveProjects Include="$(RepositoryRoot)src\PackageArchive\Archive.*\*.*proj" />
-  </ItemGroup>
-
-  <Target Name="BuildFallbackArchive" DependsOnTargets="ResolveSharedSourcesPackageInfo;GetProjectArtifactInfo;ResolveRepoInfo;GeneratePropsFiles">
-    <PropertyGroup>
-      <ArchiveBuildProps>
-        DotNetRestoreSourcePropsPath=$(GeneratedRestoreSourcesPropsPath);
-        DotNetPackageVersionPropsPath=$(GeneratedPackageVersionPropsPath);
-        OutputPath=$(ArtifactsDir)lzma\;
-        _BuildToolsAssembly=$(_BuildToolsAssembly)
-      </ArchiveBuildProps>
-    </PropertyGroup>
-
-    <Error Text="Could not find any package archive projects to build"
-      Condition=" @(ArchiveProjects->Count()) == 0 " />
-
-    <MSBuild Projects="@(ArchiveProjects)"
-      Targets="Restore"
-      BuildInParallel="false"
-      StopOnFirstFailure="true"
-      Properties="$(ArchiveBuildProps);_Dummy=restore" />
-
-    <MSBuild Projects="@(ArchiveProjects)"
-      Targets="Build"
-      BuildInParallel="false"
-      StopOnFirstFailure="true"
-      Properties="$(ArchiveBuildProps)" />
-  </Target>
-</Project>
--- a/build/Publish.targets
+++ b/build/Publish.targets
@ -1,327 +0,0 @@
-<Project>
-
-  <PropertyGroup>
-    <DependencyAssetsDir>$(RepositoryRoot).deps\assets\</DependencyAssetsDir>
-    <DependencyPackagesDir>$(RepositoryRoot).deps\packages\</DependencyPackagesDir>
-    <!-- This file is used by the dotnet/cli to determine if our shared framework aligns with the version they pull. -->
-    <BaseRuntimeVersionFileName>aspnetcore_base_runtime.version</BaseRuntimeVersionFileName>
-    <BaseRuntimeVersionFile>$(IntermediateDir)$(BaseRuntimeVersionFileName)</BaseRuntimeVersionFile>
-    <LatestRuntimeVersionFileName>latest.version</LatestRuntimeVersionFileName>
-    <LatestRuntimeVersionFile>$(IntermediateDir)$(LatestRuntimeVersionFileName)</LatestRuntimeVersionFile>
-
-    <PublishDependsOn>
-      ResolveCommitHash;
-      PrepareOutputPaths;
-      GetFilesToPublish;
-      PublishToLocalFolder;
-      PublishToAzureFeed;
-      PublishToTransportFeed;
-      PublishToMyGet;
-    </PublishDependsOn>
-
-    <!-- Settings for pushing to the transport feed -->
-    <PushToBlobFeed_UploadTimeoutMinutes>10</PushToBlobFeed_UploadTimeoutMinutes>
-    <PushToBlobFeed_Overwrite Condition="'$(PushToBlobFeed_Overwrite)' == ''">false</PushToBlobFeed_Overwrite>
-    <PushToBlobFeed_MaxClients Condition="'$(PushToBlobFeed_MaxClients)' == ''">8</PushToBlobFeed_MaxClients>
-    <BlobFileRelativePathBase Condition="'$(BlobFileRelativePathBase)' == ''">assets</BlobFileRelativePathBase>
-    <BlobFileRelativePathBase Condition="!HasTrailingSlash('$(BlobFileRelativePathBase)')">$(BlobFileRelativePathBase)/</BlobFileRelativePathBase>
-  </PropertyGroup>
-
-  <Target Name="Publish" DependsOnTargets="$(PublishDependsOn)" />
-
-  <Target Name="GeneratePublishFiles" DependsOnTargets="ResolveCommitHash">
-    <MakeDir Directories="$(IntermediateDir)" />
-
-    <!--
-      Used by the dotnet/cli build to determine which version of Microsoft.NETCore.App is used.
-    -->
-    <WriteLinesToFile File="$(BaseRuntimeVersionFile)" Lines="$(MicrosoftNETCoreApp21PackageVersion)" Overwrite="true" />
-
-    <!--
-      Used by the downloader scripts when pulling from a 'channel' instead of a specific version.
-      The second line must be the package version.
-      See dotnet-install.ps1/sh.
-    -->
-    <WriteLinesToFile
-      File="$(LatestRuntimeVersionFile)"
-      Lines="$(CommitHash);$(PackageVersion)"
-      Overwrite="true" />
-
-    <ItemGroup>
-      <SharedFxVersionBadge Include="$(IntermediateDir)$(SharedFxInstallerName)-%(AllSharedFxRIDs.Identity)-version-badge.svg" />
-    </ItemGroup>
-
-    <GenerateSvgBadge
-      OutputPath="%(SharedFxVersionBadge.Identity)"
-      Label="version"
-      Value="$(PackageVersion)" />
-  </Target>
-
-  <Target Name="GetFilesToPublish" DependsOnTargets="GetArtifactInfo;GeneratePublishFiles">
-    <PropertyGroup>
-      <BlobBasePath>aspnetcore/Runtime/$(PackageVersion)/</BlobBasePath>
-      <NpmBlobBasePath>aspnetcore/npm/</NpmBlobBasePath>
-      <AliasBlobBasePath>aspnetcore/Runtime/$(SharedFxCliBlobChannel)/</AliasBlobBasePath>
-      <InstallerBaseFileName>aspnetcore-runtime-$(PackageVersion)</InstallerBaseFileName>
-      <InstallerAliasBaseFileName>aspnetcore-runtime-latest</InstallerAliasBaseFileName>
-      <IntermediateInstallerBaseFileName>aspnetcore-runtime-internal-$(PackageVersion)</IntermediateInstallerBaseFileName>
-      <WindowsHostingBundleInstallerFileName>dotnet-hosting-$(PackageVersion)-win.exe</WindowsHostingBundleInstallerFileName>
-      <!-- This matches the property set in SharedFramework.wixproj -->
-      <SharedFrameworkRedistPackageId>VS.Redist.Common.AspNetCore.SharedFramework</SharedFrameworkRedistPackageId>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <!-- Windows Server hosting bundle -->
-      <FilesToPublish Include="$(DependencyAssetsDir)$(WindowsHostingBundleInstallerFileName)">
-        <RelativeBlobPath>$(BlobBasePath)$(WindowsHostingBundleInstallerFileName)</RelativeBlobPath>
-        <ManifestArtifactData>ShipInstaller=dotnetcli</ManifestArtifactData>
-      </FilesToPublish>
-
-      <!-- Package archives -->
-      <FilesToPublish Include="$(DependencyAssetsDir)nuGetPackagesArchive-ci-server-$(PackageVersion).zip" >
-        <RelativeBlobPath>$(BlobBasePath)nuGetPackagesArchive-ci-server-$(PackageVersion).zip</RelativeBlobPath>
-        <ManifestArtifactData>ShipInstaller=dotnetcli</ManifestArtifactData>
-      </FilesToPublish>
-
-      <!-- This file is conditionally included because it may not exist in servicing builds -->
-      <FilesToPublish Include="$(DependencyAssetsDir)nuGetPackagesArchive-ci-server-$(PackageVersion).patch.zip"
-                      Condition="Exists('$(DependencyAssetsDir)nuGetPackagesArchive-ci-server-$(PackageVersion).patch.zip')" >
-        <RelativeBlobPath>$(BlobBasePath)nuGetPackagesArchive-ci-server-$(PackageVersion).patch.zip</RelativeBlobPath>
-        <ManifestArtifactData>ShipInstaller=dotnetcli</ManifestArtifactData>
-      </FilesToPublish>
-
-      <!-- This file is conditionally included because it may not exist in servicing builds -->
-      <FilesToPublish Include="$(DependencyAssetsDir)nuGetPackagesArchive-ci-server-compat-$(PackageVersion).patch.zip"
-                      Condition="Exists('$(DependencyAssetsDir)nuGetPackagesArchive-ci-server-compat-$(PackageVersion).patch.zip')">
-        <RelativeBlobPath>$(BlobBasePath)nuGetPackagesArchive-ci-server-compat-$(PackageVersion).patch.zip</RelativeBlobPath>
-        <ManifestArtifactData>ShipInstaller=dotnetcli</ManifestArtifactData>
-      </FilesToPublish>
-
-      <!-- Intermediate files passed on to the dotnet-CLI. -->
-      <FilesToPublish Include="$(DependencyAssetsDir)nuGetPackagesArchive-$(PackageVersion).lzma" >
-        <RelativeBlobPath>$(BlobBasePath)nuGetPackagesArchive-$(PackageVersion).lzma</RelativeBlobPath>
-        <ManifestArtifactData>ShipInstaller=dotnetcli</ManifestArtifactData>
-      </FilesToPublish>
-
-      <FilesToPublish Include="$(DependencyAssetsDir)$(IntermediateInstallerBaseFileName)-%(IntermediateInstaller.Identity)%(IntermediateInstaller.FileExt)" Condition=" '%(IntermediateInstaller.Identity)' != '' ">
-        <RelativeBlobPath>$(BlobBasePath)$(IntermediateInstallerBaseFileName)-%(IntermediateInstaller.Identity)%(IntermediateInstaller.FileExt)</RelativeBlobPath>
-        <ManifestArtifactData>ShipInstaller=dotnetcli</ManifestArtifactData>
-      </FilesToPublish>
-
-      <FilesToPublish Include="$(BaseRuntimeVersionFile)">
-        <RelativeBlobPath>$(BlobBasePath)$(BaseRuntimeVersionFileName)</RelativeBlobPath>
-        <ManifestArtifactData>ShipInstaller=dotnetcli</ManifestArtifactData>
-        <ContentType>text/plain</ContentType>
-      </FilesToPublish>
-
-      <!-- Archive installers -->
-      <FilesToPublish Include="$(DependencyAssetsDir)$(InstallerBaseFileName)-%(NativeInstaller.Identity)%(NativeInstaller.FileExt)" Condition=" '%(NativeInstaller.FileExt)' != '' ">
-        <RelativeBlobPath>$(BlobBasePath)$(InstallerBaseFileName)-%(NativeInstaller.Identity)%(NativeInstaller.FileExt)</RelativeBlobPath>
-        <ManifestArtifactData>ShipInstaller=dotnetcli</ManifestArtifactData>
-      </FilesToPublish>
-
-      <!-- Support for README badges and dotnet-install.ps1/sh -->
-      <FilesToPublish Include="$(DependencyAssetsDir)$(InstallerBaseFileName)-%(NativeInstaller.Identity)%(NativeInstaller.FileExt)" Condition=" '%(NativeInstaller.FileExt)' != '' ">
-        <RelativeBlobPath>$(AliasBlobBasePath)$(InstallerAliasBaseFileName)-%(NativeInstaller.Identity)%(NativeInstaller.FileExt)</RelativeBlobPath>
-        <ManifestArtifactData>ShipInstaller=dotnetcli</ManifestArtifactData>
-        <Overwrite>true</Overwrite>
-        <!-- These uploads duplicate the same blob in a separate location for README download links and to make dotnet-install.ps1/sh work when specifying -Channel. -->
-        <IsDuplicateUpload>true</IsDuplicateUpload>
-      </FilesToPublish>
-
-      <FilesToPublish Include="@(SharedFxVersionBadge)">
-        <RelativeBlobPath>$(AliasBlobBasePath)%(SharedFxVersionBadge.FileName)%(SharedFxVersionBadge.Extension)</RelativeBlobPath>
-        <ManifestArtifactData>ShipInstaller=dotnetcli</ManifestArtifactData>
-        <CacheControl>no-cache, no-store, must-revalidate</CacheControl>
-        <ContentType>image/svg+xml</ContentType>
-        <Overwrite>true</Overwrite>
-      </FilesToPublish>
-
-      <FilesToPublish Include="$(LatestRuntimeVersionFile)">
-        <RelativeBlobPath>$(AliasBlobBasePath)$(LatestRuntimeVersionFileName)</RelativeBlobPath>
-        <ManifestArtifactData>ShipInstaller=dotnetcli</ManifestArtifactData>
-        <CacheControl>no-cache, no-store, must-revalidate</CacheControl>
-        <ContentType>text/plain</ContentType>
-        <Overwrite>true</Overwrite>
-      </FilesToPublish>
-
-      <!-- Packages -->
-      <_PackageArtifactInfo
-        Include="@(ArtifactInfo)"
-        ArtifactPath="$(DependencyPackagesDir)%(ArtifactInfo.PackageId).%(ArtifactInfo.Version).nupkg"
-        Condition="'%(ArtifactInfo.ArtifactType)' == 'NuGetPackage'" />
-
-      <_SymbolsPackageArtifactInfo
-        Include="@(ArtifactInfo)"
-        ArtifactPath="$(DependencyPackagesDir)%(ArtifactInfo.PackageId).%(ArtifactInfo.Version).symbols.nupkg"
-        Condition="'%(ArtifactInfo.ArtifactType)' == 'NuGetSymbolsPackage'" />
-
-      <NpmPackageToPublish Include="$(DependencyAssetsDir)%(ArtifactInfo.FileName)%(ArtifactInfo.Extension)" Condition="'%(ArtifactInfo.ArtifactType)' == 'NpmPackage'">
-        <RelativeBlobPath>$(NpmBlobBasePath)%(ArtifactInfo.PackageId)/%(ArtifactInfo.FileName)%(ArtifactInfo.Extension)</RelativeBlobPath>
-        <ManifestArtifactData>Type=NpmPackage</ManifestArtifactData>
-        <ContentType>application/tar+gzip</ContentType>
-      </NpmPackageToPublish>
-    </ItemGroup>
-
-    <!-- Join required because shipping category is stored in universe (PackageArtifact), but information about package ID and version comes from repos (ArtifactInfo). -->
-    <RepoTasks.JoinItems
-      Left="@(_PackageArtifactInfo->WithMetadataValue('Category',''))" LeftKey="PackageId" LeftMetadata="*" LeftItemSpec="Identity"
-      Right="@(PackageArtifact)" RightMetadata="Category">
-      <Output TaskParameter="JoinResult" ItemName="_PackageArtifactInfoWithCategory" />
-    </RepoTasks.JoinItems>
-
-    <ItemGroup>
-      <PackageToPublish Include="%(_PackageArtifactInfoWithCategory.ArtifactPath)" Category="%(_PackageArtifactInfoWithCategory.Category)" />
-      <PackageToPublish Include="%(_PackageArtifactInfo.ArtifactPath)" Category="%(_PackageArtifactInfo.Category)" Condition="'%(_PackageArtifactInfo.Category)' != ''" />
-      <PackageToPublish Include="%(_SymbolsPackageArtifactInfo.ArtifactPath)" Category="symbols" IsSymbolsPackage="true" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <RedistPackageToPublish Include="$(DependencyAssetsDir)$(SharedFrameworkRedistPackageId)*" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <_MissingArtifactFile Include="@(FilesToPublish)" Condition="!Exists(%(FilesToPublish.Identity))" />
-      <_MissingArtifactFile Include="@(NpmPackageToPublish)" Condition="!Exists(%(NpmPackageToPublish.Identity))" />
-      <_MissingArtifactFile Include="@(PackageToPublish)" Condition="!Exists(%(PackageToPublish.Identity))" />
-    </ItemGroup>
-
-    <Error Text="Missing expected files:%0A - @(_MissingArtifactFile, '%0A - ')" Condition="@(_MissingArtifactFile->Count()) != 0" />
-  </Target>
-
-  <Target Name="PublishToLocalFolder" DependsOnTargets="GetFilesToPublish">
-    <Copy SourceFiles="%(FilesToPublish.Identity)" DestinationFiles="$(ArtifactsDir)%(FilesToPublish.RelativeBlobPath)" Condition="'%(FilesToPublish.RelativeBlobPath)' != ''" />
-    <Copy SourceFiles="%(NpmPackageToPublish.Identity)" DestinationFolder="$(ArtifactsDir)npm\" />
-    <Copy SourceFiles="%(PackageToPublish.Identity)" DestinationFolder="$(ArtifactsDir)packages\%(PackageToPublish.Category)\" />
-  </Target>
-
-  <Target Name="PublishToMyGet"
-          DependsOnTargets="GetFilesToPublish;GetToolsets"
-          Condition="'$(PublishToMyget)' == 'true'">
-
-    <Error Text="Missing required property: PublishMyGetFeedUrl"  Condition=" '$(PublishMyGetFeedUrl)' == '' "/>
-    <Error Text="Missing required property: PublishMyGetSymbolsFeedUrl"  Condition=" '$(PublishMyGetSymbolsFeedUrl)' == '' "/>
-    <Error Text="Missing required property: PublishMyGetNpmRegistryUrl"  Condition=" '$(PublishMyGetNpmRegistryUrl)' == '' "/>
-    <Error Text="Missing required property: PublishMyGetFeedKey"  Condition=" '$(PublishMyGetFeedKey)' == '' "/>
-
-    <Error Text="No packages found to publish" Condition="@(PackageToPublish->Count()) == 0" />
-
-    <PushNuGetPackages Condition="'%(PackageToPublish.IsSymbolsPackage)' != 'true' AND @(PackageToPublish->Count()) != 0"
-      Packages="@(PackageToPublish)"
-      Feed="$(PublishMyGetFeedUrl)"
-      ApiKey="$(PublishMyGetFeedKey)" />
-
-    <PushNuGetPackages Condition="'%(PackageToPublish.IsSymbolsPackage)' == 'true' AND @(PackageToPublish->Count()) != 0"
-      Packages="@(PackageToPublish)"
-      Feed="$(PublishMyGetSymbolsFeedUrl)"
-      ApiKey="$(PublishMyGetFeedKey)" />
-
-    <PropertyGroup>
-      <AuthTokenSetting>$(PublishMyGetNpmRegistryUrl.Replace("https:", "")):_authToken</AuthTokenSetting>
-    </PropertyGroup>
-
-    <Message Condition=" @(NpmPackageToPublish->Count()) != 0 "
-             Text="Skipping NPM publish because there are no npm packages to publish."
-             Importance="high" />
-
-    <Exec Condition=" @(NpmPackageToPublish->Count()) != 0 "
-          Command="npm config set &quot;$(AuthTokenSetting)&quot; $(PublishMyGetFeedKey)"
-          StandardOutputImportance="Normal" />
-
-    <!-- When you UseCommandProcessor FileName is ignored -->
-    <Run Condition=" @(NpmPackageToPublish->Count()) != 0 "
-         FileName="cmd"
-         Arguments="npm;publish;--registry;$(PublishMyGetNpmRegistryUrl);%(NpmPackageToPublish.Identity)"
-         MaxRetries="5"
-         UseCommandProcessor="true"
-         ContinueOnError="true">
-      <Output TaskParameter="ExitCode" ItemName="_NpmExitCodes" />
-    </Run>
-
-    <Exec Condition=" @(NpmPackageToPublish->Count()) != 0 "
-          Command="npm config delete $(AuthTokenSetting)"
-          StandardOutputImportance="Normal" />
-
-    <Error Text="Publishing npm modules failed" Condition=" @(NpmPackageToPublish->Count()) != 0 AND %(_NpmExitCodes.Identity) != 0" />
-  </Target>
-
-  <Target Name="PublishToAzureFeed"
-    DependsOnTargets="GetFilesToPublish"
-    Condition="'$(PublishToAzureFeed)' == 'true'">
-
-    <PropertyGroup>
-      <!--
-        Allow setting AzureBlobRelativePathBase to control the base path of all uploaded blobs.
-        AzureBlobRelativePathBase should end in a slash.
-      -->
-      <AzureBlobRelativePathBase Condition="'$(AzureBlobRelativePathBase)' != '' AND !HasTrailingSlash('$(AzureBlobRelativePathBase)')">$(AzureBlobRelativePathBase)/</AzureBlobRelativePathBase>
-    </PropertyGroup>
-
-    <ItemGroup Condition=" '$(AzureBlobRelativePathBase)' != '' ">
-      <FilesToPublish Update="@(FilesToPublish)" RelativeBlobPath="$(AzureBlobRelativePathBase)%(FilesToPublish.RelativeBlobPath)" />
-    </ItemGroup>
-
-    <RepoTasks.PublishToAzureBlob
-        AccountName="$(AzureAccountName)"
-        SharedAccessToken="$(AzureSharedAccessToken)"
-        ContainerName="$(AzureContainerName)"
-        Files="@(FilesToPublish)" />
-  </Target>
-
-  <Target Name="PublishToTransportFeed"
-    DependsOnTargets="ResolveCommitHash;GetFilesToPublish"
-    Condition="'$(PublishToTransportFeed)' == 'true'">
-
-    <ItemGroup>
-      <PackageToPublishToTransport
-        Include="@(PackageToPublish)"
-        Condition="'%(PackageToPublish.Category)' == 'ship'" />
-
-      <PackageToPublishToTransport
-        Include="@(PackageToPublish)"
-        ManifestArtifactData="NonShipping=true"
-        Condition="'%(PackageToPublish.Category)' != 'ship'" />
-
-      <PackageToPublishToTransport
-        Include="@(RedistPackageToPublish)"
-        ManifestArtifactData="NonShipping=true" />
-
-      <FilesToPublishToTransport Include="@(NpmPackageToPublish)"
-        RelativeBlobPath="$(BlobFileRelativePathBase)%(NpmPackageToPublish.RelativeBlobPath)"
-        ManifestArtifactData="%(NpmPackageToPublish.ManifestArtifactData)" />
-
-      <!-- Filter aliased artifacts to workaround dotnet/buildtools#1855 -->
-      <FilesToPublishToTransport Include="@(FilesToPublish)"
-        RelativeBlobPath="$(BlobFileRelativePathBase)%(FilesToPublish.RelativeBlobPath)"
-        ManifestArtifactData="%(FilesToPublish.ManifestArtifactData)"
-        Condition=" '%(FilesToPublish.IsDuplicateUpload)' != 'true' " />
-    </ItemGroup>
-
-    <PushToBlobFeed ExpectedFeedUrl="$(PublishBlobFeedUrl)"
-                    AccountKey="$(PublishBlobFeedKey)"
-                    ItemsToPush="@(PackageToPublishToTransport)"
-                    Overwrite="$(PushToBlobFeed_Overwrite)"
-                    UploadTimeoutInMinutes="$(PushToBlobFeed_UploadTimeoutMinutes)"
-                    ManifestBranch="$(BuildBranch)"
-                    ManifestBuildId="$(Version)"
-                    ManifestBuildData="ProductVersion=$(PackageVersion);UniverseCommitHash=$(CommitHash)"
-                    ManifestCommit="$(CommitHash)"
-                    ManifestName="aspnet"
-                    MaxClients="$(PushToBlobFeed_MaxClients)"
-                    Condition="@(PackageToPublish->Count()) != 0" />
-
-    <PushToBlobFeed ExpectedFeedUrl="$(PublishBlobFeedUrl)"
-                    AccountKey="$(PublishBlobFeedKey)"
-                    ItemsToPush="@(FilesToPublishToTransport)"
-                    PublishFlatContainer="true"
-                    Overwrite="$(PushToBlobFeed_Overwrite)"
-                    UploadTimeoutInMinutes="$(PushToBlobFeed_UploadTimeoutMinutes)"
-                    ManifestBranch="$(BuildBranch)"
-                    ManifestBuildId="$(Version)"
-                    ManifestBuildData="ProductVersion=$(PackageVersion);UniverseCommitHash=$(CommitHash)"
-                    ManifestCommit="$(CommitHash)"
-                    ManifestName="aspnet"
-                    MaxClients="$(PushToBlobFeed_MaxClients)" />
-  </Target>
-
-</Project>
--- a/build/RepositoryBuild.targets
+++ b/build/RepositoryBuild.targets
@ -1,185 +0,0 @@
-<Project>
-
-  <PropertyGroup>
-    <!-- Experimental flag to run assemblies AND repos tests in parallel...if you dare. -->
-    <TestReposInParallel>false</TestReposInParallel>
-
-    <_NoBuildRepos>$(NoBuild)</_NoBuildRepos>
-    <_BuildScriptToExecute Condition="'$(OS)'!='Windows_NT'">build.sh</_BuildScriptToExecute>
-    <_BuildScriptToExecute Condition="'$(OS)'=='Windows_NT'">build.cmd</_BuildScriptToExecute>
-  </PropertyGroup>
-
-  <Target Name="GetRepoBatches" DependsOnTargets="GeneratePropsFiles;ComputeGraph">
-    <ItemGroup>
-      <RepositoryBuildOrder Condition="'%(RootPath)' == ''">
-        <RootPath>$(SubmoduleRoot)%(Identity)\</RootPath>
-      </RepositoryBuildOrder>
-      <BatchedRepository Include="$(MSBuildProjectFullPath)">
-        <BuildGroup>%(RepositoryBuildOrder.Order)</BuildGroup>
-        <Repository>%(RepositoryBuildOrder.Identity)</Repository>
-        <AdditionalProperties>
-          RepositoryToBuild=%(RepositoryBuildOrder.Identity);
-          BuildRepositoryRoot=$([MSBuild]::NormalizeDirectory(%(RepositoryBuildOrder.RootPath)))
-        </AdditionalProperties>
-      </BatchedRepository>
-    </ItemGroup>
-  </Target>
-
-  <Target Name="_BuildRepositories" DependsOnTargets="GetRepoBatches" Condition=" @(RepositoryBuildOrder->Count()) != 0 ">
-    <MSBuild
-      Projects="@(BatchedRepository)"
-      BuildInParallel="true"
-      StopOnFirstFailure="true"
-      Targets="_BuildRepository"
-      Properties="BuildGroup=%(BatchedRepository.BuildGroup);BuildNumber=$(BuildNumber);IsFinalBuild=$(IsFinalBuild);Configuration=$(Configuration)" />
-
-    <PropertyGroup>
-      <_NoBuildRepos>true</_NoBuildRepos>
-    </PropertyGroup>
-  </Target>
-
-  <Target Name="_TestRepositories" DependsOnTargets="GetRepoBatches" Condition=" @(RepositoryBuildOrder->Count()) != 0 ">
-    <!--
-      Use the task to sort instead of batching (i.e. using %(BatchedRepository.BuildGroup))
-      When batching, StopOnFirstFailure doesn't help because the MSBuild task would be invoked multiple times
-      instead of invoking once with many projects.
-    -->
-    <RepoTasks.OrderBy Items="@(BatchedRepository)" Key="BuildGroup">
-      <Output TaskParameter="Items" ItemName="_BatchedTestRepo" />
-    </RepoTasks.OrderBy>
-
-    <MSBuild
-      Projects="@(_BatchedTestRepo)"
-      BuildInParallel="$(TestProjectsInParallel)"
-      StopOnFirstFailure="false"
-      Targets="_TestRepository"
-      Properties="BuildNumber=$(BuildNumber);IsFinalBuild=$(IsFinalBuild);Configuration=$(Configuration);_NoBuildRepos=$(_NoBuildRepos)"
-      ContinueOnError="true">
-      <Output TaskParameter="TargetOutputs" ItemName="_RepoTestResults" />
-    </MSBuild>
-
-    <Warning Text="No test results were found from running repos." Condition="@(_RepoTestResults->Count()) == 0"/>
-    <Message Text="Tests passed for the following repos:%0A - @(_RepoTestResults->WithMetadataValue('Success', 'true'), '%0A - ')"
-      Importance="High"
-      Condition="@(_RepoTestResults->WithMetadataValue('Success', 'true')->Count()) != 0 " />
-    <Error Text="Tests failed for the following repos:%0A - @(_RepoTestResults->WithMetadataValue('Success', 'false'), '%0A - ')"
-      Condition="@(_RepoTestResults->WithMetadataValue('Success', 'false')->Count()) != 0 " />
-  </Target>
-
-  <!-- Inner build context -->
-
-  <Target Name="GetRepoBuildProps">
-    <PropertyGroup>
-      <SkipTestsDueToMissingSharedFx Condition="'$(InstallSharedRuntimeFromPreviousBuild)' != 'true' And '$(TestsRequiredTheSharedRuntime)' == 'true' ">true</SkipTestsDueToMissingSharedFx>
-
-      <RepositoryBuildArguments Condition="'$(CI)'== 'true'">$(RepositoryBuildArguments) -ci</RepositoryBuildArguments>
-      <RepositoryBuildArguments Condition="'$(CI)'== 'true' AND '$(OS)' != 'Windows_NT'">$(RepositoryBuildArguments) --dotnet-home '$(DOTNET_HOME)'</RepositoryBuildArguments>
-      <RepositoryBuildArguments Condition="'$(CI)'== 'true' AND '$(OS)' == 'Windows_NT'">$(RepositoryBuildArguments) -DotNetHome '$(DOTNET_HOME)'</RepositoryBuildArguments>
-      <!-- Should reduce allowable package feeds to only nuget.org. -->
-      <RepositoryBuildArguments>$(RepositoryBuildArguments) /p:AspNetUniverseBuildOffline=true</RepositoryBuildArguments>
-      <!-- If there are duplicate properties, the properties which are defined later in the order would override the earlier ones -->
-      <RepositoryBuildArguments>$(RepositoryBuildArguments) /p:DotNetRestoreSourcePropsPath=$(GeneratedRestoreSourcesPropsPath)</RepositoryBuildArguments>
-      <RepositoryBuildArguments>$(RepositoryBuildArguments) /p:DotNetPackageVersionPropsPath=$(GeneratedPackageVersionPropsPath)</RepositoryBuildArguments>
-      <RepositoryBuildArguments>$(RepositoryBuildArguments) /p:BuildNumber=$(BuildNumber)</RepositoryBuildArguments>
-      <RepositoryBuildArguments>$(RepositoryBuildArguments) /p:Configuration=$(Configuration)</RepositoryBuildArguments>
-      <RepositoryBuildArguments>$(RepositoryBuildArguments) /p:IsFinalBuild=$(IsFinalBuild)</RepositoryBuildArguments>
-      <!-- We collect all output and code sign at the end. We don't need to code sign when we build each submodule. -->
-      <RepositoryBuildArguments>$(RepositoryBuildArguments) /p:DisableCodeSigning=true</RepositoryBuildArguments>
-      <RepositoryBuildArguments>$(RepositoryBuildArguments) '/p:DotNetAssetRootAccessTokenSuffix=$(DotNetAssetRootAccessTokenSuffix)'</RepositoryBuildArguments>
-      <RepositoryBuildArguments>$(RepositoryBuildArguments) '/p:DotNetAssetRootUrl=$(DotNetAssetRootUrl)'</RepositoryBuildArguments>
-      <RepositoryBuildArguments Condition=" '$(SkipTestsDueToMissingSharedFx)' == 'true' ">$(RepositoryBuildArguments) /p:SkipAspNetCoreRuntimeInstall=true</RepositoryBuildArguments>
-
-      <SourceLockFile>$(RepositoryRoot)korebuild-lock.txt</SourceLockFile>
-      <RepoLockFile>$(BuildRepositoryRoot)korebuild-lock.txt</RepoLockFile>
-      <BackupRepoLockFile>$(IntermediateDir)$(RepositoryToBuild)-korebuild-lock.txt</BackupRepoLockFile>
-    </PropertyGroup>
-  </Target>
-
-  <Target Name="_UpdateRepoLockFile">
-    <!-- Copy Korebuild lock file to individual repos to align version if the repo doesn't already have one -->
-    <Message Text="Copying KoreBuild lockfile from repo to submodule $(BuildRepositoryRoot)"/>
-    <Move SourceFiles="$(RepoLockFile)" DestinationFiles="$(BackupRepoLockFile)" Condition="Exists($(RepoLockFile))" />
-    <Copy SourceFiles="$(SourceLockFile)" DestinationFiles="$(RepoLockFile)" />
-  </Target>
-
-  <Target Name="_RestoreOriginalRepoLockFile">
-    <!-- Restore original Korebuild lock file -->
-    <Delete Files="$(RepoLockFile)" ContinueOnError="true" />
-    <Move SourceFiles="$(BackupRepoLockFile)" DestinationFiles="$(RepoLockFile)" Condition="Exists($(BackupRepoLockFile))"  />
-  </Target>
-
-  <Target Name="_BuildRepository" DependsOnTargets="GetRepoBuildProps;_UpdateRepoLockFile">
-    <PropertyGroup>
-      <BuildArguments>/t:CleanArtifacts /t:Build /p:SkipTests=true $(RepositoryBuildArguments)</BuildArguments>
-      <BuildArguments Condition="'$(ProduceRepoBinLog)' == 'true'">$(BuildArguments) /bl:$(LogOutputDir)$(RepositoryToBuild).build.binlog</BuildArguments>
-      <RepositoryArtifactsRoot>$(BuildRepositoryRoot)artifacts</RepositoryArtifactsRoot>
-      <RepositoryArtifactsBuildDirectory>$(RepositoryArtifactsRoot)\build\</RepositoryArtifactsBuildDirectory>
-      <RepositoryArtifactsMSBuildDirectory>$(RepositoryArtifactsRoot)\msbuild\</RepositoryArtifactsMSBuildDirectory>
-    </PropertyGroup>
-
-    <Message Text="============ Building $(RepositoryToBuild) ============" Importance="High" />
-
-    <!-- Remove final slash in $(BuildRepositoryRoot) to avoid problems due to KoreBuild adding one on Windows. -->
-    <Exec
-      Command="./$(_BuildScriptToExecute) -Path $(BuildRepositoryRoot.TrimEnd('\\')) $(BuildArguments)"
-      IgnoreStandardErrorWarningFormat="true"
-      WorkingDirectory="$(RepositoryRoot)"
-      IgnoreExitCode="true"
-      ContinueOnError="WarnAndContinue">
-      <Output TaskParameter="ExitCode" PropertyName="BuildExitCode" />
-    </Exec>
-
-    <CallTarget Targets="_RestoreOriginalRepoLockFile" />
-
-    <!-- Fail if build.cmd didn't exit code 0 or process failed to start. -->
-    <Error Text="Building $(RepositoryToBuild) failed: $(_BuildScriptToExecute) exited code $(BuildExitCode)" Condition=" '$(BuildExitCode)' != '0' " />
-
-    <ItemGroup>
-      <RepositoryArtifacts Include="$(RepositoryArtifactsBuildDirectory)*" />
-      <RepositoryMSBuildArtifacts Include="$(RepositoryArtifactsMSBuildDirectory)**\*" />
-    </ItemGroup>
-
-    <Copy
-       SourceFiles="@(RepositoryArtifacts)"
-       DestinationFolder="$(BuildDir)" />
-
-    <Move
-       SourceFiles="@(RepositoryMSBuildArtifacts)"
-       DestinationFolder="$(ArtifactsDir)msbuild\$(RepositoryToBuild)\%(RecursiveDir)" />
-
-    <Message Text="============ Done building $(RepositoryToBuild) ============" Importance="High" />
-  </Target>
-
-  <Target Name="_TestRepository" DependsOnTargets="GetRepoBuildProps;_UpdateRepoLockFile" Returns="@(RepositoryTestResult)">
-    <PropertyGroup>
-      <BuildArguments>/t:Test /p:NoBuild=$(_NoBuildRepos) $(RepositoryBuildArguments)</BuildArguments>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <RepositoryTestResult Include="$(RepositoryToBuild)" Success="false" />
-    </ItemGroup>
-
-    <!-- To enable this test, either publish the shared runtime to https://dotnetcli.blob.core.windows.net/dotnet, or override the install location by setting AspNetCoreFxFeed. -->
-    <Warning Text="Skipping tests because InstallSharedRuntimeFromPreviousBuild != 'true'." Condition="'$(SkipTestsDueToMissingSharedFx)' == 'true' "/>
-
-    <Message Text="============ Testing $(RepositoryToBuild) ============" Importance="High" />
-
-    <!-- Remove final slash in $(BuildRepositoryRoot) to avoid problems due to KoreBuild adding one on Windows. -->
-    <Exec Condition="'$(SkipTestsDueToMissingSharedFx)' != 'true' "
-      Command="./$(_BuildScriptToExecute) -Path $(BuildRepositoryRoot.TrimEnd('\\')) $(BuildArguments)"
-      IgnoreStandardErrorWarningFormat="true"
-      WorkingDirectory="$(RepositoryRoot)"
-      IgnoreExitCode="true">
-      <Output TaskParameter="ExitCode" PropertyName="TestExitCode" />
-    </Exec>
-
-    <CallTarget Targets="_RestoreOriginalRepoLockFile" />
-
-    <ItemGroup>
-      <RepositoryTestResult Update="$(RepositoryToBuild)" Success="true" Condition="'$(TestExitCode)' == '0' OR '$(SkipTestsDueToMissingSharedFx)' == 'true' " />
-    </ItemGroup>
-
-    <Message Text="============ Done testing $(RepositoryToBuild) ============" Importance="High" />
-  </Target>
-
-</Project>
--- a/build/SharedFx.props
+++ b/build/SharedFx.props
@ -1,78 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <!-- directories -->
-    <_WorkRoot>$(RepositoryRoot).w\$(SharedFxRID)\</_WorkRoot>
-    <_WorkLayoutDir>$(_WorkRoot).l\</_WorkLayoutDir>
-    <_WorkOutputDir>$(_WorkRoot).o\</_WorkOutputDir>
-    <_MetapackageSrcRoot>$(RepositoryRoot)src\Packages\</_MetapackageSrcRoot>
-    <_TemplatesDir>$(MSBuildThisFileDirectory)tools\templates\</_TemplatesDir>
-    <_DockerDir>$(MSBuildThisFileDirectory)tools\docker\</_DockerDir>
-    <_PackagingDir>$(MSBuildThisFileDirectory)tools\packaging\</_PackagingDir>
-    <_SharedFxSourceDir>$(RepositoryRoot).deps\Signed\SharedFx\</_SharedFxSourceDir>
-    <_InstallerSourceDir>$(RepositoryRoot).deps\Installers\</_InstallerSourceDir>
-    <_SymbolsSourceDir>$(RepositoryRoot).deps\symbols\</_SymbolsSourceDir>
-    <_DockerRootDir>/opt/code/</_DockerRootDir>
-    <_InstallersOutputDir>$(ArtifactsDir)installers\</_InstallersOutputDir>
-    <!-- 3B = semicolon in ASCII -->
-    <PathSeparator Condition="'$(PathSeparator)' == ''">:</PathSeparator>
-    <PathSeparator Condition="$(SharedFxRID.StartsWith('win'))">%3B</PathSeparator>
-    <ArchiveExtension>.tar.gz</ArchiveExtension>
-    <ArchiveExtension Condition="$(SharedFxRID.StartsWith('win'))">.zip</ArchiveExtension>
-
-    <LibPrefix Condition="$([MSBuild]::IsOSPlatform('Linux')) OR $([MSBuild]::IsOSPlatform('OSX'))">lib</LibPrefix>
-    <LibExtension>.so</LibExtension>
-    <LibExtension Condition="$([MSBuild]::IsOSPlatform('Windows'))">.dll</LibExtension>
-    <LibExtension Condition="$([MSBuild]::IsOSPlatform('OSX'))">.dylib</LibExtension>
-    <ExeExtension Condition="$([MSBuild]::IsOSPlatform('Windows'))">.exe</ExeExtension>
-    <SharedFrameworkTargetFramework>netcoreapp2.1</SharedFrameworkTargetFramework>
-
-    <!-- installers -->
-    <SharedFxInstallerName>aspnetcore-runtime</SharedFxInstallerName>
-    <!--
-      This is named aspnetcore-runtime-internal because it only includes Microsoft.AspNetCore.All and is an intermediate file passed off to signing, installer generation, etc.
-      Subsequent build steps will combine this with Microsoft.NETCore.App and produce final tarballs/zips.
-    -->
-    <SharedFxIntermediateArchiveBaseName>$(SharedFxInstallerName)-internal</SharedFxIntermediateArchiveBaseName>
-    <DebConfigInFile>$(_PackagingDir)debian_config.json.in</DebConfigInFile>
-    <PublicCoreFeedPrefix>https://dotnetcli.blob.core.windows.net/dotnet/</PublicCoreFeedPrefix>
-
-    <!-- In an orchestrated build, this may be overriden to other Azure feeds. -->
-    <DotNetAssetRootUrl Condition="'$(DotNetAssetRootUrl)'==''">$(PublicCoreFeedPrefix)</DotNetAssetRootUrl>
-
-    <DotnetRuntimeFileNamePrefix>dotnet-runtime-$(MicrosoftNETCoreAppPackageVersion)</DotnetRuntimeFileNamePrefix>
-    <RuntimeArchiveLinkPrefix>$(DotNetAssetRootUrl)Runtime/$(MicrosoftNETCoreAppPackageVersion)/$(DotnetRuntimeFileNamePrefix)</RuntimeArchiveLinkPrefix>
-
-    <SharedFxIntermediateArchiveFilePrefix>$(_SharedFxSourceDir)$(SharedFxIntermediateArchiveBaseName)-$(PackageVersion)</SharedFxIntermediateArchiveFilePrefix>
-
-    <!-- installer versions -->
-    <!-- CLI would take a dependency such as 'aspnetcore-runtime-M.N >= M.N.P'. Here M.N is the InstallerIdVersion and M.N.P is the InstallerPackageVersion -->
-    <InstallerIdVersion>$(AspNetCoreMajorVersion).$(AspNetCoreMinorVersion)</InstallerIdVersion>
-    <InstallerPackageVersion>$(InstallerIdVersion).$(AspNetCorePatchVersion)</InstallerPackageVersion>
-    <!-- Deb installers are versioned as M.N.P~Build following the core-setup convention -->
-    <DebInstallerPackageVersion>$(InstallerPackageVersion)</DebInstallerPackageVersion>
-    <DebInstallerPackageVersion Condition="'$(PackageVersionSuffix)' != ''">$(DebInstallerPackageVersion)~$(PackageVersionSuffix)</DebInstallerPackageVersion>
-    <PackageRevision>1</PackageRevision>
-    <!-- While the revision number of Debian installers must stay at 1, the RPM installers will include the build number in the revision if available -->
-    <RpmPackageRevision>$(PackageRevision)</RpmPackageRevision>
-    <RpmPackageRevision Condition="'$(PackageVersionSuffix)' != ''">0.1.$(PackageVersionSuffix)</RpmPackageRevision>
-    <RpmPackageRevision>$([System.String]::Copy('$(RpmPackageRevision)').Replace('-', '_'))</RpmPackageRevision>
-
-    <!-- installer metadata -->
-    <MaintainerName>Microsoft</MaintainerName>
-    <MaintainerEmail>nugetaspnet@microsoft.com</MaintainerEmail>
-    <Homepage>https://www.asp.net/</Homepage>
-    <InstallRoot>/usr/share/dotnet</InstallRoot>
-    <LicenseType>Apache-2.0</LicenseType>
-    <SharedFxSummary>Microsoft ASP.NET Core $(PackageVersion) Shared Framework</SharedFxSummary>
-    <SharedFxDescription>Shared Framework for hosting of Microsoft ASP.NET Core applications. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/aspnet/home). We happily accept issues and PRs.</SharedFxDescription>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <WindowsSharedFxRIDs Include="win-x64;win-x86"/>
-    <NonWindowsSharedFxRIDs Include="osx-x64" CrossgenSymbols="false" />
-    <NonWindowsSharedFxRIDs Include="linux-musl-x64" />
-    <NonWindowsSharedFxRIDs Include="linux-x64" />
-    <NonWindowsSharedFxRIDs Include="linux-arm" CrossGen="false" />
-    <AllSharedFxRIDs Include="@(WindowsSharedFxRIDs);@(NonWindowsSharedFxRIDs)"/>
-  </ItemGroup>
-</Project>
--- a/build/SharedFx.targets
+++ b/build/SharedFx.targets
@ -1,574 +0,0 @@
-<Project>
-  <Import Project="SharedFx.props" />
-
-  <PropertyGroup>
-    <SharedFxOutputPath>$([MSBuild]::NormalizeDirectory($(ArtifactsDir)))runtime\</SharedFxOutputPath>
-  </PropertyGroup>
-
-  <Target Name="GetMetapackageArtifactInfo">
-    <ItemGroup>
-      <_MetapackageProject Include="$(RepositoryRoot)src\Packages\Microsoft.AspNetCore.All\Microsoft.AspNetCore.All.csproj" />
-      <_MetapackageProject Include="$(RepositoryRoot)src\Packages\Microsoft.AspNetCore.App\Microsoft.AspNetCore.App.csproj" />
-    </ItemGroup>
-
-    <MSBuild Projects="@(_MetapackageProject)"
-      Targets="GetArtifactInfo"
-      Properties="PackageOutputPath=$(BuildDir);BuildNumber=$(BuildNumber);DesignTimeBuild=true;IsFinalBuild=$(IsFinalBuild)">
-      <Output TaskParameter="TargetOutputs" ItemName="ArtifactInfo" />
-    </MSBuild>
-
-    <ItemGroup>
-      <!-- Cartesian products in MSBuild are fun :) -->
-      <_SharedFrameworkSymbolsPackage Include="@(SharedFrameworkName)" Condition="'%(AllSharedFxRIDs.CrossgenSymbols)' != 'false' AND '%(AllSharedFxRIDs.Crossgen)' != 'false'">
-        <Rid>%(AllSharedFxRIDs.Identity)</Rid>
-      </_SharedFrameworkSymbolsPackage>
-      <_SharedFrameworkSymbolsPackage Update="@(_SharedFrameworkSymbolsPackage)" PackageId="runtime.%(Rid).%(Identity)" />
-      <ArtifactInfo Include="@(_SharedFrameworkSymbolsPackage->'$(BuildDir)%(PackageId).$(PackageVersion).symbols.nupkg')">
-        <ArtifactType>NuGetSymbolsPackage</ArtifactType>
-        <PackageId>%(_SharedFrameworkSymbolsPackage.PackageId)</PackageId>
-        <Version>$(PackageVersion)</Version>
-        <Category>shipoob</Category>
-      </ArtifactInfo>
-    </ItemGroup>
-  </Target>
-
-  <Target Name="_BuildMetapackage" DependsOnTargets="ResolveSharedSourcesPackageInfo;GetProjectArtifactInfo;ResolveRepoInfo">
-    <PropertyGroup>
-      <MetapackageSource>$(_MetapackageSrcRoot)$(MetapackageName)\</MetapackageSource>
-      <MetapackageWorkDirectory>$(_WorkRoot)pkg\$(MetapackageName)\</MetapackageWorkDirectory>
-      <CommonProps />
-      <CommonProps>$(CommonProps);Configuration=$(Configuration)</CommonProps>
-      <CommonProps>$(CommonProps);DotNetRestoreSourcePropsPath=$(GeneratedRestoreSourcesPropsPath)</CommonProps>
-      <CommonProps>$(CommonProps);DotNetBuildOffline=true</CommonProps>
-      <CommonProps>$(CommonProps);AspNetUniverseBuildOffline=true</CommonProps>
-      <CommonProps>$(CommonProps);RuntimeFrameworkVersion=$(MicrosoftNETCoreApp21PackageVersion)</CommonProps>
-      <CommonProps>$(CommonProps);AppMetapackageVersion=$(PackageVersion)</CommonProps>
-      <CommonProps>$(CommonProps);BuildNumber=$(BuildNumber)</CommonProps>
-    </PropertyGroup>
-
-    <Error
-      Text="Source directory $(MetapackageSource) for $(MetapackageName) does not exist."
-      Condition="!Exists('$(MetapackageSource)')" />
-
-    <ItemGroup>
-      <MetapackageFiles Include="$(MetapackageSource)**\*" />
-    </ItemGroup>
-
-    <!-- Clear working directory -->
-    <RemoveDir Directories="$(MetapackageWorkDirectory)" />
-
-    <!-- Move to working dir -->
-    <Copy SourceFiles="@(MetapackageFiles)" DestinationFolder="$(MetapackageWorkDirectory)%(RecursiveDir)" />
-    <Copy SourceFiles="$(_MetapackageSrcRoot)Directory.Build.props" DestinationFolder="$(_WorkRoot)" />
-
-    <!-- Add references to project -->
-    <RepoTasks.AddMetapackageReferences
-      ReferencePackagePath="$(MetapackageWorkDirectory)$(MetapackageName).csproj"
-      MetapackageReferenceType="$(MetapackageReferenceType)"
-      DependencyVersionRangeType="$(MetapackageDependencyVersionRangeType)"
-      PackageArtifacts="@(_PackageArtifactSpec)"
-      ExternalDependencies="@(ExternalDependency)" />
-
-    <!-- Set _Target=Restore so the project will be re-evaluated to include Internal.AspNetCore.Sdk MSBuild properties on the next step. -->
-    <MSBuild Projects="$(MetapackageWorkDirectory)$(MetapackageName).csproj" Targets="Restore" Properties="$(CommonProps);_Target=Restore" />
-    <!-- Pack -->
-    <MSBuild Projects="$(MetapackageWorkDirectory)$(MetapackageName).csproj" Targets="Pack" Properties="$(CommonProps);PackageOutputPath=$(BuildDir)" />
-  </Target>
-
-  <Target Name="BuildMetapackages">
-    <ItemGroup>
-      <_MetapackageBuilderProject Include="$(MSBuildProjectFullPath)">
-        <AdditionalProperties>
-          MetapackageName=Microsoft.AspNetCore.App;
-          MetapackageReferenceType=AppMetapackage;
-          MetapackageDependencyVersionRangeType=MajorMinor
-        </AdditionalProperties>
-      </_MetapackageBuilderProject>
-
-      <_MetapackageBuilderProject Include="$(MSBuildProjectFullPath)">
-        <AdditionalProperties>
-          MetapackageName=Microsoft.AspNetCore.All;
-          MetapackageReferenceType=AllMetapackage;
-          MetapackageDependencyVersionRangeType=Minimum
-        </AdditionalProperties>
-      </_MetapackageBuilderProject>
-    </ItemGroup>
-
-    <MSBuild
-      Projects="@(_MetapackageBuilderProject)"
-      Targets="_BuildMetapackage"
-      BuildInParallel="false" />
-  </Target>
-
-  <Target Name="BuildSiteExtension" DependsOnTargets="BuildMetapackages" Condition="'$(BuildSiteExtension)' == 'true'" >
-    <PropertyGroup>
-      <AzureIntegrationProjProperties>
-        AspNetUniverseBuildOffline=true;
-        DotNetRestoreSourcePropsPath=$(GeneratedRestoreSourcesPropsPath);
-        DotNetPackageVersionPropsPath=$(GeneratedPackageVersionPropsPath);
-        BuildNumber=$(BuildNumber);
-        Configuration=$(Configuration);
-        IsFinalBuild=$(IsFinalBuild);
-      </AzureIntegrationProjProperties>
-    </PropertyGroup>
-
-    <!-- Pack logging site extension -->
-    <MSBuild Projects="$(RepositoryRoot)\src\SiteExtensions\LoggingBranch\LoggingBranch.csproj" Targets="Restore;Pack" Properties="$(AzureIntegrationProjProperties);PackageOutputPath=$(BuildDir)" />
-  </Target>
-
-  <Target Name="GetSiteExtensionArtifactInfo" Condition="'$(BuildSiteExtension)' == 'true'" >
-    <MSBuild Projects="$(RepositoryRoot)\src\SiteExtensions\LoggingBranch\LoggingBranch.csproj" Targets="GetArtifactInfo" Properties="PackageOutputPath=$(BuildDir);BuildNumber=$(BuildNumber);DesignTimeBuild=true;IsFinalBuild=$(IsFinalBuild)">
-      <Output TaskParameter="TargetOutputs" ItemName="ArtifactInfo" />
-    </MSBuild>
-  </Target>
-
-  <Target Name="DefineSharedFxPrerequisites" DependsOnTargets="ResolveCommitHash">
-    <PropertyGroup>
-      <RIDIsAcceptable Condition="'%(AllSharedFxRIDs.Identity)' == '$(SharedFxRID)'">true</RIDIsAcceptable>
-      <CrossGenSharedFx>false</CrossGenSharedFx>
-      <CrossGenSharedFx Condition="'%(AllSharedFxRIDs.Identity)' == '$(SharedFxRID)' AND '%(AllSharedFxRIDs.Crossgen)' != 'false' ">true</CrossGenSharedFx>
-      <CrossGenSharedFxSymbols>false</CrossGenSharedFxSymbols>
-      <CrossGenSharedFxSymbols Condition="'$(CrossGenSharedFx)' != 'false' AND '%(AllSharedFxRIDs.Identity)' == '$(SharedFxRID)' AND '%(AllSharedFxRIDs.CrossgenSymbols)' != 'false' ">true</CrossGenSharedFxSymbols>
-    </PropertyGroup>
-
-    <Error Text="&quot;$(SharedFxRID)&quot; not acceptable as a SharedFxRID, please specify an acceptable value: {@(AllSharedFxRIDs)}." Condition="'$(RIDIsAcceptable)' != 'true'"/>
-
-    <PropertyGroup>
-      <AppSharedFxWorkDirectory>$(_WorkRoot)AppSharedFx\</AppSharedFxWorkDirectory>
-      <AllSharedFxWorkDirectory>$(_WorkRoot)AllSharedFx\</AllSharedFxWorkDirectory>
-      <SharedFxIntermediateOutputPath>$(_WorkRoot)Publish\</SharedFxIntermediateOutputPath>
-      <SharedFxCrossGenDirectory>$(_WorkRoot)CrossGen\</SharedFxCrossGenDirectory>
-      <SharedFxCrossGenSymbolsDirectory>$(_WorkRoot)CrossGenSymbols\</SharedFxCrossGenSymbolsDirectory>
-      <SharedFxCrossGenToolDirectory>$(_WorkRoot)CrossGenTool\</SharedFxCrossGenToolDirectory>
-      <SharedFxCrossGenRspDirectory>$(_WorkRoot)CrossGenRsp\</SharedFxCrossGenRspDirectory>
-      <AppSharedFxPublishDirectory>$(SharedFxIntermediateOutputPath)shared\Microsoft.AspNetCore.App\$(PackageVersion)\</AppSharedFxPublishDirectory>
-      <AllSharedFxPublishDirectory>$(SharedFxIntermediateOutputPath)shared\Microsoft.AspNetCore.All\$(PackageVersion)\</AllSharedFxPublishDirectory>
-      <SharedFxRestoreRid>$(SharedFxRID)</SharedFxRestoreRid>
-
-      <!-- 3B = semicolon in ASCII -->
-      <PathSeparator Condition="'$(PathSeparator)' == ''">:</PathSeparator>
-      <PathSeparator Condition="$(SharedFxRID.StartsWith('win'))">%3B</PathSeparator>
-
-      <CommonSharedFxProps>Configuration=$(Configuration);RuntimeIdentifier=$(SharedFxRestoreRid)</CommonSharedFxProps>
-      <CommonSharedFxProps>$(CommonSharedFxProps);DotNetRestoreSourcePropsPath=$(GeneratedRestoreSourcesPropsPath)</CommonSharedFxProps>
-      <CommonSharedFxProps>$(CommonSharedFxProps);DotNetBuildOffline=true</CommonSharedFxProps>
-      <CommonSharedFxProps>$(CommonSharedFxProps);AspNetUniverseBuildOffline=true</CommonSharedFxProps>
-    </PropertyGroup>
-  </Target>
-
-  <Target Name="_PrepareForSharedFx" DependsOnTargets="DefineSharedFxPrerequisites">
-    <PropertyGroup>
-      <RestoreProps>$(CommonSharedFxProps)</RestoreProps>
-      <RestoreProps>$(RestoreProps);SharedFxPackage=$(SharedFxPackage)</RestoreProps>
-      <RestoreProps>$(RestoreProps);SharedFxPackageVersion=$(PackageVersion)</RestoreProps>
-      <RestoreProps>$(RestoreProps);SharedFxBase=$(SharedFxBase)</RestoreProps>
-      <RestoreProps>$(RestoreProps);SharedFxBaseVersion=$(SharedFxBaseVersion)</RestoreProps>
-    </PropertyGroup>
-
-    <!-- Copy to working dir -->
-    <ItemGroup>
-      <SharedFxFiles Include="$(_TemplatesDir)SharedFx\**\*" />
-    </ItemGroup>
-
-    <Copy SourceFiles="@(SharedFxFiles)" DestinationFolder="$(SharedFxWorkDirectory)\%(RecursiveDir)" />
-
-    <!-- Set _Target=Restore so the project will be re-evaluated to include Internal.AspNetCore.Sdk MSBuild properties on the next step. -->
-    <MSBuild Projects="$(SharedFxWorkDirectory)SharedFx.csproj"
-      Targets="Restore"
-      Properties="$(RestoreProps);_Target=Restore;RestoreForce=true" />
-  </Target>
-
-  <Target Name="PrepareForSharedFx" DependsOnTargets="DefineSharedFxPrerequisites;ResolveCommitHash">
-    <PropertyGroup>
-      <AppSharedFxProps>RepositoryCommit=$(RepositoryCommit);SharedFxWorkDirectory=$(AppSharedFxWorkDirectory)</AppSharedFxProps>
-      <AppSharedFxProps>$(AppSharedFxProps);RuntimeFrameworkVersion=$(MicrosoftNETCoreApp21PackageVersion)</AppSharedFxProps>
-      <AppSharedFxProps>$(AppSharedFxProps);SharedFxPackage=Microsoft.AspNetCore.App</AppSharedFxProps>
-      <AllSharedFxProps>RepositoryCommit=$(RepositoryCommit);SharedFxWorkDirectory=$(AllSharedFxWorkDirectory)</AllSharedFxProps>
-      <AllSharedFxProps>$(AllSharedFxProps);RuntimeFrameworkVersion=$(MicrosoftNETCoreApp21PackageVersion)</AllSharedFxProps>
-      <AllSharedFxProps>$(AllSharedFxProps);SharedFxPackage=Microsoft.AspNetCore.All</AllSharedFxProps>
-      <AllSharedFxProps>$(AllSharedFxProps);SharedFxDep=Microsoft.AspNetCore.App</AllSharedFxProps>
-      <AllSharedFxProps>$(AllSharedFxProps);SharedFxDepVersion=$(PackageVersion)</AllSharedFxProps>
-    </PropertyGroup>
-
-    <!-- Clear working directory -->
-    <!-- <RemoveDir Directories="$(_WorkRoot)" /> -->
-
-    <Copy SourceFiles="$(_MetapackageSrcRoot)Directory.Build.props" DestinationFolder="$(_WorkRoot)" />
-
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_PrepareForSharedFx" Properties="$(AppSharedFxProps)" />
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_PrepareForSharedFx" Properties="$(AllSharedFxProps)" />
-  </Target>
-
-  <Target Name="_ResolveSharedFxFiles" DependsOnTargets="DefineSharedFxPrerequisites">
-    <ItemGroup>
-      <VersionLines Include="$(RepositoryCommit)" />
-      <VersionLines Include="$(PackageVersion)" />
-    </ItemGroup>
-
-    <!-- Publish -->
-    <MSBuild Projects="$(SharedFxWorkDirectory)SharedFx.csproj"
-      Targets="Publish"
-      Properties="$(CommonSharedFxProps);GenerateRuntimeConfigurationFiles=true;SelfContained=false;PublishDir=$(SharedFxPublishDirectory)" />
-
-    <!-- Clean deps.json -->
-    <RepoTasks.TrimDeps DepsFiles="$(SharedFxPublishDirectory)/SharedFx.deps.json" />
-
-    <!-- Clean up artifacts that publish generates which we don't need -->
-    <ItemGroup>
-      <ToDelete Include="$(SharedFxPublishDirectory)\SharedFx" />
-      <ToDelete Include="$(SharedFxPublishDirectory)\SharedFx.dll" />
-      <ToDelete Include="$(SharedFxPublishDirectory)\SharedFx.pdb" />
-    </ItemGroup>
-
-    <Delete Files="@(ToDelete)" />
-
-    <!-- Rename deps file -->
-    <Move SourceFiles="$(SharedFxPublishDirectory)\SharedFx.deps.json"
-      DestinationFiles="$(SharedFxPublishDirectory)\$(SharedFxPackage).deps.json" />
-
-    <!-- Rename runtimeconfig.json file -->
-    <Move SourceFiles="$(SharedFxPublishDirectory)\SharedFx.runtimeconfig.json"
-      DestinationFiles="$(SharedFxPublishDirectory)\$(SharedFxPackage).runtimeconfig.json" />
-
-    <!-- Generate Runtime Graph -->
-    <PropertyGroup>
-      <RuntimeGraphGeneratorRuntime Condition="$([MSBuild]::IsOSPlatform('Windows'))">win</RuntimeGraphGeneratorRuntime>
-      <RuntimeGraphGeneratorRuntime Condition="$([MSBuild]::IsOSPlatform('Linux'))">linux</RuntimeGraphGeneratorRuntime>
-      <RuntimeGraphGeneratorRuntime Condition="$([MSBuild]::IsOSPlatform('OSX'))">osx</RuntimeGraphGeneratorRuntime>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <SharedFxAssetsFile Include="$(SharedFxWorkDirectory)**\project.assets.json" />
-    </ItemGroup>
-
-    <ProcessSharedFrameworkDeps
-      AssetsFilePath="@(SharedFxAssetsFile)"
-      DepsFilePath="$(SharedFxPublishDirectory)\$(SharedFxPackage).deps.json"
-      Runtime="$(RuntimeGraphGeneratorRuntime)" />
-
-    <!-- Generate .version file -->
-    <WriteLinesToFile
-      File="$(SharedFxPublishDirectory)\.version"
-      Lines="@(VersionLines)"
-      Overwrite="true" />
-  </Target>
-
-  <Target Name="ResolveSharedFxFiles" DependsOnTargets="PrepareForSharedFx">
-    <PropertyGroup>
-      <AppSharedFxProps>SharedFxPackage=Microsoft.AspNetCore.App</AppSharedFxProps>
-      <AppSharedFxProps>$(AppSharedFxProps);SharedFxWorkDirectory=$(AppSharedFxWorkDirectory)</AppSharedFxProps>
-      <AppSharedFxProps>$(AppSharedFxProps);SharedFxPublishDirectory=$(AppSharedFxPublishDirectory)</AppSharedFxProps>
-      <AllSharedFxProps>SharedFxPackage=Microsoft.AspNetCore.All</AllSharedFxProps>
-      <AllSharedFxProps>$(AllSharedFxProps);SharedFxWorkDirectory=$(AllSharedFxWorkDirectory)</AllSharedFxProps>
-      <AllSharedFxProps>$(AllSharedFxProps);SharedFxPublishDirectory=$(AllSharedFxPublishDirectory)</AllSharedFxProps>
-    </PropertyGroup>
-
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_ResolveSharedFxFiles" Properties="$(AppSharedFxProps)" />
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_ResolveSharedFxFiles" Properties="$(AllSharedFxProps)" />
-
-    <MakeDir Directories="$(SharedFxOutputPath)" />
-  </Target>
-
-  <Target Name="PrepareForCrossGen" DependsOnTargets="PrepareForSharedFx;ResolveSharedFxFiles">
-    <PropertyGroup>
-      <RuntimePackageName>Microsoft.NETCore.App</RuntimePackageName>
-      <CrossGenTool>crossgen</CrossGenTool>
-      <CrossGenTool Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(CrossGenTool).exe</CrossGenTool>
-    </PropertyGroup>
-
-    <!-- Determine runtime location (via .App shared framework) -->
-    <MSBuild Projects="$(AppSharedFxWorkDirectory)SharedFx.csproj" Targets="GetPackageDefinitions" >
-      <Output TaskParameter="TargetOutputs" ItemName="PackageDefinitions" />
-    </MSBuild>
-
-    <ItemGroup>
-      <RuntimePackage Include="@(PackageDefinitions)" Condition="$([System.String]::new('%(PackageDefinitions.Name)').Contains('runtime')) AND $([System.String]::new('%(PackageDefinitions.Name)').Contains('$(RuntimePackageName)'))" />
-      <RuntimePackageFiles Include="%(RuntimePackage.ResolvedPath)\runtimes\**\*" />
-      <CrossGenToolFile Include="%(RuntimePackage.ResolvedPath)\**\$(CrossGenTool)" />
-    </ItemGroup>
-
-    <Error Text="Could not identify the runtime package for $(SharedFXRid)" Condition="@(RuntimePackage->Count()) == 0" />
-
-    <!-- Create tool directory with crossgen executable and runtime assemblies -->
-    <Copy SourceFiles="@(RuntimePackageFiles);@(CrossGenToolFile)" DestinationFolder="$(SharedFxCrossGenToolDirectory)"/>
-
-    <ItemGroup>
-      <ClrJitAssembly Include="$(SharedFxCrossGenToolDirectory)\**\$(LibPrefix)clrjit$(LibExtension)" />
-    </ItemGroup>
-
-    <Error Text="Expected to resolve a single runtime package but instead resolved @(RuntimePackage->Count()) with identities %(RuntimePackage.Identity)" Condition="'@(RuntimePackage->Count())' != 1" />
-    <Error Text="Could not find crossgen in %(RuntimePackage.ResolvedPath)" Condition="@(CrossGenToolFile->Count()) == 0" />
-    <Error Text="Expected to resolve a single clr jit assembly but instead resolved @(ClrJitAssembly->Count()) with identities %(ClrJitAssembly.Identity)" Condition="'@(ClrJitAssembly->Count())' != 1" />
-
-    <!-- Gather details on published assemblies -->
-    <MSBuild Projects="$(AppSharedFxWorkDirectory)SharedFx.csproj"
-      Targets="GetPublishAssemblies"
-      Properties="RuntimeIdentifier=$(SharedFxRestoreRid);SelfContained=false" >
-      <Output TaskParameter="TargetOutputs" ItemName="AppPublishAssemblies" />
-    </MSBuild>
-    <MSBuild Projects="$(AllSharedFxWorkDirectory)SharedFx.csproj"
-      Targets="GetPublishAssemblies"
-      Properties="RuntimeIdentifier=$(SharedFxRestoreRid);SelfContained=false" >
-      <Output TaskParameter="TargetOutputs" ItemName="AllPublishAssemblies" />
-    </MSBuild>
-
-    <ItemGroup>
-      <IgnoredAssemblies Include="@(AppPublishAssemblies);@(AllPublishAssemblies)" Condition="'%(AssetType)' == 'native' OR '%(AssetType)' == 'resources'" />
-      <_AppRuntimeAssemblies Include="@(AppPublishAssemblies)" Condition="'%(AssetType)' == 'runtime'">
-        <SymbolsPackageFilename>%(PackageName).%(PackageVersion).symbols.nupkg</SymbolsPackageFilename>
-        <PortablePDB>%(RootDir)%(Directory)%(Filename).pdb</PortablePDB>
-      </_AppRuntimeAssemblies>
-      <_AllRuntimeAssemblies Include="@(AllPublishAssemblies)" Exclude="@(_AppRuntimeAssemblies)" Condition="'%(AssetType)' == 'runtime'">
-        <SymbolsPackageFilename>%(PackageName).%(PackageVersion).symbols.nupkg</SymbolsPackageFilename>
-        <PortablePDB>%(RootDir)%(Directory)%(Filename).pdb</PortablePDB>
-      </_AllRuntimeAssemblies>
-      <OtherAssemblies Include="@(AppPublishAssemblies);@(AllPublishAssemblies)" Exclude="@(IgnoredAssemblies);@(_AppRuntimeAssemblies);@(_AllRuntimeAssemblies)" />
-      <_AssembliesToCrossgen Include="$(SharedFxIntermediateOutputPath)**\*.dll" />
-    </ItemGroup>
-
-    <RepoTasks.ResolveSymbolsRecursivePath Symbols="@(_AppRuntimeAssemblies)">
-      <Output TaskParameter="Symbols" ItemName="AppRuntimeAssemblies" />
-    </RepoTasks.ResolveSymbolsRecursivePath>
-    <RepoTasks.ResolveSymbolsRecursivePath Symbols="@(_AllRuntimeAssemblies)">
-      <Output TaskParameter="Symbols" ItemName="AllRuntimeAssemblies" />
-    </RepoTasks.ResolveSymbolsRecursivePath>
-
-    <Error Text="Unaccounted shared framework assemblies found: @(OtherAssemblies). Assemblies must be included as runtime assemblies or marked as ignored." Condition="'@(OtherAssemblies)' != ''" />
-
-    <!-- Compute the intersection of crossgen candidates and native/resources assemblies as the set of assemblies to skip crossgen -->
-    <CreateItem Include="@(_AssembliesToCrossgen)" Condition="'%(Filename)' != ''and '@(IgnoredAssemblies)' != ''">
-      <Output TaskParameter="Include" ItemName="AssembliesToRemove"/>
-    </CreateItem>
-
-    <!-- Resolve list of assemblies to crossgen -->
-    <ItemGroup>
-      <AssembliesToCrossgen Include="@(_AssembliesToCrossgen)">
-        <Source>%(FullPath)</Source>
-        <Rsp>$(SharedFxCrossGenRspDirectory)%(RecursiveDir)%(Filename).rsp</Rsp>
-        <SymbolsRsp>$(SharedFxCrossGenRspDirectory)%(RecursiveDir)%(Filename).symbols.rsp</SymbolsRsp>
-        <Destination>$(SharedFxCrossGenDirectory)%(RecursiveDir)%(Filename)%(Extension)</Destination>
-        <Symbols>$(SharedFxCrossGenDirectory)%(RecursiveDir)</Symbols>
-      </AssembliesToCrossgen>
-      <AssembliesToCrossgen Remove="@(AssembliesToRemove)" />
-    </ItemGroup>
-
-    <!-- Compute the intersection of runtime assemblies and assemblies to crossgen to resolve the set of portablePDBs to publish -->
-    <CreateItem Include="@(AppRuntimeAssemblies)" Condition="'%(Filename)' != ''and '@(AssembliesToCrossgen)' != ''">
-      <Output TaskParameter="Include" ItemName="AppPortablePDBsToPublish"/>
-    </CreateItem>
-    <CreateItem Include="@(AllRuntimeAssemblies)" Condition="'%(Filename)' != ''and '@(AssembliesToCrossgen)' != ''">
-      <Output TaskParameter="Include" ItemName="AllPortablePDBsToPublish"/>
-    </CreateItem>
-  </Target>
-
-  <Target Name="CrossGenAssemblies"
-    DependsOnTargets="PrepareForCrossGen"
-    Inputs="@(AssembliesToCrossgen)"
-    Outputs="%(AssembliesToCrossgen.Destination)">
-    <ItemGroup>
-      <CrossGenArgs Include="-nologo" />
-      <CrossGenArgs Include="-readytorun" />
-      <CrossGenArgs Include="-in %(AssembliesToCrossgen.Source)" />
-      <CrossGenArgs Include="-out %(AssembliesToCrossgen.Destination)" />
-      <CrossGenArgs Include="-platform_assemblies_paths $(SharedFxCrossGenToolDirectory)$(PathSeparator)$(AppSharedFxPublishDirectory)$(PathSeparator)$(AllSharedFxPublishDirectory)" />
-      <CrossGenArgs Include="-JITPath %(ClrJitAssembly.FullPath)" />
-    </ItemGroup>
-
-    <MakeDir Directories="$([System.IO.Path]::GetDirectoryName('%(AssembliesToCrossgen.Rsp)'))" />
-    <MakeDir Directories="$([System.IO.Path]::GetDirectoryName('%(AssembliesToCrossgen.Destination)'))" />
-    <WriteLinesToFile File="%(AssembliesToCrossgen.Rsp)" Lines="@(CrossGenArgs)" Overwrite="true" />
-
-    <Copy Condition="'$(CrossGenSharedFx)' == 'false'"
-          SourceFiles="%(AssembliesToCrossgen.Source)"
-          DestinationFiles="%(AssembliesToCrossgen.Destination)" />
-    <Exec Condition="'$(CrossGenSharedFx)' != 'false'"
-          Command="$(SharedFxCrossGenToolDirectory)$(CrossGenTool) @%(AssembliesToCrossgen.Rsp)"
-          EnvironmentVariables="COMPlus_PartialNGen=0" />
-  </Target>
-
-  <Target Name="CrossGenSymbols"
-    Condition=" '$(CrossGenSharedFxSymbols)' != 'false' "
-    DependsOnTargets="CrossGenAssemblies"
-    Inputs="@(AssembliesToCrossgen)"
-    Outputs="%(AssembliesToCrossgen.SymbolsRsp)">
-    <PropertyGroup>
-      <CrossGenSymbolsType>CreatePerfMap</CrossGenSymbolsType>
-      <CrossGenSymbolsType Condition="'$(OS)' == 'Windows_NT'">CreatePDB</CrossGenSymbolsType>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <CrossGenSymbolsArgs Include="-nologo" />
-      <CrossGenSymbolsArgs Include="-readytorun" />
-      <CrossGenSymbolsArgs Include="-platform_assemblies_paths $(SharedFxCrossGenToolDirectory)$(PathSeparator)$(AppSharedFxPublishDirectory)$(PathSeparator)$(AllSharedFxPublishDirectory)" />
-      <CrossGenSymbolsArgs Include="-$(CrossGenSymbolsType)" />
-      <CrossGenSymbolsArgs Include="%(AssembliesToCrossgen.Symbols)" />
-      <CrossGenSymbolsArgs Include="%(AssembliesToCrossgen.Destination)" />
-    </ItemGroup>
-
-    <MakeDir Directories="$([System.IO.Path]::GetDirectoryName('%(AssembliesToCrossgen.Symbols)'))" />
-    <WriteLinesToFile File="%(AssembliesToCrossgen.SymbolsRsp)" Lines="@(CrossGenSymbolsArgs)" Overwrite="true" />
-
-    <Exec Command="$(SharedFxCrossGenToolDirectory)$(CrossGenTool) @%(AssembliesToCrossgen.SymbolsRsp)" EnvironmentVariables="COMPlus_PartialNGen=0" />
-  </Target>
-
-  <Target Name="_BuildSharedFxSymbols">
-    <PropertyGroup>
-      <SymbolsPackageId>runtime.$(SharedFxRID).$(SymbolsNuspecIdSuffix)</SymbolsPackageId>
-    </PropertyGroup>
-
-    <!-- Create Layout -->
-    <Copy
-      SourceFiles="$(_TemplatesDir)SharedFxSymbols\SharedFrameworkSymbols.csproj"
-      DestinationFiles="$(SymbolsWorkDir)$(SymbolsPackageId).csproj"
-      OverwriteReadOnlyFiles="True" />
-
-    <!-- Produce symbols nupkg -->
-    <MSBuild Projects="$(SymbolsWorkDir)$(SymbolsPackageId).csproj"
-                Targets="Restore;Pack"
-                Properties="SymbolsWorkDir=$(SymbolsWorkDir);PackageId=$(SymbolsPackageId);PackageVersion=$(PackageVersion);PackageOutputPath=$(IntermediateDir);PackageDescription=$(Description)" />
-    <Copy
-      SourceFiles="$(IntermediateDir)$(SymbolsPackageId).$(PackageVersion).symbols.nupkg"
-      DestinationFolder="$([MSBuild]::NormalizeDirectory($(ArtifactsDir)))symbols\" />
-  </Target>
-
-  <Target Name="PackSharedFx" DependsOnTargets="DefineSharedFxPrerequisites" >
-    <PropertyGroup>
-      <AppSharedFxCrossgenDirectory>$(SharedFxCrossGenDirectory)shared\Microsoft.AspNetCore.App\$(PackageVersion)\</AppSharedFxCrossgenDirectory>
-      <AllSharedFxCrossgenDirectory>$(SharedFxCrossGenDirectory)shared\Microsoft.AspNetCore.All\$(PackageVersion)\</AllSharedFxCrossgenDirectory>
-      <AppSharedFxSymbolsDirectory>$(_WorkRoot)Symbols\Microsoft.AspNetCore.App\</AppSharedFxSymbolsDirectory>
-      <AllSharedFxSymbolsDirectory>$(_WorkRoot)Symbols\Microsoft.AspNetCore.All\</AllSharedFxSymbolsDirectory>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <AppCrossGenOutput Include="$(AppSharedFxCrossgenDirectory)**\*.dll" />
-      <AllCrossGenOutput Include="$(AllSharedFxCrossgenDirectory)**\*.dll" />
-      <AppCrossGenSymbols Include="$(AppSharedFxCrossgenDirectory)**\*" Exclude="@(AppCrossGenOutput)" />
-      <AllCrossGenSymbols Include="$(AllSharedFxCrossgenDirectory)**\*" Exclude="@(AllCrossGenOutput)" />
-    </ItemGroup>
-
-    <!-- Extract symbols package and copy over PDBs -->
-    <UnzipArchive
-      File="$(_SymbolsSourceDir)%(AppPortablePDBsToPublish.SymbolsPackageFilename)"
-      Destination="$(_WorkRoot)SymbolsPackages\%(AppPortablePDBsToPublish.SymbolsPackageFilename)"
-      Condition="Exists('$(_SymbolsSourceDir)%(AppPortablePDBsToPublish.SymbolsPackageFilename)')" />
-    <UnzipArchive
-      File="$(_SymbolsSourceDir)%(AllPortablePDBsToPublish.SymbolsPackageFilename)"
-      Destination="$(_WorkRoot)SymbolsPackages\%(AllPortablePDBsToPublish.SymbolsPackageFilename)"
-      Condition="Exists('$(_SymbolsSourceDir)%(AllPortablePDBsToPublish.SymbolsPackageFilename)')" />
-    <Copy
-      SourceFiles="$(_WorkRoot)SymbolsPackages\%(AppPortablePDBsToPublish.SymbolsPackageFilename)%(AppPortablePDBsToPublish.SymbolsRecursivePath)"
-      DestinationFolder="$(AppSharedFxSymbolsDirectory)runtimes\$(SharedFxRID)\lib\$(SharedFrameworkTargetFramework)"
-      OverwriteReadOnlyFiles="True"
-      Condition="Exists('$(_WorkRoot)SymbolsPackages\%(AppPortablePDBsToPublish.SymbolsPackageFilename)\%(AppPortablePDBsToPublish.SymbolsRecursivePath)')" />
-    <Copy
-      SourceFiles="$(_WorkRoot)SymbolsPackages\%(AllPortablePDBsToPublish.SymbolsPackageFilename)%(AllPortablePDBsToPublish.SymbolsRecursivePath)"
-      DestinationFolder="$(AllSharedFxSymbolsDirectory)runtimes\$(SharedFxRID)\lib\$(SharedFrameworkTargetFramework)"
-      OverwriteReadOnlyFiles="True"
-      Condition="Exists('$(_WorkRoot)SymbolsPackages\%(AllPortablePDBsToPublish.SymbolsPackageFilename)\%(AllPortablePDBsToPublish.SymbolsRecursivePath)')" />
-
-    <!-- Copy over DLLs and PDBs -->
-    <Copy
-      SourceFiles="%(AppPortablePDBsToPublish.PortablePDB)"
-      DestinationFolder="$(AppSharedFxSymbolsDirectory)runtimes\$(SharedFxRID)\lib\$(SharedFrameworkTargetFramework)"
-      OverwriteReadOnlyFiles="True"
-      Condition="Exists('%(AppPortablePDBsToPublish.PortablePDB)')" />
-    <Copy
-      SourceFiles="%(AllPortablePDBsToPublish.PortablePDB)"
-      DestinationFolder="$(AllSharedFxSymbolsDirectory)runtimes\$(SharedFxRID)\lib\$(SharedFrameworkTargetFramework)"
-      OverwriteReadOnlyFiles="True"
-      Condition="Exists('%(AllPortablePDBsToPublish.PortablePDB)')" />
-    <Copy
-      SourceFiles="@(AppCrossGenSymbols)"
-      DestinationFolder="$(AppSharedFxSymbolsDirectory)runtimes\$(SharedFxRID)\lib\$(SharedFrameworkTargetFramework)"
-      OverwriteReadOnlyFiles="True" />
-    <Copy
-      SourceFiles="@(AllCrossGenSymbols)"
-      DestinationFolder="$(AllSharedFxSymbolsDirectory)runtimes\$(SharedFxRID)\lib\$(SharedFrameworkTargetFramework)"
-      OverwriteReadOnlyFiles="True" />
-    <Copy
-      SourceFiles="$(AppSharedFxCrossgenDirectory)%(AppCrossGenOutput.RecursiveDir)%(AppCrossGenOutput.FileName)%(AppCrossGenOutput.Extension)"
-      DestinationFolder="$(AppSharedFxSymbolsDirectory)runtimes\$(SharedFxRID)\lib\$(SharedFrameworkTargetFramework)"
-      OverwriteReadOnlyFiles="True" />
-    <Copy
-      SourceFiles="$(AllSharedFxCrossgenDirectory)%(AllCrossGenOutput.RecursiveDir)%(AllCrossGenOutput.FileName)%(AllCrossGenOutput.Extension)"
-      DestinationFolder="$(AllSharedFxSymbolsDirectory)runtimes\$(SharedFxRID)\lib\$(SharedFrameworkTargetFramework)"
-      OverwriteReadOnlyFiles="True" />
-
-    <!-- Create symbols nupkg -->
-    <PropertyGroup>
-      <AppSymbolsArguments>SymbolsWorkDir=$(AppSharedFxSymbolsDirectory)</AppSymbolsArguments>
-      <AppSymbolsArguments>$(AppSymbolsArguments);SymbolsNuspecIdSuffix=Microsoft.AspNetCore.App</AppSymbolsArguments>
-      <AppSymbolsArguments>$(AppSymbolsArguments);Description=Symbol packages for Microsoft.AspNetCore.App shared framework</AppSymbolsArguments>
-      <AllSymbolsArguments>SymbolsWorkDir=$(AllSharedFxSymbolsDirectory)</AllSymbolsArguments>
-      <AllSymbolsArguments>$(AllSymbolsArguments);SymbolsNuspecIdSuffix=Microsoft.AspNetCore.All</AllSymbolsArguments>
-      <AllSymbolsArguments>$(AllSymbolsArguments);Description=Symbol packages for Microsoft.AspNetCore.All shared framework</AllSymbolsArguments>
-    </PropertyGroup>
-
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_BuildSharedFxSymbols" Properties="$(AppSymbolsArguments)" />
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_BuildSharedFxSymbols" Properties="$(AllSymbolsArguments)" />
-
-    <!-- Replace assemblies with crossgen output -->
-    <Copy
-      SourceFiles="$(AppSharedFxCrossgenDirectory)%(AppCrossGenOutput.RecursiveDir)%(AppCrossGenOutput.FileName)%(AppCrossGenOutput.Extension)"
-      DestinationFiles="$(AppSharedFxPublishDirectory)%(AppCrossGenOutput.RecursiveDir)%(AppCrossGenOutput.FileName)%(AppCrossGenOutput.Extension)"
-      OverwriteReadOnlyFiles="True" />
-    <Copy
-      SourceFiles="$(AllSharedFxCrossgenDirectory)%(AllCrossGenOutput.RecursiveDir)%(AllCrossGenOutput.FileName)%(AllCrossGenOutput.Extension)"
-      DestinationFiles="$(AllSharedFxPublishDirectory)%(AllCrossGenOutput.RecursiveDir)%(AllCrossGenOutput.FileName)%(AllCrossGenOutput.Extension)"
-      OverwriteReadOnlyFiles="True" />
-
-    <ItemGroup>
-      <OutputZipFiles Include="$(SharedFxIntermediateOutputPath)**\*" />
-    </ItemGroup>
-
-    <!-- Create internal archive file -->
-    <Exec Condition="'$(ArchiveExtension)' == '.tar.gz'"
-      Command="tar -czf $(SharedFxOutputPath)$(SharedFxIntermediateArchiveBaseName)-$(PackageVersion)-$(SharedFxRID)$(ArchiveExtension) -C $(SharedFxIntermediateOutputPath) ." />
-    <ZipArchive Condition="'$(ArchiveExtension)' == '.zip'"
-      File="$(SharedFxOutputPath)$(SharedFxIntermediateArchiveBaseName)-$(PackageVersion)-$(SharedFxRID).zip"
-      SourceFiles="@(OutputZipFiles)"
-      WorkingDirectory="$(SharedFxIntermediateOutputPath)"
-      Overwrite="true"/>
-  </Target>
-
-  <Target Name="BuildSharedFx" DependsOnTargets="GeneratePropsFiles;ResolveSharedFxFiles;CrossGenAssemblies;CrossGenSymbols;PackSharedFx;TestSharedFx"/>
-
-
-  <Target Name="TestSharedFx" DependsOnTargets="GeneratePropsFiles;DefineSharedFxPrerequisites;ResolveCommitHash;InstallDotNet">
-    <PropertyGroup>
-      <UnitTestFxProject>$(RepositoryRoot)\test\SharedFx.UnitTests\SharedFx.UnitTests.csproj</UnitTestFxProject>
-
-      <!-- The file path to the log file, from within the container -->
-      <UnitTestFxTrxLogFile>$(LogOutputDir)SharedFx-UnitTests-$(Version).trx</UnitTestFxTrxLogFile>
-      <!-- The trx file path from the perspective of the TeamCity agent -->
-      <UnitTestFxTrxPhysicalFilePath>$(UnitTestFxTrxLogFile)</UnitTestFxTrxPhysicalFilePath>
-      <UnitTestFxTrxPhysicalFilePath Condition="'$(HostMachineRepositoryRoot)' != ''">$(HostMachineRepositoryRoot)/artifacts/logs/SharedFx-UnitTests.trx</UnitTestFxTrxPhysicalFilePath>
-
-      <UnitTestFxTestProps>
-        DotNetRestoreSourcePropsPath=$(GeneratedRestoreSourcesPropsPath);
-        DotNetPackageVersionPropsPath=$(GeneratedPackageVersionPropsPath);
-        SharedFxOutputPath=$(SharedFxIntermediateOutputPath);
-        RepositoryCommit=$(RepositoryCommit);
-        VSTestLogger=$([MSBuild]::Escape('trx;LogFileName=$(UnitTestFxTrxLogFile)'));
-        SharedFxRuntimeIdentifier=$(SharedFXRid)
-      </UnitTestFxTestProps>
-    </PropertyGroup>
-    <MSBuild Projects="$(UnitTestFxProject)" Targets="Restore" Properties="_Dummy=restore;$(UnitTestFxTestProps)" />
-    <MSBuild Projects="$(UnitTestFxProject)" Targets="Build" Properties="$(UnitTestFxTestProps)">
-      <Output TaskParameter="TargetOutputs" ItemName="SharedFxTestAssembly" />
-    </MSBuild>
-    <RunDotNet Arguments="vstest;
-      --Framework:%(TargetFrameworkIdentifier),Version=v%(TargetFrameworkVersion);
-      --Logger:$([MSBuild]::Escape('trx;LogFileName=$(UnitTestFxTrxLogFile)'));
-      %(SharedFxTestAssembly.Identity);
-      --;RunConfiguration.NoAutoReporters=true" IgnoreExitCode="true">
-      <Output TaskParameter="ExitCode" PropertyName="VsTestExitCode" />
-    </RunDotNet>
-
-    <Message Text="##teamcity[importData type='vstest' path='$(UnitTestFxTrxPhysicalFilePath)']"
-      Importance="High"
-      Condition="'$(TEAMCITY_VERSION)' != '' AND Exists('$(UnitTestFxTrxLogFile)')" />
-    <Error Text="SharedFx.UnitTests failed with exit code '$(VsTestExitCode)'." Condition=" $(VsTestExitCode) != 0 " />
-  </Target>
-
-</Project>
--- a/build/SharedFxInstaller.targets
+++ b/build/SharedFxInstaller.targets
@ -1,251 +0,0 @@
-<Project>
-  <Target Name="BuildInstallers" DependsOnTargets="GenerateCumulativeArchives;GenerateRpms;GenerateDebs" />
-
-  <Target Name="_EnsureInstallerPrerequisites">
-    <MakeDir Directories="$(_InstallersOutputDir)" />
-
-    <!-- Check Docker server OS -->
-    <Exec Command="docker version -f &quot;{{.Server.Os}}&quot;" StandardOutputImportance="Normal" ConsoleToMSBuild="true">
-      <Output TaskParameter="ConsoleOutput" PropertyName="DockerHostOS" />
-    </Exec>
-
-    <Error
-      Text="Docker host must be using Linux containers."
-      Condition="'$(DockerHostOS)' != 'linux'"/>
-    <Error
-      Text="Expected archive missing at $(SharedFxIntermediateArchiveFilePrefix)-%(WindowsSharedFxRIDs.Identity).zip."
-      Condition="!Exists('$(SharedFxIntermediateArchiveFilePrefix)-%(WindowsSharedFxRIDs.Identity).zip')" />
-    <Error
-      Text="Expected archive missing at $(SharedFxIntermediateArchiveFilePrefix)-%(NonWindowsSharedFxRIDs.Identity).tar.gz."
-      Condition="!Exists('$(SharedFxIntermediateArchiveFilePrefix)-%(NonWindowsSharedFxRIDs.Identity).tar.gz')" />
-  </Target>
-
-  <Target Name="_DownloadInstallers">
-    <!-- Download dotnet installers -->
-    <MakeDir Directories="$(_InstallerSourceDir)" />
-    <KoreBuild.Tasks.DownloadFile
-      Uri="$(RuntimeArchiveLinkPrefix)-%(WindowsSharedFxRIDs.Identity).zip$(DotNetAssetRootAccessTokenSuffix)"
-      DestinationPath="$(_InstallerSourceDir)$(DotnetRuntimeFileNamePrefix)-%(WindowsSharedFxRIDs.Identity).zip"
-      Condition="!Exists('$(_InstallerSourceDir)$(DotnetRuntimeFileNamePrefix)-%(WindowsSharedFxRIDs.Identity).zip')" />
-    <KoreBuild.Tasks.DownloadFile
-      Uri="$(RuntimeArchiveLinkPrefix)-%(NonWindowsSharedFxRIDs.Identity).tar.gz$(DotNetAssetRootAccessTokenSuffix)"
-      DestinationPath="$(_InstallerSourceDir)$(DotnetRuntimeFileNamePrefix)-%(NonWindowsSharedFxRIDs.Identity).tar.gz"
-      Condition="!Exists('$(_InstallerSourceDir)$(DotnetRuntimeFileNamePrefix)-%(NonWindowsSharedFxRIDs.Identity).tar.gz')" />
-  </Target>
-
-  <Target Name="_GenerateCumulativeArchive">
-    <PropertyGroup>
-      <ArchiveExtension>.tar.gz</ArchiveExtension>
-      <ArchiveExtension Condition="$(SharedFxPlatform.StartsWith('win'))">.zip</ArchiveExtension>
-    </PropertyGroup>
-
-    <!-- Clear working directory -->
-    <RemoveDir Directories="$(_WorkRoot)" />
-    <MakeDir Directories="$(_WorkRoot)" />
-
-    <!-- Create layout: Aspnet Runtime  -->
-    <Exec
-      Command="tar -xzf $(SharedFxIntermediateArchiveFilePrefix)-$(SharedFxPlatform)$(ArchiveExtension) -C $(_WorkRoot)"
-      Condition="'$(ArchiveExtension)' == '.tar.gz'"/>
-    <Exec
-      Command="tar -xzf $(_InstallerSourceDir)$(DotnetRuntimeFileNamePrefix)-$(SharedFxPlatform)$(ArchiveExtension) -C $(_WorkRoot)"
-      Condition="'$(ArchiveExtension)' == '.tar.gz'"/>
-    <UnzipArchive
-      File="$(SharedFxIntermediateArchiveFilePrefix)-$(SharedFxPlatform)$(ArchiveExtension)"
-      Destination="$(_WorkRoot)"
-      Condition="'$(ArchiveExtension)' == '.zip'" />
-    <UnzipArchive
-      File="$(_InstallerSourceDir)$(DotnetRuntimeFileNamePrefix)-$(SharedFxPlatform)$(ArchiveExtension)"
-      Destination="$(_WorkRoot)"
-      Condition="'$(ArchiveExtension)' == '.zip'" />
-
-    <ItemGroup>
-      <SharedFxArchiveFiles Include="$(_WorkRoot)**\*" />
-    </ItemGroup>
-
-    <!-- Create Aspnet Runtime archive -->
-    <Exec
-      Command="tar -czf $(_InstallersOutputDir)$(SharedFxInstallerName)-$(PackageVersion)-$(SharedFxPlatform)$(ArchiveExtension) -C $(_WorkRoot) ."
-      Condition="'$(ArchiveExtension)' == '.tar.gz'"/>
-    <ZipArchive
-      File="$(_InstallersOutputDir)$(SharedFxInstallerName)-$(PackageVersion)-$(SharedFxPlatform)$(ArchiveExtension)"
-      SourceFiles="@(SharedFxArchiveFiles)"
-      WorkingDirectory="$(_WorkRoot)"
-      Overwrite="true"
-      Condition="'$(ArchiveExtension)' == '.zip'"/>
-  </Target>
-
-  <Target Name="GenerateCumulativeArchives" DependsOnTargets="_EnsureInstallerPrerequisites;_DownloadInstallers">
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_GenerateCumulativeArchive" Properties="SharedFxPlatform=%(AllSharedFxRIDs.Identity)" />
-  </Target>
-
-  <Target Name="_BuildDockerImage">
-    <Exec Command="docker build --build-arg USER_ID=%24(id -u) -t docker-image-$(Image) $(Image)" WorkingDirectory="$(_DockerDir)" />
-  </Target>
-
-  <Target Name="_RemoveDockerImage">
-    <Exec Command="docker rmi docker-image-$(Image)" />
-  </Target>
-
-  <Target Name="_GenerateRpm">
-    <!-- Clear working directory -->
-    <RemoveDir Directories="$(_WorkRoot)" />
-    <MakeDir Directories="$(_WorkRoot)" />
-
-    <!-- Create layout: Extract archive if given -->
-    <MakeDir Directories="$(_WorkRoot)package_root\" />
-    <Exec Command="tar -xzf $(SharedFxArchive) -C $(_WorkRoot)package_root\" Condition="'$(SharedFxArchive)'!=''" />
-
-    <!-- Create layout: Create changelog -->
-    <PropertyGroup>
-      <ChangeLogProps>DATE=$([System.DateTime]::UtcNow.ToString(ddd MMM dd yyyy))</ChangeLogProps>
-      <ChangeLogProps>$(ChangeLogProps);MAINTAINER_NAME=$(RpmMaintainerName)</ChangeLogProps>
-      <ChangeLogProps>$(ChangeLogProps);MAINTAINER_EMAIL=$(RpmMaintainerEmail)</ChangeLogProps>
-      <ChangeLogProps>$(ChangeLogProps);PACKAGE_VERSION=$(RpmPackageVersion)</ChangeLogProps>
-      <ChangeLogProps>$(ChangeLogProps);PACKAGE_REVISION=$(RpmRevision)</ChangeLogProps>
-    </PropertyGroup>
-
-    <GenerateFileFromTemplate TemplateFile="$(_PackagingDir)changelog.in" OutputPath="$(_WorkRoot)templates/changelog" Properties="$(ChangeLogProps)" />
-
-    <!-- Run fpm -->
-    <!-- Retry added due to fpm/docker race where .w/package_root directory cannot be resolved -->
-    <Run
-      FileName="docker"
-      Command="run --rm -v $(RepositoryRoot):$(_DockerRootDir) docker-image-$(Image) fpm --verbose -s dir -t rpm -n $(RpmName)-$(RpmIdVersion) -p $(_DockerRootDir)artifacts/installers/$(RpmName)-$(RpmFileVersion)-$(RpmFileSuffix) -v $(RpmPackageVersion) --iteration $(RpmRevision) -a amd64 $(RpmArguments) --rpm-changelog $(_DockerRootDir).w/templates/changelog --rpm-summary &quot;$(RpmMSummary)&quot; --description &quot;$(RpmDescription)&quot; --maintainer &quot;$(RpmMaintainerName) &lt;$(RpmMaintainerEmail)&gt;&quot; --vendor &quot;$(RpmVendor)&quot; --license &quot;$(RpmLicense)&quot; --url &quot;$(RpmHomepage)&quot; $(_DockerRootDir).w/package_root/=&quot;$(RpmInstallRoot)/&quot;"
-      MaxRetries="5"/>
-  </Target>
-
-  <Target Name="GenerateRpms" DependsOnTargets="_EnsureInstallerPrerequisites">
-     <PropertyGroup>
-      <Image>rhel.7</Image>
-      <RpmVendor>.NET Foundation</RpmVendor>
-      <RHInstallRoot>/opt/rh/rh-dotnet20/root/usr/lib64/dotnet</RHInstallRoot>
-      <Rpm_DotnetRuntimeDependencyId>dotnet-runtime-$(AspNetCoreMajorVersion).$(AspNetCoreMinorVersion)</Rpm_DotnetRuntimeDependencyId>
-      <Rpm_DotnetRuntimeDependencyVersion>$(MicrosoftNETCoreAppPackageVersion.Split('-')[0])</Rpm_DotnetRuntimeDependencyVersion>
-    </PropertyGroup>
-
-    <!-- Build Docker Image -->
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_BuildDockerImage" Properties="Image=$(Image)" />
-
-    <ItemGroup>
-      <RpmSharedFxDependencies Include="$(Rpm_DotnetRuntimeDependencyId)" Version="$(Rpm_DotnetRuntimeDependencyVersion)" />
-      <RpmRHSharedFxDirectories Include="$(RHInstallRoot)/shared" />
-      <RpmGenericSharedFxDirectories Include="$(InstallRoot)/shared" />
-    </ItemGroup>
-
-    <PropertyGroup>
-      <RpmSharedFxArguments>@(RpmSharedFxDependencies->' -d &quot;%(Identity) &gt;= %(Version)&quot;', ' ')</RpmSharedFxArguments>
-      <RpmRHSharedFxArguments>$(RpmSharedFxArguments) @(RpmRHSharedFxDirectories->' --directories &quot;%(FullPath)&quot;', ' ')</RpmRHSharedFxArguments>
-      <RpmGenericSharedFxArguments>$(RpmSharedFxArguments) @(RpmGenericSharedFxDirectories->' --directories &quot;%(FullPath)&quot;', ' ')</RpmGenericSharedFxArguments>
-
-      <RpmCommonProps>Image=$(Image);RpmVendor=$(RpmVendor);RpmName=$(SharedFxInstallerName)</RpmCommonProps>
-      <RpmCommonProps>$(RpmCommonProps);RpmMaintainerName=$(MaintainerName);RpmMaintainerEmail=$(MaintainerEmail)</RpmCommonProps>
-      <RpmCommonProps>$(RpmCommonProps);RpmHomepage=$(Homepage);RpmRevision=$(RpmPackageRevision)</RpmCommonProps>
-      <RpmCommonProps>$(RpmCommonProps);RpmLicense=$(LicenseType)</RpmCommonProps>
-      <RpmCommonProps>$(RpmCommonProps);SharedFxArchive=$(SharedFxIntermediateArchiveFilePrefix)-linux-x64.tar.gz</RpmCommonProps>
-      <RpmCommonProps>$(RpmCommonProps);RpmMSummary=$(SharedFxSummary);RpmDescription=$(SharedFxDescription)</RpmCommonProps>
-      <RpmGenericProps>RpmInstallRoot=$(InstallRoot)</RpmGenericProps>
-      <RpmRHProps>RpmInstallRoot=$(RHInstallRoot)</RpmRHProps>
-      <RpmProps>RpmIdVersion=$(InstallerIdVersion);RpmPackageVersion=$(InstallerPackageVersion);RpmFileVersion=$(PackageVersion)</RpmProps>
-
-      <RpmSharedFxProps>$(RpmCommonProps);$(RpmGenericProps);$(RpmProps);RpmArguments=$(RpmGenericSharedFxArguments);RpmFileSuffix=x64.rpm</RpmSharedFxProps>
-      <RpmRHSharedFxProps>$(RpmCommonProps);$(RpmRHProps);$(RpmProps);RpmArguments=$(RpmRHSharedFxArguments);RpmFileSuffix=rh.rhel.7-x64.rpm</RpmRHSharedFxProps>
-    </PropertyGroup>
-
-    <!-- Generic installer-->
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_GenerateRpm" Properties="$(RpmSharedFxProps)" />
-
-    <!-- RH installer-->
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_GenerateRpm" Properties="$(RpmRHSharedFxProps)" />
-
-    <!-- Remove Docker Image to save disk space -->
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_RemoveDockerImage" Properties="Image=$(Image)" />
-  </Target>
-
-  <Target Name="RunDebTool">
-    <PropertyGroup>
-      <BuildDebInstallerScript>$(RepositoryRoot)src/Installers/Debian/build.sh</BuildDebInstallerScript>
-    </PropertyGroup>
-
-    <!-- Build deb package -->
-    <Exec Command="$(BuildDebInstallerScript) -i $(_WorkLayoutDir) -o $(_WorkOutputDir) -n $(INSTALLER_NAME) -v $(INSTALLER_VERSION)" />
-  </Target>
-
-  <Target Name="_GenerateDeb">
-    <!-- Create layout: Clear work directory -->
-    <RemoveDir Directories="$(_WorkRoot)" />
-    <MakeDir Directories="$(_WorkRoot)" />
-
-    <!-- Create layout: Extract archive if given -->
-    <MakeDir Directories="$(_WorkLayoutDir)package_root\" />
-    <Exec Command="tar -xzf $(SharedFxArchive) -C $(_WorkLayoutDir)package_root/" Condition="'$(SharedFxArchive)'!=''" />
-
-    <!-- Create layout: Generate and Place debian_config.json -->
-    <PropertyGroup>
-      <DebConfigProps>MAINTAINER_NAME=$(MaintainerName)</DebConfigProps>
-      <DebConfigProps>$(DebConfigProps);MAINTAINER_EMAIL=$(MaintainerEmail)</DebConfigProps>
-      <DebConfigProps>$(DebConfigProps);HOMEPAGE=$(Homepage)</DebConfigProps>
-      <DebConfigProps>$(DebConfigProps);INSTALL_ROOT=$(InstallRoot)</DebConfigProps>
-      <DebConfigProps>$(DebConfigProps);PACKAGE_NAME=$(DebPrefix)</DebConfigProps>
-      <DebConfigProps>$(DebConfigProps);PACKAGE_REVISION=$(PackageRevision)</DebConfigProps>
-      <DebConfigProps>$(DebConfigProps);LICENSE_TYPE=$(LicenseType)</DebConfigProps>
-      <DebConfigProps>$(DebConfigProps);SHORT_DESCRIPTION=$(DebSummary)</DebConfigProps>
-      <DebConfigProps>$(DebConfigProps);LONG_DESCRIPTION=$(DebDescription)</DebConfigProps>
-      <DebConfigProps>$(DebConfigProps);DEBIAN_DEPENDENCIES=$(DebDependencies)</DebConfigProps>
-    </PropertyGroup>
-
-    <GenerateFileFromTemplate TemplateFile="$(DebConfigInFile)" OutputPath="$(_WorkLayoutDir)debian_config.json" Properties="$(DebConfigProps)" />
-
-    <!-- Build SharedFx Bundle Deb package -->
-
-    <Exec Command="docker run --rm -v $(RepositoryRoot):$(_DockerRootDir) -e DOTNET_SKIP_FIRST_TIME_EXPERIENCE=true -e INSTALLER_NAME=$(DebPrefix)-$(DebIdVersion) -e INSTALLER_VERSION=$(DebPackageVersion) docker-image-$(Image) ./build.sh /t:RunDebTool"
-      ContinueOnError="WarnAndContinue" />
-
-    <!-- Copy SharedFx packages to output -->
-    <ItemGroup>
-      <GeneratedDebFiles Include="$(_WorkOutputDir)/*.deb" />
-    </ItemGroup>
-
-    <Error Text="@(GeneratedDebFiles->Count()) deb installer files generated." Condition="'@(GeneratedDebFiles->Count())' != 1" />
-
-    <Copy
-      DestinationFiles="$(_InstallersOutputDir)$(DebPrefix)-$(DebFileVersion)-x64.deb"
-      SourceFiles="@(GeneratedDebFiles)"
-      OverwriteReadOnlyFiles="True"
-      SkipUnchangedFiles="False"
-      UseHardlinksIfPossible="False" />
-  </Target>
-
-  <Target Name="GenerateDebs" DependsOnTargets="_EnsureInstallerPrerequisites">
-    <PropertyGroup>
-      <Deb_DotnetRuntimeDependencyId>dotnet-runtime-$(AspNetCoreMajorVersion).$(AspNetCoreMinorVersion)</Deb_DotnetRuntimeDependencyId>
-      <Deb_DotnetRuntimeDependencyVersion>$(MicrosoftNETCoreAppPackageVersion)</Deb_DotnetRuntimeDependencyVersion>
-      <!-- Needed some creativity to convert the PackageVersion M.N.P-Build to the installer version M.N.P~Build, The conditional handles stabilized builds -->
-      <Deb_DotnetRuntimeDependencyVersion Condition="$(Deb_DotnetRuntimeDependencyVersion.Contains('-'))">$(Deb_DotnetRuntimeDependencyVersion.Substring(0, $(Deb_DotnetRuntimeDependencyVersion.IndexOf('-'))))~$(Deb_DotnetRuntimeDependencyVersion.Substring($([MSBuild]::Add($(Deb_DotnetRuntimeDependencyVersion.IndexOf('-')), 1))))</Deb_DotnetRuntimeDependencyVersion>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <_DebSharedFxDependencies Include="$(Deb_DotnetRuntimeDependencyId)" Version="$(Deb_DotnetRuntimeDependencyVersion)"/>
-    </ItemGroup>
-
-    <PropertyGroup>
-      <Image>ubuntu.14.04</Image>
-
-      <DebSharedFxDependencies>@(_DebSharedFxDependencies->'"%(Identity)": { "package_version": "%(Version)" }', ', ')</DebSharedFxDependencies>
-
-      <DebCommonProps>Image=$(Image);DebPrefix=$(SharedFxInstallerName)</DebCommonProps>
-      <DebCommonProps>$(DebCommonProps);DebSummary=$(SharedFxSummary);DebDescription=$(SharedFxDescription)</DebCommonProps>
-      <DebCommonProps>$(DebCommonProps);SharedFxArchive=$(SharedFxIntermediateArchiveFilePrefix)-linux-x64.tar.gz</DebCommonProps>
-
-      <DebProps>DebIdVersion=$(InstallerIdVersion);DebPackageVersion=$(DebInstallerPackageVersion);DebFileVersion=$(PackageVersion);DebDependencies=$(DebSharedFxDependencies)</DebProps>
-    </PropertyGroup>
-
-    <!-- Build Docker Image -->
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_BuildDockerImage" Properties="Image=$(Image)" />
-
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_GenerateDeb" Properties="$(DebCommonProps);$(DebProps)" />
-
-    <!-- Remove Docker Image to save disk space -->
-    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="_RemoveDockerImage" Properties="Image=$(Image)" />
-  </Target>
-</Project>
--- a/build/artifacts.props
+++ b/build/artifacts.props
@ -1,172 +0,0 @@
-<Project>
-
-  <ItemDefinitionGroup>
-    <PackageArtifact>
-      <!-- When true, this dependency will be included in the Microsoft.AspNetCore.App metapackage. -->
-      <AppMetapackage>false</AppMetapackage>
-      <!-- When true, this dependency will be included in the Microsoft.AspNetCore.All metapackage. -->
-      <AllMetapackage>false</AllMetapackage>
-      <!--
-      Other known package types:
-        Dependency = for packages that are installed via PackageReference
-        DotnetCliTool = for packages that are installed via DotNetCliToolReference
-      -->
-      <PackageType>Dependency</PackageType>
-    </PackageArtifact>
-  </ItemDefinitionGroup>
-
-  <ItemGroup>
-    <PackageArtifact Include="dotnet-dev-certs" Category="ship" />
-    <PackageArtifact Include="dotnet-ef" Category="ship" />
-    <PackageArtifact Include="dotnet-sql-cache" Category="ship" />
-    <PackageArtifact Include="dotnet-user-secrets" Category="ship" />
-    <PackageArtifact Include="dotnet-watch" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.All" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Antiforgery" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.App" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.ApplicationInsights.HostingStartup" AllMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.AspNetCoreModuleV1" Category="noship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.AzureAD.UI" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.AzureADB2C.UI" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.Cookies" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.Core" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.Facebook" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.Google" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.JwtBearer" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.MicrosoftAccount" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.OAuth" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.OpenIdConnect" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.Twitter" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication.WsFederation" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authentication" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authorization.Policy" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Authorization" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.AzureAppServices.SiteExtension.2.1" AllMetapackage="false" Category="noship" Condition="'$(BuildSiteExtension)' == 'true'" />
-    <PackageArtifact Include="Microsoft.AspNetCore.AzureAppServices.HostingStartup" AllMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.AzureAppServicesIntegration" AllMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Connections.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.CookiePolicy" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Cors" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Cryptography.Internal" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Cryptography.KeyDerivation" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.DataProtection.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.DataProtection.AzureKeyVault" AllMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.DataProtection.AzureStorage" AllMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.DataProtection.Extensions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.DataProtection.Redis" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.DataProtection.SystemWeb" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.DataProtection" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.DeveloperCertificates.XPlat" Category="shipoob" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Diagnostics.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Diagnostics" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.HostFiltering" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Hosting.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Hosting.Server.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Hosting.WindowsServices" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Hosting" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Html.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Http.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Http.Connections.Client" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Http.Connections.Common" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Http.Connections" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Http.Extensions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Http.Features" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Http" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.HttpOverrides" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.HttpsPolicy" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Identity.Specification.Tests" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Identity.UI" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Identity" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.JsonPatch" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Localization.Routing" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Localization" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.MiddlewareAnalysis" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.Analyzers" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.ApiExplorer" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.Core" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.Cors" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.DataAnnotations" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.Formatters.Json" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.Formatters.Xml" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.Localization" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X" Category="shipoob" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.Razor.Extensions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.Razor.ViewCompilation" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.Razor" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.RazorPages" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.TagHelpers" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.Testing" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.ViewFeatures" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc.WebApiCompatShim" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Mvc" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.NodeServices" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Owin" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Razor.Design" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Razor.Language" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Razor.Runtime" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Razor" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.ResponseCaching.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.ResponseCaching" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.ResponseCompression" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Rewrite" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Routing.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Routing" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Server.HttpSys" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Server.IISIntegration" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Server.Kestrel.Core" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Server.Kestrel.Https" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Server.Kestrel.Transport.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Server.Kestrel.Transport.Libuv" AllMetapackage="true" AppMetapackage="false" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Server.Kestrel" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.Session" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.SignalR.Client.Core" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.SignalR.Client" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.SignalR.Common" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.SignalR.Core" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.SignalR.Protocols.Json" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.SignalR.Protocols.MessagePack" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.SignalR.Redis" AllMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.SignalR" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.SpaServices.Extensions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.SpaServices" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.StaticFiles" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.TestHost" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.WebSockets" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore.WebUtilities" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.AspNetCore" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.CodeAnalysis.Razor" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.Data.Sqlite.Core" AllMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.Data.Sqlite" AllMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.DotNet.Web.Client.ItemTemplates" Category="ship" />
-    <PackageArtifact Include="Microsoft.DotNet.Web.ItemTemplates" Category="ship" />
-    <PackageArtifact Include="Microsoft.DotNet.Web.ProjectTemplates.2.1" Category="ship" />
-    <PackageArtifact Include="Microsoft.DotNet.Web.Spa.ProjectTemplates.2.1" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.Abstractions" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.Analyzers" Analyzer="true" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.Design" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.DocumentDb" Category="noship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.InMemory" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.Proxies" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.Relational.Specification.Tests" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.Relational" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.Specification.Tests" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.Sqlite.Core" AllMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.Sqlite" AllMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.SqlServer" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore.Tools" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.EntityFrameworkCore" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.Extensions.Identity.Core" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.Extensions.Identity.Stores" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.Net.Http.Headers" AllMetapackage="true" AppMetapackage="true" Category="ship" />
-    <PackageArtifact Include="Microsoft.NET.Sdk.Razor" Category="ship" />
-    <PackageArtifact Include="Microsoft.Owin.Security.Interop" Category="ship" />
-
-    <PackageArtifact Include="Microsoft.AspNetCore.Hosting.WebHostBuilderFactory.Sources" Category="noship"/>
-  </ItemGroup>
-
-</Project>
--- a/build/buildorder.props
+++ b/build/buildorder.props
@ -1,13 +0,0 @@
-<Project>
-  <ItemDefinitionGroup>
-    <RepositoryBuildOrder>
-      <Order></Order>
-      <RootPath></RootPath>
-    </RepositoryBuildOrder>
-  </ItemDefinitionGroup>
-
-  <ItemGroup>
-    <RepositoryBuildOrder Include="EntityFrameworkCore" Order="8" />
-    <RepositoryBuildOrder Include="Templating" Order="17" RootPath="$(RepositoryRoot)src\Templating\" />
-  </ItemGroup>
-</Project>
--- a/build/dependencies.props
+++ b/build/dependencies.props
@ -1,234 +0,0 @@
-<Project>
-  <!-- These package versions may be overridden or updated by automation. -->
-  <PropertyGroup Label="Package Versions: Auto" Condition=" '$(DotNetPackageVersionPropsPath)' == '' ">
-    <!-- MicrosoftNETCoreApp21PackageVersion is assigned at the bottom so it can automatically pick up MicrosoftNETCoreAppPackageVersion in an orchestrated build. -->
-    <MicrosoftNETCoreAppPackageVersion>2.1.12</MicrosoftNETCoreAppPackageVersion>
-    <MicrosoftNETCoreDotNetAppHostPackageVersion>2.1.12</MicrosoftNETCoreDotNetAppHostPackageVersion>
-  </PropertyGroup>
-
-  <Import Project="$(DotNetPackageVersionPropsPath)" Condition="'$(DotNetPackageVersionPropsPath)' != ''" />
-
-  <PropertyGroup>
-    <!-- Assign this variable last because it may be updated from DotNetPackageVersionPropsPath as MicrosoftNETCoreAppPackageVersion. -->
-    <MicrosoftNETCoreApp21PackageVersion Condition="'$(MicrosoftNETCoreAppPackageVersion)' != ''">$(MicrosoftNETCoreAppPackageVersion)</MicrosoftNETCoreApp21PackageVersion>
-
-    <!-- Determined by build tools -->
-    <InternalAspNetCoreSdkPackageVersion>$(KoreBuildVersion)</InternalAspNetCoreSdkPackageVersion>
-    <InternalAspNetCoreSiteExtensionSdkPackageVersion>$(KoreBuildVersion)</InternalAspNetCoreSiteExtensionSdkPackageVersion>
-    <InternalAspNetCoreSdkPackageVersion Condition=" '$(KoreBuildVersion)' == '' ">2.1.7-build-20190110.2</InternalAspNetCoreSdkPackageVersion>
-  </PropertyGroup>
-
-  <!-- These are package versions that should not be overridden or updated by automation. -->
-  <PropertyGroup Label="Package Versions: Pinned">
-    <!-- Packages that came from aspnet/Extensions. -->
-    <MicrosoftAspNetCoreBenchmarkRunnerSourcesPackageVersion>2.1.1</MicrosoftAspNetCoreBenchmarkRunnerSourcesPackageVersion>
-    <MicrosoftAspNetCoreTestingPackageVersion>2.1.0</MicrosoftAspNetCoreTestingPackageVersion>
-    <MicrosoftExtensionsActivatorUtilitiesSourcesPackageVersion>2.1.1</MicrosoftExtensionsActivatorUtilitiesSourcesPackageVersion>
-    <MicrosoftExtensionsCachingAbstractionsPackageVersion>2.1.2</MicrosoftExtensionsCachingAbstractionsPackageVersion>
-    <MicrosoftExtensionsCachingMemoryPackageVersion>2.1.2</MicrosoftExtensionsCachingMemoryPackageVersion>
-    <MicrosoftExtensionsCachingRedisPackageVersion>2.1.2</MicrosoftExtensionsCachingRedisPackageVersion>
-    <MicrosoftExtensionsCachingSqlServerPackageVersion>2.1.2</MicrosoftExtensionsCachingSqlServerPackageVersion>
-    <MicrosoftExtensionsCommandLineUtilsSourcesPackageVersion>2.1.1</MicrosoftExtensionsCommandLineUtilsSourcesPackageVersion>
-    <MicrosoftExtensionsConfigurationAbstractionsPackageVersion>2.1.1</MicrosoftExtensionsConfigurationAbstractionsPackageVersion>
-    <MicrosoftExtensionsConfigurationAzureKeyVaultPackageVersion>2.1.1</MicrosoftExtensionsConfigurationAzureKeyVaultPackageVersion>
-    <MicrosoftExtensionsConfigurationBinderPackageVersion>2.1.10</MicrosoftExtensionsConfigurationBinderPackageVersion>
-    <MicrosoftExtensionsConfigurationCommandLinePackageVersion>2.1.1</MicrosoftExtensionsConfigurationCommandLinePackageVersion>
-    <MicrosoftExtensionsConfigurationEnvironmentVariablesPackageVersion>2.1.1</MicrosoftExtensionsConfigurationEnvironmentVariablesPackageVersion>
-    <MicrosoftExtensionsConfigurationFileExtensionsPackageVersion>2.1.1</MicrosoftExtensionsConfigurationFileExtensionsPackageVersion>
-    <MicrosoftExtensionsConfigurationIniPackageVersion>2.1.1</MicrosoftExtensionsConfigurationIniPackageVersion>
-    <MicrosoftExtensionsConfigurationJsonPackageVersion>2.1.1</MicrosoftExtensionsConfigurationJsonPackageVersion>
-    <MicrosoftExtensionsConfigurationKeyPerFilePackageVersion>2.1.1</MicrosoftExtensionsConfigurationKeyPerFilePackageVersion>
-    <MicrosoftExtensionsConfigurationPackageVersion>2.1.1</MicrosoftExtensionsConfigurationPackageVersion>
-    <MicrosoftExtensionsConfigurationUserSecretsPackageVersion>2.1.1</MicrosoftExtensionsConfigurationUserSecretsPackageVersion>
-    <MicrosoftExtensionsConfigurationXmlPackageVersion>2.1.1</MicrosoftExtensionsConfigurationXmlPackageVersion>
-    <MicrosoftExtensionsDependencyInjectionAbstractionsPackageVersion>2.1.1</MicrosoftExtensionsDependencyInjectionAbstractionsPackageVersion>
-    <MicrosoftExtensionsDependencyInjectionPackageVersion>2.1.1</MicrosoftExtensionsDependencyInjectionPackageVersion>
-    <MicrosoftExtensionsDependencyInjectionSpecificationTestsPackageVersion>2.1.1</MicrosoftExtensionsDependencyInjectionSpecificationTestsPackageVersion>
-    <MicrosoftExtensionsDiagnosticAdapterPackageVersion>2.1.0</MicrosoftExtensionsDiagnosticAdapterPackageVersion>
-    <MicrosoftExtensionsFileProvidersAbstractionsPackageVersion>2.1.1</MicrosoftExtensionsFileProvidersAbstractionsPackageVersion>
-    <MicrosoftExtensionsFileProvidersCompositePackageVersion>2.1.1</MicrosoftExtensionsFileProvidersCompositePackageVersion>
-    <MicrosoftExtensionsFileProvidersEmbeddedPackageVersion>2.1.1</MicrosoftExtensionsFileProvidersEmbeddedPackageVersion>
-    <MicrosoftExtensionsFileProvidersPhysicalPackageVersion>2.1.1</MicrosoftExtensionsFileProvidersPhysicalPackageVersion>
-    <MicrosoftExtensionsFileSystemGlobbingPackageVersion>2.1.1</MicrosoftExtensionsFileSystemGlobbingPackageVersion>
-    <MicrosoftExtensionsHashCodeCombinerSourcesPackageVersion>2.1.1</MicrosoftExtensionsHashCodeCombinerSourcesPackageVersion>
-    <MicrosoftExtensionsHostingAbstractionsPackageVersion>2.1.1</MicrosoftExtensionsHostingAbstractionsPackageVersion>
-    <MicrosoftExtensionsHostingPackageVersion>2.1.1</MicrosoftExtensionsHostingPackageVersion>
-    <MicrosoftExtensionsHttpPackageVersion>2.1.1</MicrosoftExtensionsHttpPackageVersion>
-    <MicrosoftExtensionsLocalizationAbstractionsPackageVersion>2.1.1</MicrosoftExtensionsLocalizationAbstractionsPackageVersion>
-    <MicrosoftExtensionsLocalizationPackageVersion>2.1.1</MicrosoftExtensionsLocalizationPackageVersion>
-    <MicrosoftExtensionsLoggingAbstractionsPackageVersion>2.1.1</MicrosoftExtensionsLoggingAbstractionsPackageVersion>
-    <MicrosoftExtensionsLoggingAzureAppServicesPackageVersion>2.1.1</MicrosoftExtensionsLoggingAzureAppServicesPackageVersion>
-    <MicrosoftExtensionsLoggingConfigurationPackageVersion>2.1.1</MicrosoftExtensionsLoggingConfigurationPackageVersion>
-    <MicrosoftExtensionsLoggingConsolePackageVersion>2.1.1</MicrosoftExtensionsLoggingConsolePackageVersion>
-    <MicrosoftExtensionsLoggingDebugPackageVersion>2.1.1</MicrosoftExtensionsLoggingDebugPackageVersion>
-    <MicrosoftExtensionsLoggingEventLogPackageVersion>2.1.1</MicrosoftExtensionsLoggingEventLogPackageVersion>
-    <MicrosoftExtensionsLoggingEventSourcePackageVersion>2.1.1</MicrosoftExtensionsLoggingEventSourcePackageVersion>
-    <MicrosoftExtensionsLoggingPackageVersion>2.1.1</MicrosoftExtensionsLoggingPackageVersion>
-    <MicrosoftExtensionsLoggingTestingPackageVersion>2.1.1</MicrosoftExtensionsLoggingTestingPackageVersion>
-    <MicrosoftExtensionsLoggingTraceSourcePackageVersion>2.1.1</MicrosoftExtensionsLoggingTraceSourcePackageVersion>
-    <MicrosoftExtensionsObjectPoolPackageVersion>2.1.6</MicrosoftExtensionsObjectPoolPackageVersion>
-    <MicrosoftExtensionsOptionsConfigurationExtensionsPackageVersion>2.1.1</MicrosoftExtensionsOptionsConfigurationExtensionsPackageVersion>
-    <MicrosoftExtensionsOptionsPackageVersion>2.1.1</MicrosoftExtensionsOptionsPackageVersion>
-    <MicrosoftExtensionsParameterDefaultValueSourcesPackageVersion>2.1.1</MicrosoftExtensionsParameterDefaultValueSourcesPackageVersion>
-    <MicrosoftExtensionsPrimitivesPackageVersion>2.1.6</MicrosoftExtensionsPrimitivesPackageVersion>
-    <MicrosoftExtensionsTypeNameHelperSourcesPackageVersion>2.1.1</MicrosoftExtensionsTypeNameHelperSourcesPackageVersion>
-    <MicrosoftExtensionsValueStopwatchSourcesPackageVersion>2.1.1</MicrosoftExtensionsValueStopwatchSourcesPackageVersion>
-    <MicrosoftExtensionsWebEncodersPackageVersion>2.1.1</MicrosoftExtensionsWebEncodersPackageVersion>
-
-    <!-- Packages that come from aspnet/Scaffolding. (Used only in the 2.1.x package archives.) -->
-    <MicrosoftVisualStudioWebCodeGenerationContractsPackageVersion>2.1.7</MicrosoftVisualStudioWebCodeGenerationContractsPackageVersion>
-    <MicrosoftVisualStudioWebCodeGenerationCorePackageVersion>2.1.7</MicrosoftVisualStudioWebCodeGenerationCorePackageVersion>
-    <MicrosoftVisualStudioWebCodeGenerationDesignPackageVersion>2.1.7</MicrosoftVisualStudioWebCodeGenerationDesignPackageVersion>
-    <MicrosoftVisualStudioWebCodeGenerationEntityFrameworkCorePackageVersion>2.1.7</MicrosoftVisualStudioWebCodeGenerationEntityFrameworkCorePackageVersion>
-    <MicrosoftVisualStudioWebCodeGenerationPackageVersion>2.1.7</MicrosoftVisualStudioWebCodeGenerationPackageVersion>
-    <MicrosoftVisualStudioWebCodeGenerationTemplatingPackageVersion>2.1.7</MicrosoftVisualStudioWebCodeGenerationTemplatingPackageVersion>
-    <MicrosoftVisualStudioWebCodeGenerationUtilsPackageVersion>2.1.7</MicrosoftVisualStudioWebCodeGenerationUtilsPackageVersion>
-    <MicrosoftVisualStudioWebCodeGeneratorsMvcPackageVersion>2.1.7</MicrosoftVisualStudioWebCodeGeneratorsMvcPackageVersion>
-    <!-- These dependencies are temporary while we refactor package refs into project refs. -->
-    <MicrosoftAspNetCoreAspNetCoreModulePackageVersion>2.1.1</MicrosoftAspNetCoreAspNetCoreModulePackageVersion>
-    <MicrosoftAspNetCoreAspNetCoreModuleV1PackageVersion>2.1.1</MicrosoftAspNetCoreAspNetCoreModuleV1PackageVersion>
-    <MicrosoftExtensionsBuffersTestingSourcesPackageVersion>2.1.1</MicrosoftExtensionsBuffersTestingSourcesPackageVersion>
-    <MicrosoftAspNetCoreHostingWebHostBuilderFactorySourcesPackageVersion>2.1.1</MicrosoftAspNetCoreHostingWebHostBuilderFactorySourcesPackageVersion>
-    <MicrosoftAspNetCoreServerIntegrationTestingPackageVersion>0.5.1</MicrosoftAspNetCoreServerIntegrationTestingPackageVersion>
-    <MicrosoftEntityFrameworkCoreInMemoryPackageVersion>2.1.4</MicrosoftEntityFrameworkCoreInMemoryPackageVersion>
-    <MicrosoftEntityFrameworkCoreSqlitePackageVersion>2.1.4</MicrosoftEntityFrameworkCoreSqlitePackageVersion>
-    <MicrosoftEntityFrameworkCoreSqlServerPackageVersion>2.1.4</MicrosoftEntityFrameworkCoreSqlServerPackageVersion>
-    <MicrosoftEntityFrameworkCoreToolsPackageVersion>2.1.4</MicrosoftEntityFrameworkCoreToolsPackageVersion>
-
-    <!-- External and partner dependencies -->
-    <AngleSharpPackageVersion>0.9.9</AngleSharpPackageVersion>
-    <BenchmarkDotNetPackageVersion>0.10.13</BenchmarkDotNetPackageVersion>
-    <CastleCorePackageVersion>4.2.1</CastleCorePackageVersion>
-    <DevDependency_MicrosoftDotNetBuildTasksFeedPackageVersion>2.1.0-prerelease-02430-04</DevDependency_MicrosoftDotNetBuildTasksFeedPackageVersion>
-    <DevDependency_MicrosoftExtensionsDependencyModelPackageVersion>2.1.0</DevDependency_MicrosoftExtensionsDependencyModelPackageVersion>
-    <DevDependency_WindowsAzureStoragePackageVersion>8.7.0</DevDependency_WindowsAzureStoragePackageVersion>
-    <FSharpCorePackageVersion>4.2.1</FSharpCorePackageVersion>
-    <GoogleProtobufPackageVersion>3.1.0</GoogleProtobufPackageVersion>
-    <LibuvPackageVersion>1.10.0</LibuvPackageVersion>
-    <MessagePackPackageVersion>1.7.3.7</MessagePackPackageVersion>
-    <MicrosoftApplicationInsightsAspNetCorePackageVersion>2.1.1</MicrosoftApplicationInsightsAspNetCorePackageVersion>
-    <MicrosoftAspNetIdentityEntityFrameworkPackageVersion>2.2.1</MicrosoftAspNetIdentityEntityFrameworkPackageVersion>
-    <MicrosoftAspNetWebApiClientPackageVersion>5.2.6</MicrosoftAspNetWebApiClientPackageVersion>
-    <MicrosoftAzureDocumentDBCorePackageVersion>1.7.1</MicrosoftAzureDocumentDBCorePackageVersion>
-    <MicrosoftAzureKeyVaultPackageVersion>2.3.2</MicrosoftAzureKeyVaultPackageVersion>
-    <MicrosoftAzureManagementFluentPackageVersion>1.1.3</MicrosoftAzureManagementFluentPackageVersion>
-    <MicrosoftAzureServicesAppAuthenticationPackageVersion>1.0.1</MicrosoftAzureServicesAppAuthenticationPackageVersion>
-    <MicrosoftBuildFrameworkPackageVersion>15.6.82</MicrosoftBuildFrameworkPackageVersion>
-    <MicrosoftBuildPackageVersion>15.6.82</MicrosoftBuildPackageVersion>
-    <MicrosoftBuildRuntimePackageVersion>15.6.82</MicrosoftBuildRuntimePackageVersion>
-    <MicrosoftBuildTasksCorePackageVersion>15.6.82</MicrosoftBuildTasksCorePackageVersion>
-    <MicrosoftBuildUtilitiesCorePackageVersion>15.6.82</MicrosoftBuildUtilitiesCorePackageVersion>
-    <MicrosoftCodeAnalysisCommonPackageVersion>2.8.0</MicrosoftCodeAnalysisCommonPackageVersion>
-    <MicrosoftCodeAnalysisCSharpPackageVersion>2.8.0</MicrosoftCodeAnalysisCSharpPackageVersion>
-    <MicrosoftCodeAnalysisCSharpWorkspacesPackageVersion>2.8.0</MicrosoftCodeAnalysisCSharpWorkspacesPackageVersion>
-    <MicrosoftCSharpPackageVersion>4.5.0</MicrosoftCSharpPackageVersion>
-    <MicrosoftDataODataPackageVersion>5.8.4</MicrosoftDataODataPackageVersion>
-    <MicrosoftDataServicesClientPackageVersion>5.8.4</MicrosoftDataServicesClientPackageVersion>
-    <MicrosoftDiaSymReaderNativePackageVersion>1.7.0</MicrosoftDiaSymReaderNativePackageVersion>
-    <MicrosoftDotNetArchivePackageVersion>0.2.0-beta-63019-01</MicrosoftDotNetArchivePackageVersion>
-    <MicrosoftDotNetProjectModelPackageVersion>1.0.0-rc3-003121</MicrosoftDotNetProjectModelPackageVersion>
-    <MicrosoftExtensionsDependencyModelPackageVersion>2.1.0</MicrosoftExtensionsDependencyModelPackageVersion>
-    <MicrosoftExtensionsPlatformAbstractionsPackageVersion>1.1.0</MicrosoftExtensionsPlatformAbstractionsPackageVersion>
-    <MicrosoftIdentityModelClientsActiveDirectoryPackageVersion>3.14.2</MicrosoftIdentityModelClientsActiveDirectoryPackageVersion>
-    <MicrosoftIdentityModelProtocolsOpenIdConnectPackageVersion>5.2.0</MicrosoftIdentityModelProtocolsOpenIdConnectPackageVersion>
-    <MicrosoftIdentityModelProtocolsWsFederationPackageVersion>5.2.0</MicrosoftIdentityModelProtocolsWsFederationPackageVersion>
-    <MicrosoftNETCoreApp10PackageVersion>1.0.15</MicrosoftNETCoreApp10PackageVersion>
-    <MicrosoftNETCoreApp11PackageVersion>1.1.12</MicrosoftNETCoreApp11PackageVersion>
-    <MicrosoftNETCoreApp20PackageVersion>2.0.9</MicrosoftNETCoreApp20PackageVersion>
-    <MicrosoftNETCoreWindowsApiSetsPackageVersion>1.0.1</MicrosoftNETCoreWindowsApiSetsPackageVersion>
-    <MicrosoftNETTestSdkPackageVersion>15.9.0</MicrosoftNETTestSdkPackageVersion>
-    <MicrosoftOwinSecurityCookiesPackageVersion>3.0.1</MicrosoftOwinSecurityCookiesPackageVersion>
-    <MicrosoftOwinSecurityPackageVersion>3.0.1</MicrosoftOwinSecurityPackageVersion>
-    <MicrosoftOwinTestingPackageVersion>3.0.1</MicrosoftOwinTestingPackageVersion>
-    <MicrosoftVisualStudioComponentModelHostPackageVersion>15.0.26606</MicrosoftVisualStudioComponentModelHostPackageVersion>
-    <MicrosoftVisualStudioEditorPackageVersion>15.6.161-preview</MicrosoftVisualStudioEditorPackageVersion>
-    <MicrosoftVisualStudioLanguageIntellisensePackageVersion>15.6.161-preview</MicrosoftVisualStudioLanguageIntellisensePackageVersion>
-    <MicrosoftVisualStudioOLEInteropPackageVersion>7.10.6070</MicrosoftVisualStudioOLEInteropPackageVersion>
-    <MicrosoftVisualStudioProjectSystemAnalyzersPackageVersion>15.3.224</MicrosoftVisualStudioProjectSystemAnalyzersPackageVersion>
-    <MicrosoftVisualStudioProjectSystemManagedVSPackageVersion>2.0.6142705</MicrosoftVisualStudioProjectSystemManagedVSPackageVersion>
-    <MicrosoftVisualStudioProjectSystemSDKPackageVersion>15.3.224</MicrosoftVisualStudioProjectSystemSDKPackageVersion>
-    <MicrosoftVisualStudioShell150PackageVersion>15.0.26606</MicrosoftVisualStudioShell150PackageVersion>
-    <MicrosoftVisualStudioShellInterop100PackageVersion>10.0.30319</MicrosoftVisualStudioShellInterop100PackageVersion>
-    <MicrosoftVisualStudioShellInterop110PackageVersion>11.0.61030</MicrosoftVisualStudioShellInterop110PackageVersion>
-    <MicrosoftVisualStudioShellInterop120PackageVersion>12.0.30110</MicrosoftVisualStudioShellInterop120PackageVersion>
-    <MicrosoftVisualStudioShellInterop80PackageVersion>8.0.50727</MicrosoftVisualStudioShellInterop80PackageVersion>
-    <MicrosoftVisualStudioShellInterop90PackageVersion>9.0.30729</MicrosoftVisualStudioShellInterop90PackageVersion>
-    <MicrosoftVisualStudioShellInteropPackageVersion>7.10.6071</MicrosoftVisualStudioShellInteropPackageVersion>
-    <MicrosoftVisualStudioTextUIPackageVersion>15.6.161-preview</MicrosoftVisualStudioTextUIPackageVersion>
-    <MicrosoftVisualStudioWebBrowserLinkPackageVersion>2.1.1</MicrosoftVisualStudioWebBrowserLinkPackageVersion>
-    <MicrosoftWebXdtPackageVersion>1.4.0</MicrosoftWebXdtPackageVersion>
-    <MicrosoftWin32RegistryPackageVersion>4.5.0</MicrosoftWin32RegistryPackageVersion>
-    <MonoAddinsPackageVersion>1.3.8</MonoAddinsPackageVersion>
-    <MonoDevelopSdkPackageVersion>1.0.1</MonoDevelopSdkPackageVersion>
-    <MoqPackageVersion>4.7.49</MoqPackageVersion>
-    <NETStandard16PackageVersion>1.6.1</NETStandard16PackageVersion>
-    <NETStandardLibrary20PackageVersion>2.0.3</NETStandardLibrary20PackageVersion>
-    <NewtonsoftJsonBsonPackageVersion>1.0.1</NewtonsoftJsonBsonPackageVersion>
-    <NewtonsoftJsonPackageVersion>11.0.2</NewtonsoftJsonPackageVersion>
-    <NuGetFrameworksPackageVersion>4.7.0</NuGetFrameworksPackageVersion>
-    <OracleManagedDataAccessPackageVersion>12.2.1100</OracleManagedDataAccessPackageVersion>
-    <RemotionLinqPackageVersion>2.2.0</RemotionLinqPackageVersion>
-    <SeleniumFirefoxWebDriverPackageVersion>0.20.0</SeleniumFirefoxWebDriverPackageVersion>
-    <SeleniumSupportPackageVersion>3.12.1</SeleniumSupportPackageVersion>
-    <SeleniumWebDriverMicrosoftDriverPackageVersion>17.17134.0</SeleniumWebDriverMicrosoftDriverPackageVersion>
-    <SeleniumWebDriverPackageVersion>3.12.1</SeleniumWebDriverPackageVersion>
-    <SerilogExtensionsLoggingPackageVersion>1.4.0</SerilogExtensionsLoggingPackageVersion>
-    <SerilogSinksFilePackageVersion>3.2.0</SerilogSinksFilePackageVersion>
-    <SQLitePCLRawBundleGreenPackageVersion>1.1.11</SQLitePCLRawBundleGreenPackageVersion>
-    <SQLitePCLRawBundleSqlcipherPackageVersion>1.1.11</SQLitePCLRawBundleSqlcipherPackageVersion>
-    <SQLitePCLRawCorePackageVersion>1.1.11</SQLitePCLRawCorePackageVersion>
-    <StackExchangeRedisStrongNamePackageVersion>1.2.6</StackExchangeRedisStrongNamePackageVersion>
-    <StreamJsonRpcPackageVersion>1.1.92</StreamJsonRpcPackageVersion>
-    <StyleCopAnalyzersPackageVersion>1.0.0</StyleCopAnalyzersPackageVersion>
-    <SystemBuffersPackageVersion>4.5.1</SystemBuffersPackageVersion>
-    <SystemCollectionsImmutablePackageVersion>1.5.0</SystemCollectionsImmutablePackageVersion>
-    <SystemComponentModelAnnotationsPackageVersion>4.5.0</SystemComponentModelAnnotationsPackageVersion>
-    <SystemDataSqlClientPackageVersion>4.5.3</SystemDataSqlClientPackageVersion>
-    <SystemDiagnosticsDiagnosticSourcePackageVersion>4.5.1</SystemDiagnosticsDiagnosticSourcePackageVersion>
-    <SystemDiagnosticsEventLogPackageVersion>4.5.0</SystemDiagnosticsEventLogPackageVersion>
-    <SystemIdentityModelTokensJwtPackageVersion>5.2.0</SystemIdentityModelTokensJwtPackageVersion>
-    <SystemInteractiveAsyncPackageVersion>3.1.1</SystemInteractiveAsyncPackageVersion>
-    <SystemIOPipelinesPackageVersion>4.5.3</SystemIOPipelinesPackageVersion>
-    <SystemMemoryPackageVersion>4.5.4</SystemMemoryPackageVersion>
-    <SystemNetHttpPackageVersion>4.3.4</SystemNetHttpPackageVersion>
-    <SystemNetHttpWinHttpHandlerPackageVersion>4.5.3</SystemNetHttpWinHttpHandlerPackageVersion>
-    <SystemNumericsVectorsPackageVersion>4.5.0</SystemNumericsVectorsPackageVersion>
-    <SystemReactiveLinqPackageVersion>3.1.1</SystemReactiveLinqPackageVersion>
-    <SystemReflectionEmitPackageVersion>4.3.0</SystemReflectionEmitPackageVersion>
-    <SystemReflectionMetadataPackageVersion>1.6.0</SystemReflectionMetadataPackageVersion>
-    <SystemRuntimeCompilerServicesUnsafePackageVersion>4.5.3</SystemRuntimeCompilerServicesUnsafePackageVersion>
-    <SystemRuntimeInteropServicesRuntimeInformationPackageVersion>4.3.0</SystemRuntimeInteropServicesRuntimeInformationPackageVersion>
-    <SystemSecurityCryptographyCngPackageVersion>4.5.2</SystemSecurityCryptographyCngPackageVersion>
-    <SystemSecurityCryptographyXmlPackageVersion>4.5.0</SystemSecurityCryptographyXmlPackageVersion>
-    <SystemSecurityPermissionsPackageVersion>4.5.0</SystemSecurityPermissionsPackageVersion>
-    <SystemSecurityPrincipalWindowsPackageVersion>4.5.1</SystemSecurityPrincipalWindowsPackageVersion>
-    <SystemServiceProcessServiceControllerPackageVersion>4.5.0</SystemServiceProcessServiceControllerPackageVersion>
-    <SystemTextEncodingsWebPackageVersion>4.5.0</SystemTextEncodingsWebPackageVersion>
-    <SystemThreadingChannelsPackageVersion>4.5.0</SystemThreadingChannelsPackageVersion>
-    <SystemThreadingTasksDataflowPackageVersion>4.9.0</SystemThreadingTasksDataflowPackageVersion>
-    <SystemThreadingTasksExtensionsPackageVersion>4.5.4</SystemThreadingTasksExtensionsPackageVersion>
-    <SystemValueTuplePackageVersion>4.5.0</SystemValueTuplePackageVersion>
-    <SystemNetWebSocketsWebSocketProtocolPackageVersion>4.5.3</SystemNetWebSocketsWebSocketProtocolPackageVersion>
-    <Utf8JsonPackageVersion>1.3.7</Utf8JsonPackageVersion>
-    <VisualStudio_NewtonsoftJsonPackageVersion>9.0.1</VisualStudio_NewtonsoftJsonPackageVersion>
-    <VSIX_MicrosoftCodeAnalysisCommonPackageVersion>2.8.0</VSIX_MicrosoftCodeAnalysisCommonPackageVersion>
-    <VSIX_MicrosoftCodeAnalysisCSharpFeaturesPackageVersion>2.8.0</VSIX_MicrosoftCodeAnalysisCSharpFeaturesPackageVersion>
-    <VSIX_MicrosoftCodeAnalysisCSharpPackageVersion>2.8.0</VSIX_MicrosoftCodeAnalysisCSharpPackageVersion>
-    <VSIX_MicrosoftCodeAnalysisCSharpWorkspacesPackageVersion>2.8.0</VSIX_MicrosoftCodeAnalysisCSharpWorkspacesPackageVersion>
-    <VSIX_MicrosoftCodeAnalysisEditorFeaturesTextPackageVersion>2.8.0</VSIX_MicrosoftCodeAnalysisEditorFeaturesTextPackageVersion>
-    <VSIX_MicrosoftCodeAnalysisRemoteRazorServiceHubPackageVersion>2.8.0-beta2-62721-09</VSIX_MicrosoftCodeAnalysisRemoteRazorServiceHubPackageVersion>
-    <VSIX_MicrosoftCodeAnalysisVisualBasicWorkspacesPackageVersion>2.8.0</VSIX_MicrosoftCodeAnalysisVisualBasicWorkspacesPackageVersion>
-    <VSIX_MicrosoftCodeAnalysisWorkspacesCommonPackageVersion>2.8.0</VSIX_MicrosoftCodeAnalysisWorkspacesCommonPackageVersion>
-    <VSIX_MicrosoftVisualStudioLanguageServicesPackageVersion>2.8.0</VSIX_MicrosoftVisualStudioLanguageServicesPackageVersion>
-    <VSIX_MicrosoftVisualStudioLanguageServicesRazorRemoteClientPackageVersion>2.8.0-beta2-62721-09</VSIX_MicrosoftVisualStudioLanguageServicesRazorRemoteClientPackageVersion>
-    <WindowsAzureStoragePackageVersion>8.1.4</WindowsAzureStoragePackageVersion>
-    <XunitAbstractionsPackageVersion>2.0.1</XunitAbstractionsPackageVersion>
-    <XunitAnalyzersPackageVersion>0.10.0</XunitAnalyzersPackageVersion>
-    <XunitAssertPackageVersion>2.3.1</XunitAssertPackageVersion>
-    <XunitCorePackageVersion>2.3.1</XunitCorePackageVersion>
-    <XunitExtensibilityCorePackageVersion>2.3.1</XunitExtensibilityCorePackageVersion>
-    <XunitExtensibilityExecutionPackageVersion>2.3.1</XunitExtensibilityExecutionPackageVersion>
-    <XunitPackageVersion>2.4.0</XunitPackageVersion>
-    <XunitRunnerVisualStudioPackageVersion>2.4.0</XunitRunnerVisualStudioPackageVersion>
-  </PropertyGroup>
-</Project>
--- a/build/external-dependencies.props
+++ b/build/external-dependencies.props
@ -1,227 +0,0 @@
-<Project>
-  <Import Project="dependencies.props" />
-
-  <ItemDefinitionGroup>
-    <ExternalDependency>
-      <!-- The NuGet package version. Floating versions not allowed. -->
-      <Version></Version>
-      <!-- When true, this dependency will be included in the Microsoft.AspNetCore.App metapackage. -->
-      <AppMetapackage>false</AppMetapackage>
-      <!-- When true, this dependency will be included in the Microsoft.AspNetCore.All metapackage. -->
-      <AllMetapackage>false</AllMetapackage>
-    </ExternalDependency>
-  </ItemDefinitionGroup>
-
-  <ItemGroup>
-    <!-- Packages from aspnet/Extensions -->
-    <ExternalDependency Include="Microsoft.AspNetCore.BenchmarkRunner.Sources" Version="$(MicrosoftAspNetCoreBenchmarkRunnerSourcesPackageVersion)" />
-    <ExternalDependency Include="Microsoft.AspNetCore.Testing" Version="$(MicrosoftAspNetCoreTestingPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Extensions.ActivatorUtilities.Sources" Version="$(MicrosoftExtensionsActivatorUtilitiesSourcesPackageVersion)"  />
-    <ExternalDependency Include="Microsoft.Extensions.Caching.Abstractions" Version="$(MicrosoftExtensionsCachingAbstractionsPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Caching.Memory" Version="$(MicrosoftExtensionsCachingMemoryPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Caching.Redis" Version="$(MicrosoftExtensionsCachingRedisPackageVersion)"  AllMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Caching.SqlServer" Version="$(MicrosoftExtensionsCachingSqlServerPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.CommandLineUtils.Sources" Version="$(MicrosoftExtensionsCommandLineUtilsSourcesPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Extensions.Configuration.Abstractions" Version="$(MicrosoftExtensionsConfigurationAbstractionsPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Configuration.AzureKeyVault" Version="$(MicrosoftExtensionsConfigurationAzureKeyVaultPackageVersion)"  AllMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Configuration.Binder" Version="$(MicrosoftExtensionsConfigurationBinderPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Configuration.CommandLine" Version="$(MicrosoftExtensionsConfigurationCommandLinePackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="$(MicrosoftExtensionsConfigurationEnvironmentVariablesPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Configuration.FileExtensions" Version="$(MicrosoftExtensionsConfigurationFileExtensionsPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Configuration.Ini" Version="$(MicrosoftExtensionsConfigurationIniPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Configuration.Json" Version="$(MicrosoftExtensionsConfigurationJsonPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Configuration.KeyPerFile" Version="$(MicrosoftExtensionsConfigurationKeyPerFilePackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Configuration.UserSecrets" Version="$(MicrosoftExtensionsConfigurationUserSecretsPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Configuration.Xml" Version="$(MicrosoftExtensionsConfigurationXmlPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Configuration" Version="$(MicrosoftExtensionsConfigurationPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="$(MicrosoftExtensionsDependencyInjectionAbstractionsPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.DependencyInjection.Specification.Tests" Version="$(MicrosoftExtensionsDependencyInjectionSpecificationTestsPackageVersion)"  />
-    <ExternalDependency Include="Microsoft.Extensions.DependencyInjection" Version="$(MicrosoftExtensionsDependencyInjectionPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.DiagnosticAdapter" Version="$(MicrosoftExtensionsDiagnosticAdapterPackageVersion)" AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.FileProviders.Abstractions" Version="$(MicrosoftExtensionsFileProvidersAbstractionsPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.FileProviders.Composite" Version="$(MicrosoftExtensionsFileProvidersCompositePackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.FileProviders.Embedded" Version="$(MicrosoftExtensionsFileProvidersEmbeddedPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.FileProviders.Physical" Version="$(MicrosoftExtensionsFileProvidersPhysicalPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.FileSystemGlobbing" Version="$(MicrosoftExtensionsFileSystemGlobbingPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.HashCodeCombiner.Sources" Version="$(MicrosoftExtensionsHashCodeCombinerSourcesPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Extensions.Hosting.Abstractions" Version="$(MicrosoftExtensionsHostingAbstractionsPackageVersion)" AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Localization.Abstractions" Version="$(MicrosoftExtensionsLocalizationAbstractionsPackageVersion)" AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Localization" Version="$(MicrosoftExtensionsLocalizationPackageVersion)" AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Hosting" Version="$(MicrosoftExtensionsHostingPackageVersion)" AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Http" Version="$(MicrosoftExtensionsHttpPackageVersion)" AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Logging.Abstractions" Version="$(MicrosoftExtensionsLoggingAbstractionsPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Logging.AzureAppServices" Version="$(MicrosoftExtensionsLoggingAzureAppServicesPackageVersion)"  AllMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Logging.Configuration" Version="$(MicrosoftExtensionsLoggingConfigurationPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Logging.Console" Version="$(MicrosoftExtensionsLoggingConsolePackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Logging.Debug" Version="$(MicrosoftExtensionsLoggingDebugPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Logging.EventLog" Version="$(MicrosoftExtensionsLoggingEventLogPackageVersion)"  />
-    <ExternalDependency Include="Microsoft.Extensions.Logging.EventSource" Version="$(MicrosoftExtensionsLoggingEventSourcePackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Logging.Testing" Version="$(MicrosoftExtensionsLoggingTestingPackageVersion)"  />
-    <ExternalDependency Include="Microsoft.Extensions.Logging.TraceSource" Version="$(MicrosoftExtensionsLoggingTraceSourcePackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Logging" Version="$(MicrosoftExtensionsLoggingPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.ObjectPool" Version="$(MicrosoftExtensionsObjectPoolPackageVersion)" AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="$(MicrosoftExtensionsOptionsConfigurationExtensionsPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.Options" Version="$(MicrosoftExtensionsOptionsPackageVersion)"  AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.ParameterDefaultValue.Sources" Version="$(MicrosoftExtensionsParameterDefaultValueSourcesPackageVersion)"  />
-    <ExternalDependency Include="Microsoft.Extensions.Primitives" Version="$(MicrosoftExtensionsPrimitivesPackageVersion)" AllMetapackage="true" AppMetapackage="true" />
-    <ExternalDependency Include="Microsoft.Extensions.TypeNameHelper.Sources" Version="$(MicrosoftExtensionsTypeNameHelperSourcesPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Extensions.ValueStopwatch.Sources" Version="$(MicrosoftExtensionsValueStopwatchSourcesPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Extensions.WebEncoders" Version="$(MicrosoftExtensionsWebEncodersPackageVersion)" AllMetapackage="true" AppMetapackage="true" />
-
-    <!-- These dependencies are temporary while we refactor package refs into project refs. -->
-    <ExternalDependency Include="Microsoft.AspNetCore.Server.IntegrationTesting" Version="$(MicrosoftAspNetCoreServerIntegrationTestingPackageVersion)" />
-  </ItemGroup>
-
-   <ItemGroup>
-    <ExternalDependency Include="AngleSharp" Version="$(AngleSharpPackageVersion)" />
-    <ExternalDependency Include="BenchmarkDotNet" Version="$(BenchmarkDotNetPackageVersion)" />
-    <ExternalDependency Include="Castle.Core" Version="$(CastleCorePackageVersion)" />
-    <ExternalDependency Include="FSharp.Core" Version="$(FSharpCorePackageVersion)" />
-    <ExternalDependency Include="Google.Protobuf" Version="$(GoogleProtobufPackageVersion)" />
-    <ExternalDependency Include="Internal.AspNetCore.Sdk" Version="$(InternalAspNetCoreSdkPackageVersion)" />
-    <ExternalDependency Include="Internal.AspNetCore.SiteExtension.Sdk" Version="$(InternalAspNetCoreSiteExtensionSdkPackageVersion)" />
-    <ExternalDependency Include="Libuv" Version="$(LibuvPackageVersion)" />
-    <ExternalDependency Include="Microsoft.ApplicationInsights.AspNetCore" Version="$(MicrosoftApplicationInsightsAspNetCorePackageVersion)" />
-    <ExternalDependency Include="Microsoft.AspNet.Identity.EntityFramework" Version="$(MicrosoftAspNetIdentityEntityFrameworkPackageVersion)" />
-    <ExternalDependency Include="Microsoft.AspNet.WebApi.Client" Version="$(MicrosoftAspNetWebApiClientPackageVersion)" AppMetapackage="true" AllMetapackage="true"/>
-    <ExternalDependency Include="Microsoft.Azure.DocumentDB.Core" Version="$(MicrosoftAzureDocumentDBCorePackageVersion)" />
-    <ExternalDependency Include="Microsoft.Azure.KeyVault" Version="$(MicrosoftAzureKeyVaultPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Azure.Management.Fluent" Version="$(MicrosoftAzureManagementFluentPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Azure.Services.AppAuthentication" Version="$(MicrosoftAzureServicesAppAuthenticationPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Build" Version="$(MicrosoftBuildPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Build.Framework" Version="$(MicrosoftBuildFrameworkPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Build.Runtime" Version="$(MicrosoftBuildRuntimePackageVersion)" />
-    <ExternalDependency Include="Microsoft.Build.Tasks.Core" Version="$(MicrosoftBuildTasksCorePackageVersion)" />
-    <ExternalDependency Include="Microsoft.Build.Utilities.Core" Version="$(MicrosoftBuildUtilitiesCorePackageVersion)" />
-    <ExternalDependency Include="Microsoft.Data.OData" Version="$(MicrosoftDataODataPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Data.Services.Client" Version="$(MicrosoftDataServicesClientPackageVersion)" />
-
-
-    <!-- Microsoft.NetCore.DotNetAppHost for global tools-->
-    <ExternalDependency Include="Microsoft.NETCore.DotNetAppHost" Version="$(MicrosoftNETCoreDotNetAppHostPackageVersion)" />
-
-    <!-- Razor uses a custom version of roslyn packages -->
-    <ExternalDependency Include="Microsoft.CodeAnalysis.Common" Version="$(MicrosoftCodeAnalysisCommonPackageVersion)" />
-    <ExternalDependency Include="Microsoft.CodeAnalysis.Common" Version="$(VSIX_MicrosoftCodeAnalysisCommonPackageVersion)" VariableName="VSIX_MicrosoftCodeAnalysisCommonPackageVersion" />
-    <ExternalDependency Include="Microsoft.CodeAnalysis.CSharp" Version="$(MicrosoftCodeAnalysisCSharpPackageVersion)" />
-    <ExternalDependency Include="Microsoft.CodeAnalysis.CSharp" Version="$(VSIX_MicrosoftCodeAnalysisCSharpPackageVersion)" VariableName="VSIX_MicrosoftCodeAnalysisCSharpPackageVersion" />
-    <ExternalDependency Include="Microsoft.CodeAnalysis.CSharp.Features" Version="$(VSIX_MicrosoftCodeAnalysisCSharpFeaturesPackageVersion)" VariableName="VSIX_MicrosoftCodeAnalysisCSharpFeaturesPackageVersion" />
-    <ExternalDependency Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="$(MicrosoftCodeAnalysisCSharpWorkspacesPackageVersion)" />
-    <ExternalDependency Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="$(VSIX_MicrosoftCodeAnalysisCSharpWorkspacesPackageVersion)" VariableName="VSIX_MicrosoftCodeAnalysisCSharpWorkspacesPackageVersion" />
-    <ExternalDependency Include="Microsoft.CodeAnalysis.EditorFeatures.Text" Version="$(VSIX_MicrosoftCodeAnalysisEditorFeaturesTextPackageVersion)" VariableName="VSIX_MicrosoftCodeAnalysisEditorFeaturesTextPackageVersion" />
-    <ExternalDependency Include="Microsoft.CodeAnalysis.Remote.Razor.ServiceHub" Version="$(VSIX_MicrosoftCodeAnalysisRemoteRazorServiceHubPackageVersion)" VariableName="VSIX_MicrosoftCodeAnalysisRemoteRazorServiceHubPackageVersion" />
-    <ExternalDependency Include="Microsoft.CodeAnalysis.VisualBasic.Workspaces" Version="$(VSIX_MicrosoftCodeAnalysisVisualBasicWorkspacesPackageVersion)" VariableName="VSIX_MicrosoftCodeAnalysisVisualBasicWorkspacesPackageVersion" />
-    <ExternalDependency Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="$(VSIX_MicrosoftCodeAnalysisWorkspacesCommonPackageVersion)" VariableName="VSIX_MicrosoftCodeAnalysisWorkspacesCommonPackageVersion" />
-
-    <ExternalDependency Include="Microsoft.CSharp" Version="$(MicrosoftCSharpPackageVersion)" />
-    <ExternalDependency Include="Microsoft.DotNet.ProjectModel" Version="$(MicrosoftDotNetProjectModelPackageVersion)" />
-    <ExternalDependency Include="Microsoft.DiaSymReader.Native" Version="$(MicrosoftDiaSymReaderNativePackageVersion)" />
-    <ExternalDependency Include="Microsoft.Extensions.DependencyModel" Version="$(MicrosoftExtensionsDependencyModelPackageVersion)" />
-    <ExternalDependency Include="Microsoft.IdentityModel.Clients.ActiveDirectory" Version="$(MicrosoftIdentityModelClientsActiveDirectoryPackageVersion)" />
-    <ExternalDependency Include="Microsoft.IdentityModel.Protocols.OpenIdConnect" Version="$(MicrosoftIdentityModelProtocolsOpenIdConnectPackageVersion)" />
-    <ExternalDependency Include="Microsoft.IdentityModel.Protocols.WsFederation" Version="$(MicrosoftIdentityModelProtocolsWsFederationPackageVersion)" />
-    <ExternalDependency Include="Microsoft.NET.Test.Sdk" Version="$(MicrosoftNETTestSdkPackageVersion)" />
-
-    <!-- Multiple versions of this package required to support all netcoreapp versions -->
-    <ExternalDependency Include="Microsoft.NETCore.App" Version="$(MicrosoftNETCoreApp10PackageVersion)" VariableName="MicrosoftNETCoreApp10PackageVersion" />
-    <ExternalDependency Include="Microsoft.NETCore.App" Version="$(MicrosoftNETCoreApp11PackageVersion)" VariableName="MicrosoftNETCoreApp11PackageVersion" />
-    <ExternalDependency Include="Microsoft.NETCore.App" Version="$(MicrosoftNETCoreApp20PackageVersion)" VariableName="MicrosoftNETCoreApp20PackageVersion" />
-    <ExternalDependency Include="Microsoft.NETCore.App" Version="$(MicrosoftNETCoreApp21PackageVersion)" VariableName="MicrosoftNETCoreApp21PackageVersion" />
-
-    <ExternalDependency Include="Microsoft.NETCore.Windows.ApiSets" Version="$(MicrosoftNETCoreWindowsApiSetsPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Owin.Security" Version="$(MicrosoftOwinSecurityPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Owin.Security.Cookies" Version="$(MicrosoftOwinSecurityCookiesPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Owin.Testing" Version="$(MicrosoftOwinTestingPackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.ComponentModelHost" Version="$(MicrosoftVisualStudioComponentModelHostPackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.Editor" Version="$(MicrosoftVisualStudioEditorPackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.Language.Intellisense" Version="$(MicrosoftVisualStudioLanguageIntellisensePackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.LanguageServices" Version="$(VSIX_MicrosoftVisualStudioLanguageServicesPackageVersion)" VariableName="VSIX_MicrosoftVisualStudioLanguageServicesPackageVersion" />
-    <ExternalDependency Include="Microsoft.VisualStudio.LanguageServices.Razor.RemoteClient" Version="$(VSIX_MicrosoftVisualStudioLanguageServicesRazorRemoteClientPackageVersion)" VariableName="VSIX_MicrosoftVisualStudioLanguageServicesRazorRemoteClientPackageVersion" />
-    <ExternalDependency Include="Microsoft.VisualStudio.OLE.Interop" Version="$(MicrosoftVisualStudioOLEInteropPackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.ProjectSystem.Analyzers" Version="$(MicrosoftVisualStudioProjectSystemAnalyzersPackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.ProjectSystem.Managed.VS" Version="$(MicrosoftVisualStudioProjectSystemManagedVSPackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.ProjectSystem.SDK" Version="$(MicrosoftVisualStudioProjectSystemSDKPackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.Shell.15.0" Version="$(MicrosoftVisualStudioShell150PackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.Shell.Interop" Version="$(MicrosoftVisualStudioShellInteropPackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.Shell.Interop.10.0" Version="$(MicrosoftVisualStudioShellInterop100PackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.Shell.Interop.11.0" Version="$(MicrosoftVisualStudioShellInterop110PackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.Shell.Interop.12.0" Version="$(MicrosoftVisualStudioShellInterop120PackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.Shell.Interop.8.0" Version="$(MicrosoftVisualStudioShellInterop80PackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.Shell.Interop.9.0" Version="$(MicrosoftVisualStudioShellInterop90PackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.Text.UI" Version="$(MicrosoftVisualStudioTextUIPackageVersion)" />
-    <ExternalDependency Include="Microsoft.VisualStudio.Web.BrowserLink" Version="$(MicrosoftVisualStudioWebBrowserLinkPackageVersion)" AllMetapackage="true"  />
-    <ExternalDependency Include="Microsoft.Web.Xdt" Version="$(MicrosoftWebXdtPackageVersion)" />
-    <ExternalDependency Include="Microsoft.Win32.Registry" Version="$(MicrosoftWin32RegistryPackageVersion)" />
-    <ExternalDependency Include="Mono.Addins" Version="$(MonoAddinsPackageVersion)" />
-    <ExternalDependency Include="MonoDevelop.Sdk" Version="$(MonoDevelopSdkPackageVersion)" />
-    <ExternalDependency Include="Moq" Version="$(MoqPackageVersion)" />
-    <ExternalDependency Include="MessagePack" Version="$(MessagePackPackageVersion)" />
-
-    <!-- netstandard1.x -->
-    <ExternalDependency Include="NETStandard.Library" Version="$(NETStandard16PackageVersion)" VariableName="NETStandard16PackageVersion" />
-    <!-- netstandard2.0 -->
-    <ExternalDependency Include="NETStandard.Library" Version="$(NETStandardLibrary20PackageVersion)" VariableName="NETStandardLibrary20PackageVersion" />
-
-    <!-- This version should be used by runtime packages -->
-    <ExternalDependency Include="Newtonsoft.Json" Version="$(NewtonsoftJsonPackageVersion)" />
-    <!-- This version is required by MSBuild tasks or Visual Studio extensions. -->
-    <ExternalDependency Include="Newtonsoft.Json" Version="$(VisualStudio_NewtonsoftJsonPackageVersion)" VariableName="VisualStudio_NewtonsoftJsonPackageVersion" />
-
-    <ExternalDependency Include="Newtonsoft.Json.Bson" Version="$(NewtonsoftJsonBsonPackageVersion)" />
-    <ExternalDependency Include="NuGet.Frameworks" Version="$(NuGetFrameworksPackageVersion)" />
-    <ExternalDependency Include="Oracle.ManagedDataAccess" Version="$(OracleManagedDataAccessPackageVersion)" />
-    <ExternalDependency Include="Remotion.Linq" Version="$(RemotionLinqPackageVersion)" />
-    <ExternalDependency Include="Selenium.Firefox.WebDriver" Version="$(SeleniumFirefoxWebDriverPackageVersion)" />
-    <ExternalDependency Include="Selenium.Support" Version="$(SeleniumSupportPackageVersion)" />
-    <ExternalDependency Include="Selenium.WebDriver.MicrosoftDriver" Version="$(SeleniumWebDriverMicrosoftDriverPackageVersion)" />
-    <ExternalDependency Include="Selenium.WebDriver" Version="$(SeleniumWebDriverPackageVersion)" />
-    <ExternalDependency Include="Serilog.Extensions.Logging" Version="$(SerilogExtensionsLoggingPackageVersion)" />
-    <ExternalDependency Include="Serilog.Sinks.File" Version="$(SerilogSinksFilePackageVersion)" />
-    <ExternalDependency Include="SQLitePCLRaw.bundle_green" Version="$(SQLitePCLRawBundleGreenPackageVersion)" />
-    <ExternalDependency Include="SQLitePCLRaw.bundle_sqlcipher" Version="$(SQLitePCLRawBundleSqlcipherPackageVersion)" />
-    <ExternalDependency Include="SQLitePCLRaw.core" Version="$(SQLitePCLRawCorePackageVersion)" />
-    <ExternalDependency Include="StackExchange.Redis.StrongName" Version="$(StackExchangeRedisStrongNamePackageVersion)" />
-    <ExternalDependency Include="StreamJsonRpc" Version="$(StreamJsonRpcPackageVersion)" />
-    <ExternalDependency Include="StyleCop.Analyzers" Version="$(StyleCopAnalyzersPackageVersion)" />
-    <ExternalDependency Include="System.Buffers" Version="$(SystemBuffersPackageVersion)" />
-    <ExternalDependency Include="System.Collections.Immutable" Version="$(SystemCollectionsImmutablePackageVersion)" />
-    <ExternalDependency Include="System.ComponentModel.Annotations" Version="$(SystemComponentModelAnnotationsPackageVersion)" />
-    <ExternalDependency Include="System.Data.SqlClient" Version="$(SystemDataSqlClientPackageVersion)" />
-    <ExternalDependency Include="System.Diagnostics.DiagnosticSource" Version="$(SystemDiagnosticsDiagnosticSourcePackageVersion)" />
-    <ExternalDependency Include="System.Diagnostics.EventLog" Version="$(SystemDiagnosticsEventLogPackageVersion)" />
-    <ExternalDependency Include="System.IdentityModel.Tokens.Jwt" Version="$(SystemIdentityModelTokensJwtPackageVersion)" />
-    <ExternalDependency Include="System.Interactive.Async" Version="$(SystemInteractiveAsyncPackageVersion)" />
-    <ExternalDependency Include="System.IO.Pipelines" Version="$(SystemIOPipelinesPackageVersion)" AppMetapackage="true" AllMetapackage="true" MetapackageVersionRangeType="Minimum" />
-    <ExternalDependency Include="System.Memory" Version="$(SystemMemoryPackageVersion)" />
-    <ExternalDependency Include="System.Net.Http.WinHttpHandler" Version="$(SystemNetHttpWinHttpHandlerPackageVersion)" />
-    <ExternalDependency Include="System.Net.Http" Version="$(SystemNetHttpPackageVersion)" />
-    <ExternalDependency Include="System.Net.WebSockets.WebSocketProtocol" Version="$(SystemNetWebSocketsWebSocketProtocolPackageVersion)" />
-    <ExternalDependency Include="System.Numerics.Vectors" Version="$(SystemNumericsVectorsPackageVersion)" />
-    <ExternalDependency Include="System.Reactive.Linq" Version="$(SystemReactiveLinqPackageVersion)" />
-    <ExternalDependency Include="System.Reflection.Emit" Version="$(SystemReflectionEmitPackageVersion)" />
-    <ExternalDependency Include="System.Reflection.Metadata" Version="$(SystemReflectionMetadataPackageVersion)" />
-    <ExternalDependency Include="System.Runtime.CompilerServices.Unsafe" Version="$(SystemRuntimeCompilerServicesUnsafePackageVersion)" />
-    <ExternalDependency Include="System.Runtime.InteropServices.RuntimeInformation" Version="$(SystemRuntimeInteropServicesRuntimeInformationPackageVersion)" />
-    <ExternalDependency Include="System.Security.Cryptography.Cng" Version="$(SystemSecurityCryptographyCngPackageVersion)" />
-    <ExternalDependency Include="System.Security.Cryptography.Xml" Version="$(SystemSecurityCryptographyXmlPackageVersion)" />
-    <ExternalDependency Include="System.Security.Permissions" Version="$(SystemSecurityPermissionsPackageVersion)" />
-    <ExternalDependency Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsPackageVersion)" />
-    <ExternalDependency Include="System.ServiceProcess.ServiceController" Version="$(SystemServiceProcessServiceControllerPackageVersion)" />
-    <ExternalDependency Include="System.Text.Encodings.Web" Version="$(SystemTextEncodingsWebPackageVersion)" />
-    <ExternalDependency Include="System.Threading.Channels" Version="$(SystemThreadingChannelsPackageVersion)" />
-    <ExternalDependency Include="System.Threading.Tasks.Dataflow" Version="$(SystemThreadingTasksDataflowPackageVersion)" />
-    <ExternalDependency Include="System.Threading.Tasks.Extensions" Version="$(SystemThreadingTasksExtensionsPackageVersion)" />
-    <ExternalDependency Include="System.ValueTuple" Version="$(SystemValueTuplePackageVersion)" />
-    <ExternalDependency Include="Utf8Json" Version="$(Utf8JsonPackageVersion)" />
-    <ExternalDependency Include="WindowsAzure.Storage" Version="$(WindowsAzureStoragePackageVersion)" />
-    <ExternalDependency Include="xunit.abstractions" Version="$(XunitAbstractionsPackageVersion)" />
-    <ExternalDependency Include="xunit.analyzers" Version="$(XunitAnalyzersPackageVersion)" />
-    <ExternalDependency Include="xunit.assert" Version="$(XunitAssertPackageVersion)" />
-    <ExternalDependency Include="xunit.core" Version="$(XunitCorePackageVersion)" />
-    <ExternalDependency Include="xunit.extensibility.core" Version="$(XunitExtensibilityCorePackageVersion)" />
-    <ExternalDependency Include="xunit.extensibility.execution" Version="$(XunitExtensibilityExecutionPackageVersion)" />
-    <ExternalDependency Include="xunit.runner.visualstudio" Version="$(XunitRunnerVisualstudioPackageVersion)" />
-    <ExternalDependency Include="xunit" Version="$(XunitPackageVersion)" />
-  </ItemGroup>
-
-</Project>
--- a/build/repo.props
+++ b/build/repo.props
@ -1,136 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <!-- This repo does not have solutions to build -->
-    <DisableDefaultTargets>true</DisableDefaultTargets>
-    <DisableDefaultItems>true</DisableDefaultItems>
-    <BuildSolutions>false</BuildSolutions>
-
-    <SkipTests>false</SkipTests>
-    <SkipTests Condition="'$(CompileOnly)' == 'true'">true</SkipTests>
-    <IsFinalBuild Condition="'$(IsFinalBuild)' == ''">false</IsFinalBuild>
-
-    <SubmoduleRoot>$(RepositoryRoot)modules\</SubmoduleRoot>
-
-    <DependencyPackageDir>$(RepositoryRoot).deps\build\</DependencyPackageDir>
-    <SignedDependencyPackageDir>$(RepositoryRoot).deps\Signed\Packages\</SignedDependencyPackageDir>
-    <SharedSourcesFolder>$(RepositoryRoot)src\Shared\</SharedSourcesFolder>
-    <SharedFxArchitecture Condition="'$(SharedFxArchitecture)' == ''">$(SharedFxRid.Substring($([MSBuild]::Add($(SharedFxRid.LastIndexOf('-')), 1))))</SharedFxArchitecture>
-    <BuildSiteExtension>false</BuildSiteExtension>
-    <BuildSiteExtension Condition="'$(BuildSiteExtension)' == 'true' AND '$(OS)' != 'Windows_NT'">false</BuildSiteExtension>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <SharedSourceDirectories Include="$(SharedSourcesFolder)Hosting.WebHostBuilderFactory\" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <IntermediateInstaller Include="win-x86" FileExt=".zip" />
-    <IntermediateInstaller Include="win-x86" FileExt=".wixlib" />
-    <IntermediateInstaller Include="win-x64" FileExt=".zip" />
-    <IntermediateInstaller Include="win-x64" FileExt=".wixlib" />
-    <IntermediateInstaller Include="osx-x64" FileExt=".tar.gz" />
-    <IntermediateInstaller Include="linux-x64" FileExt=".tar.gz" />
-    <IntermediateInstaller Include="linux-arm" FileExt=".tar.gz" />
-    <IntermediateInstaller Include="linux-musl-x64" FileExt=".tar.gz" />
-
-    <NativeInstaller Include="win-x86" FileExt=".exe" />
-    <NativeInstaller Include="win-x86" FileExt=".zip" />
-    <NativeInstaller Include="win-x64" FileExt=".exe" />
-    <NativeInstaller Include="win-x64" FileExt=".zip" />
-    <NativeInstaller Include="osx-x64" FileExt=".tar.gz" />
-    <NativeInstaller Include="linux-x64" FileExt=".tar.gz" />
-    <NativeInstaller Include="linux-arm" FileExt=".tar.gz" />
-    <NativeInstaller Include="linux-musl-x64" FileExt=".tar.gz" />
-    <NativeInstaller Include="x64" FileExt=".deb" />
-    <NativeInstaller Include="x64" FileExt=".rpm" />
-    <NativeInstaller Include="rh.rhel.7-x64" FileExt=".rpm" />
-
-    <SharedFrameworkName Include="Microsoft.AspNetCore.All" />
-    <SharedFrameworkName Include="Microsoft.AspNetCore.App" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <!-- These projects use 'legacy' csproj, which is not supported by dotnet-msbuild. -->
-    <ProjectToExclude Include="
-                      $(RepositoryRoot)src\Servers\HttpSys\samples\TestClient\TestClient.csproj;
-                      $(RepositoryRoot)src\Middleware\WebSockets\samples\TestServer\TestServer.csproj;
-                      $(RepositoryRoot)src\Identity\samples\NativeWPFClient\NativeWPFClient.csproj;
-                      "
-                      Condition=" '$(MSBuildRuntimeType)' == 'Core' " />
-
-    <!-- Exclude the websockets samples for now because they use classic .csproj, which is not yet supported in our build. -->
-    <ProjectToExclude Include="
-                      $(RepositoryRoot)src\Middleware\WebSockets\samples\**\*.csproj;
-                      $(RepositoryRoot)src\Middleware\NodeServices.Sockets\**\*.csproj;
-                      $(RepositoryRoot)src\Tools\dotnet-watch\test\TestProjects\**\*.csproj;
-                      $(RepositoryRoot)src\Razor\Razor.Design\test\testassets\**\*.*proj;
-                      $(RepositoryRoot)src\SignalR\clients\cpp\**\*.*proj;
-                      $(RepositoryRoot)src\SignalR\clients\ts\**\node_modules\**\*.*proj;
-                      " />
-  </ItemGroup>
-
-  <Choose>
-    <!-- Project selection can be overridden on the command line by passing in -projects -->
-    <When Condition="'$(Projects)' != ''">
-      <ItemGroup>
-        <ProjectToBuild Include="$(Projects)" Exclude="@(ProjectToExclude)">
-          <RestoreInParallel Condition="'%(Extension)' == '.npmproj'">false</RestoreInParallel>
-        </ProjectToBuild>
-      </ItemGroup>
-    </When>
-    <Otherwise>
-      <ItemGroup>
-        <ProjectToBuild Condition="'$(SkipNpm)' != 'true'"
-                        Include="$(RepositoryRoot)src\SignalR\**\*.npmproj"
-                        RestoreInParallel="false"
-                        Exclude="@(ProjectToExclude)" />
-
-        <ProjectToBuild Include="
-                          $(RepositoryRoot)src\DefaultBuilder\**\*.*proj;
-                          $(RepositoryRoot)src\Features\JsonPatch\**\*.*proj;
-                          $(RepositoryRoot)src\DataProtection\**\*.*proj;
-                          $(RepositoryRoot)src\Antiforgery\**\*.*proj;
-                          $(RepositoryRoot)src\Hosting\**\*.*proj;
-                          $(RepositoryRoot)src\Http\**\*.*proj;
-                          $(RepositoryRoot)src\Html\**\*.*proj;
-                          $(RepositoryRoot)src\Identity\**\*.*proj;
-                          $(RepositoryRoot)src\Servers\**\*.csproj;
-                          $(RepositoryRoot)src\Servers\**\*.pkgproj;
-                          $(RepositoryRoot)src\Security\**\*.*proj;
-                          $(RepositoryRoot)src\Shared\**\*.*proj;
-                          $(RepositoryRoot)src\Tools\**\*.*proj;
-                          $(RepositoryRoot)src\Middleware\**\*.*proj;
-                          $(RepositoryRoot)src\Razor\**\*.*proj;
-                          $(RepositoryRoot)src\Mvc\**\*.*proj;
-                          $(RepositoryRoot)src\Azure\**\*.*proj;
-                          $(RepositoryRoot)src\MusicStore\**\*.*proj;
-                          $(RepositoryRoot)src\SignalR\**\*.csproj;
-                          "
-                        Exclude="
-                          @(ProjectToExclude);
-                          $(RepositoryRoot)**\node_modules\**\*;
-                          $(RepositoryRoot)**\bin\**\*;
-                          $(RepositoryRoot)**\obj\**\*;">
-          <RestoreInParallel Condition="'%(Extension)' == '.npmproj'">false</RestoreInParallel>
-        </ProjectToBuild>
-      </ItemGroup>
-    </Otherwise>
-  </Choose>
-
-  <!-- Properties for publishing -->
-  <PropertyGroup>
-    <!-- myget = non-orchestrated builds -->
-    <PublishToMyGet Condition=" $(PublishType.Contains('myget')) ">true</PublishToMyGet>
-    <!-- azure = non-orchestrated builds -->
-    <PublishToAzureFeed Condition="$(PublishType.Contains('azure'))">true</PublishToAzureFeed>
-
-    <!-- blob = orchestrated builds -->
-    <PublishToTransportFeed Condition="$(PublishType.Contains('blob'))">true</PublishToTransportFeed>
-  </PropertyGroup>
-
-  <Import Project="runtimes.props" />
-  <Import Project="sources.props" />
-  <Import Project="external-dependencies.props" />
-  <Import Project="artifacts.props" />
-  <Import Project="submodules.props" />
-</Project>
--- a/build/repo.targets
+++ b/build/repo.targets
@ -1,277 +0,0 @@
-<Project>
-  <Import Project="RepositoryBuild.targets" />
-  <Import Project="PackageArchive.targets" />
-  <Import Project="SharedFx.targets" />
-  <Import Project="SharedFxInstaller.targets" />
-  <Import Project="Publish.targets" />
-  <Import Project="buildorder.props" />
-
-  <PropertyGroup>
-    <GeneratedPackageVersionPropsPath>$(IntermediateDir)dependencies.g.props</GeneratedPackageVersionPropsPath>
-    <GeneratedRestoreSourcesPropsPath>$(IntermediateDir)sources.g.props</GeneratedRestoreSourcesPropsPath>
-    <GeneratedBrandingPropsPath>$(IntermediateDir)branding.g.props</GeneratedBrandingPropsPath>
-
-    <PrepareDependsOn>SetTeamCityBuildNumberToVersion;$(PrepareDependsOn)</PrepareDependsOn>
-    <PrepareDependsOn Condition="'$(_ProjectsOnly)' != 'true'">$(PrepareDependsOn);VerifyPackageArtifactConfig;VerifyExternalDependencyConfig;PrepareOutputPaths</PrepareDependsOn>
-    <CleanDependsOn>$(CleanDependsOn);CleanArtifacts;CleanRepoArtifacts</CleanDependsOn>
-    <RestoreDependsOn>$(RestoreDependsOn);InstallDotNet;RestoreProjects</RestoreDependsOn>
-    <CompileDependsOn>$(CompileDependsOn);BuildProjects;PackSharedSources</CompileDependsOn>
-    <CompileDependsOn Condition="'$(_ProjectsOnly)' != 'true'">$(CompileDependsOn);PackProjects;BuildRepositories</CompileDependsOn>
-    <PackageDependsOn Condition=" '$(_ProjectsOnly)' == 'true'">$(PackageDependsOn);PackProjects</PackageDependsOn>
-    <PackageDependsOn Condition="'$(TestOnly)' != 'true' AND '$(_ProjectsOnly)' != 'true'">$(PackageDependsOn);BuildMetapackages;BuildSiteExtension;CheckExpectedPackagesExist</PackageDependsOn>
-    <TestDependsOn>$(TestDependsOn);TestProjects</TestDependsOn>
-    <TestDependsOn Condition="'$(_ProjectsOnly)' != 'true'">$(TestDependsOn);_TestRepositories</TestDependsOn>
-    <GetArtifactInfoDependsOn>$(GetArtifactInfoDependsOn);GetProjectArtifactInfo</GetArtifactInfoDependsOn>
-    <GetArtifactInfoDependsOn>$(GetArtifactInfoDependsOn);ResolveSharedSourcesPackageInfo</GetArtifactInfoDependsOn>
-    <GetArtifactInfoDependsOn  Condition="'$(_ProjectsOnly)' != 'true'">$(GetArtifactInfoDependsOn);ResolveRepoInfo</GetArtifactInfoDependsOn>
-  </PropertyGroup>
-
-  <Target Name="PrepareOutputPaths">
-    <MakeDir Directories="$(ArtifactsDir);$(BuildDir)" />
-  </Target>
-
-  <Target Name="GenerateProjectList" DependsOnTargets="ResolveProjects">
-    <MSBuild Projects="@(ProjectToBuild)"
-             Targets="GetReferencesProvided"
-             BuildInParallel="true"
-             SkipNonexistentTargets="true"
-             SkipNonexistentProjects="true" >
-
-      <Output TaskParameter="TargetOutputs" ItemName="_ProjectReferenceProvider"/>
-    </MSBuild>
-
-    <PropertyGroup>
-      <ProjectListFile>$(MSBuildThisFileDirectory)..\eng\ProjectReferences.props</ProjectListFile>
-      <ProjectListContent>
-      <![CDATA[
-<!--
-  This file is automatically generated. Run `build.cmd /t:GenerateProjectList` to update.
-
-  This file contains a map of assembly names to the projects that build them.
-->
-<Project>
-  <ItemGroup>
-    @(_ProjectReferenceProvider->'<ProjectReferenceProvider Include="%(Identity)" ProjectPath="%24(RepositoryRoot)%(ProjectFileRelativePath)" />', '%0A    ')
-  </ItemGroup>
-</Project>
-      ]]>
-      </ProjectListContent>
-    </PropertyGroup>
-
-    <WriteLinesToFile File="$(ProjectListFile)" Lines="$(ProjectListContent)" Overwrite="true" />
-  </Target>
-
-  <Target Name="_ResolveProjectArtifactsInfoShipped" AfterTargets="GetProjectArtifactInfo">
-    <ItemGroup>
-      <ShippedArtifactInfo Include="@(ArtifactInfo)" Condition="'%(ArtifactInfo.IsShipped)' == 'true'" />
-      <ArtifactInfo Remove="@(ShippedArtifactInfo)" />
-    </ItemGroup>
-  </Target>
-
-  <Target Name="ResolveRepoInfo" DependsOnTargets="_ResolveProjectArtifactsInfoShipped;_PrepareRepositories;GetMetapackageArtifactInfo;GetSiteExtensionArtifactInfo">
-    <!-- We need to pass the NETCoreApp package versions to msbuild so that it doesn't complain about us using a different one than it was restored against.  -->
-    <PropertyGroup>
-      <DesignTimeBuildProps>MicrosoftNETCoreAppPackageVersion=$(MicrosoftNETCoreAppPackageVersion);</DesignTimeBuildProps>
-      <DesignTimeBuildProps>$(DesignTimeBuildProps);MicrosoftNETCoreApp21PackageVersion=$(MicrosoftNETCoreApp21PackageVersion);</DesignTimeBuildProps>
-      <DesignTimeBuildProps>$(DesignTimeBuildProps);MicrosoftNETCoreApp20PackageVersion=$(MicrosoftNETCoreApp20PackageVersion);</DesignTimeBuildProps>
-    </PropertyGroup>
-
-    <MSBuild Projects="$(MSBuildProjectFullPath)"
-             Targets="GetArtifactInfo"
-             Properties="$(DesignTimeBuildProps);RepositoryRoot=%(Repository.RootPath);Configuration=$(Configuration);BuildNumber=$(BuildNumber);DesignTimeBuild=true"
-             ContinueOnError="WarnAndContinue"
-             Condition="'%(Repository.Identity)' != ''">
-      <Output TaskParameter="TargetOutputs" ItemName="ArtifactInfo" />
-    </MSBuild>
-
-    <MSBuild Projects="$(MSBuildProjectFullPath)"
-             Targets="ResolveSolutions"
-             Properties="RepositoryRoot=%(Repository.RootPath);Configuration=$(Configuration);BuildNumber=$(BuildNumber)"
-             ContinueOnError="WarnAndContinue"
-             Condition="'%(Repository.Identity)' != ''">
-      <Output TaskParameter="TargetOutputs" ItemName="Solution" Condition="'%(Repository.Build)' == 'true'" />
-      <Output TaskParameter="TargetOutputs" ItemName="_NoBuildSolution" Condition="'%(Repository.Build)' != 'true'" />
-    </MSBuild>
-
-    <!--
-      Analyze what was shipped in these repos.
-      This is required so we can verify that cascading versions are consistent.
-    -->
-    <MSBuild Projects="$(MSBuildProjectFullPath)"
-             Targets="GetArtifactInfo"
-             Properties="$(DesignTimeBuildProps);RepositoryRoot=%(ShippedRepository.RootPath);Configuration=$(Configuration);BuildNumber=$(BuildNumber);IsFinalBuild=true;DesignTimeBuild=true"
-             ContinueOnError="WarnAndContinue"
-             Condition="'%(ShippedRepository.Identity)' != ''">
-      <Output TaskParameter="TargetOutputs" ItemName="ShippedArtifactInfo" />
-    </MSBuild>
-    <MSBuild Projects="$(MSBuildProjectFullPath)"
-             Targets="ResolveSolutions"
-             Properties="RepositoryRoot=%(ShippedRepository.RootPath);Configuration=$(Configuration);BuildNumber=$(BuildNumber)"
-             ContinueOnError="WarnAndContinue"
-             Condition="'%(ShippedRepository.Identity)' != ''">
-      <Output TaskParameter="TargetOutputs" ItemName="_ShippedSolution" />
-    </MSBuild>
-
-    <ItemGroup>
-      <_Temp Remove="@(_Temp)" />
-      <_Temp Include="@(PackageArtifact)" />
-      <PackageArtifact Remove="@(PackageArtifact)" />
-    </ItemGroup>
-
-    <!-- Join required because shipping category is stored in artifact.props (PackageArtifact), but information about package ID and version comes from repos (ArtifactInfo). -->
-    <RepoTasks.JoinItems
-      Left="@(_Temp)"
-      LeftMetadata="*"
-      Right="@(ArtifactInfo->WithMetadataValue('ArtifactType','NuGetPackage'));@(ShippedArtifactInfo->WithMetadataValue('ArtifactType','NuGetPackage'))"
-      RightKey="PackageId"
-      RightMetadata="Version">
-      <Output TaskParameter="JoinResult" ItemName="PackageArtifact" />
-    </RepoTasks.JoinItems>
-
-    <ItemGroup>
-      <_PackageArtifactWithoutMatchingInfo Include="@(_Temp)" Exclude="@(PackageArtifact)" />
-    </ItemGroup>
-
-    <Error Text="Could not detect version information for package id:%0A * @(_PackageArtifactWithoutMatchingInfo, '%0A * ')"
-           Condition="@(_PackageArtifactWithoutMatchingInfo->Count()) != 0" />
-
-    <ItemGroup>
-      <!-- Adjust the list of what is considered external vs locally built. -->
-      <ExternalDependency Include="%(ShippedArtifactInfo.PackageId)" Condition="'%(ShippedArtifactInfo.ArtifactType)' == 'NuGetPackage'">
-        <Version>%(ShippedArtifactInfo.Version)</Version>
-      </ExternalDependency>
-
-      <!-- capture the original list of PackageArtifacts -->
-      <_PackageArtifactSpec Include="@(PackageArtifact)" />
-
-      <PackageArtifact Remove="%(ShippedArtifactInfo.PackageId)" Condition="'%(ShippedArtifactInfo.ArtifactType)' == 'NuGetPackage'" />
-
-      <Solution Update="@(Solution)" Build="true" IsPatching="true" />
-      <_ShippedSolution Update="@(_ShippedSolution)" Build="false" IsPatching="false" />
-      <_NoBuildSolution Update="@(_NoBuildSolution)" Build="false" />
-      <Solution Include="@(_NoBuildSolution);@(_ShippedSolution)" />
-    </ItemGroup>
-
-    <Error Text="No solutions were found in '$(SubmoduleRoot)'. Did you forget to clone the submodules? Run `git submodule update --init`." Condition="@(Solution->Count()) == 0" />
-  </Target>
-
-  <Target Name="GeneratePropsFiles" DependsOnTargets="PrepareOutputPaths;GetArtifactInfo">
-    <ItemGroup>
-      <_LineupPackages Include="@(ExternalDependency)" />
-      <_LineupPackages Include="%(ArtifactInfo.PackageId)" Version="%(ArtifactInfo.Version)" Condition=" '%(ArtifactInfo.ArtifactType)' == 'NuGetPackage' " />
-
-      <_RestoreSources Include="$(DependencyPackageDir)" Condition="'$(DependencyPackageDir)' != '' AND Exists('$(DependencyPackageDir)')" />
-      <_RestoreSources Include="$(SignedDependencyPackageDir)" Condition="'$(SignedDependencyPackageDir)' != '' AND Exists('$(SignedDependencyPackageDir)')" />
-      <_RestoreSources Include="$(BuildDir)" />
-      <_RestoreSources Include="$(RestoreSources)" />
-    </ItemGroup>
-
-    <GeneratePackageVersionPropsFile
-      Packages="@(_LineupPackages)"
-      OutputPath="$(GeneratedPackageVersionPropsPath)" />
-
-    <Copy SourceFiles="$(GeneratedPackageVersionPropsPath)" DestinationFolder="$(ArtifactsDir)" />
-
-    <RepoTasks.GenerateRestoreSourcesPropsFile
-      Sources="@(_RestoreSources)"
-      OutputPath="$(GeneratedRestoreSourcesPropsPath)" />
-
-    <PropertyGroup>
-      <!-- Generate an MSBuild file that can be imported and used by Windows Installer builds to keep our versions consistent. -->
-      <BrandingPropsContent>
-<![CDATA[
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <AspNetCoreMajorVersion>$(AspNetCoreMajorVersion)</AspNetCoreMajorVersion>
-    <AspNetCoreMinorVersion>$(AspNetCoreMinorVersion)</AspNetCoreMinorVersion>
-    <AspNetCorePatchVersion>$(AspNetCorePatchVersion)</AspNetCorePatchVersion>
-    <AspNetCorePreReleaseVersionLabel>$(PreReleaseLabel)</AspNetCorePreReleaseVersionLabel>
-    <AspNetCoreBuildNumber>$(BuildNumber)</AspNetCoreBuildNumber>
-    <AspNetCoreBrandingVersion>$(PackageBrandingVersion)</AspNetCoreBrandingVersion>
-  </PropertyGroup>
-</Project>
-]]>
-      </BrandingPropsContent>
-    </PropertyGroup>
-
-    <WriteLinesToFile File="$(GeneratedBrandingPropsPath)" Overwrite="true" Lines="$(BrandingPropsContent)"/>
-
-    <Copy SourceFiles="$(GeneratedPackageVersionPropsPath);$(GeneratedBrandingPropsPath)" DestinationFolder="$(ArtifactsDir)" />
-  </Target>
-
-  <Target Name="CleanRepoArtifacts">
-    <RemoveDir Directories="$(RepositoryRoot)obj" Condition="Exists('$(RepositoryRoot)obj')" />
-  </Target>
-
-  <Target Name="_PrepareRepositories">
-    <ItemGroup>
-      <Repository Update="%(Identity)" RootPath="$(SubmoduleRoot)%(Identity)\" Condition="'%(Identity)' != '' AND '%(RootPath)' == ''"  />
-      <ShippedRepository Update="%(Identity)" RootPath="$(SubmoduleRoot)%(Identity)\" Condition="'%(Identity)' != '' AND '%(RootPath)' == ''" />
-    </ItemGroup>
-  </Target>
-
-  <Target Name="BuildRepositories"
-     DependsOnTargets="_PrepareRepositories;GeneratePropsFiles;ComputeGraph;_BuildRepositories" />
-
-  <Target Name="ListExpectedPackages" DependsOnTargets="ResolveSharedSourcesPackageInfo;GetProjectArtifactInfo;ResolveRepoInfo">
-    <WriteLinesToFile File="$(RepositoryRoot)artifacts\packages.csv" Lines="PackageId,Version;@(ArtifactInfo->WithMetadataValue('ArtifactType', 'NuGetPackage')->'%(PackageId),%(Version)')" Overwrite="true" />
-  </Target>
-
-  <Target Name="ComputeGraph" DependsOnTargets="ResolveSharedSourcesPackageInfo;GetProjectArtifactInfo;ResolveRepoInfo;GeneratePropsFiles">
-    <ItemGroup>
-      <_UndeclaredPackageArtifact Include="%(ArtifactInfo.PackageId)" Condition="'%(ArtifactInfo.ArtifactType)' == 'NuGetPackage'" />
-      <_UndeclaredPackageArtifact Remove="@(PackageArtifact)" />
-      <RepositoryBuildOrder Remove="@(ShippedRepository)" />
-    </ItemGroup>
-
-    <Error Text="Undeclared package artifacts. Add these to artifacts.props:%0A  - @(_UndeclaredPackageArtifact, '%0A  - ')"
-      Condition=" @(_UndeclaredPackageArtifact->Count()) != 0 " />
-
-    <Message Text="Repository build order:" Importance="high" />
-    <Message Text="%(RepositoryBuildOrder.Order). @(RepositoryBuildOrder, ', ')" Importance="high" />
-  </Target>
-
-  <Target Name="VerifyPackageArtifactConfig">
-    <Error Text="Invalid configuration of %(PackageArtifact.Identity). PackageArtifact must have the 'Category' metadata."
-           Condition="'%(PackageArtifact.Category)' == '' " />
-
-    <Error Text="Invalid configuration of %(PackageArtifact.Identity). Packages marked as LZMA='true' must be Category='ship'."
-           Condition="'%(PackageArtifact.Category)' != 'ship' AND '%(PackageArtifact.LZMA)' == 'true' " />
-
- 	  <Error Text="Invalid configuration of %(PackageArtifact.Identity). Packages marked as AppMetapackage='true' must be Category='ship'."
-           Condition="'%(PackageArtifact.Category)' != 'ship' AND '%(PackageArtifact.AppMetapackage)' == 'true' " />
-
-    <Error Text="Invalid configuration of %(PackageArtifact.Identity). Packages marked as AllMetapackage='true' must be Category='ship'."
-           Condition="'%(PackageArtifact.Category)' != 'ship' AND '%(PackageArtifact.AllMetapackage)' == 'true' " />
-
-    <Error Text="Invalid configuration of %(PackageArtifact.Identity). Packages marked as AppMetapackage='true' must also be marked as AllMetapackage='true'."
-           Condition="'%(PackageArtifact.AppMetapackage)' == 'true' AND '%(PackageArtifact.AllMetapackage)' != 'true' " />
-  </Target>
-
-  <Target Name="VerifyExternalDependencyConfig">
-    <RepoTasks.CheckVersionOverrides DotNetPackageVersionPropsPath="$(DotNetPackageVersionPropsPath)"
-      DependenciesFile="$(MSBuildThisFileDirectory)dependencies.props"
-      Condition="'$(DotNetPackageVersionPropsPath)' != ''" />
-
-    <Error Text="Missing Version metadata for the following external dependencies: %0A - @(ExternalDependency->WithMetadataValue('Version', ''), '%0A - '). "
-           Condition=" @(ExternalDependency->WithMetadataValue('Version', '')->Count()) != 0 " />
-  </Target>
-
-  <Target Name="FastCheck"
-    DependsOnTargets="ComputeGraph;VerifyPackageArtifactConfig;VerifyAllReposHaveNuGetPackageVerifier" />
-
-  <Target Name="CheckExpectedPackagesExist">
-    <ItemGroup>
-      <PackageArtifactFile Include="$(BuildDir)*.nupkg" Exclude="$(BuildDir)*.symbols.nupkg" />
-    </ItemGroup>
-
-    <RepoTasks.CheckExpectedPackagesExist Packages="@(PackageArtifact)" Files="@(PackageArtifactFile)" />
-  </Target>
-
-  <Target Name="VerifyAllReposHaveNuGetPackageVerifier" DependsOnTargets="_PrepareRepositories">
-    <Error Condition="'%(Repository.Identity)' != '' AND !Exists('%(Repository.RootPath)NuGetPackageVerifier.json')"
-           Text="Repository %(Repository.Identity) is missing NuGetPackageVerifier.json. Expected file to exist in %(Repository.RootPath)NuGetPackageVerifier.json" />
-  </Target>
-
-</Project>
--- a/build/runtimes.props
+++ b/build/runtimes.props
@ -1,24 +0,0 @@
-<Project>
-
-  <ItemGroup>
-    <!-- Explicitly require the 2.0.x and 2.1.0-* version of shared runtime used by ASP.NET Core -->
-    <DotNetCoreRuntime Include="$(MicrosoftNETCoreApp20PackageVersion)" Condition="'$(SharedFXRid)' != 'linux-musl-x64'" />
-
-    <DotNetCoreRuntime Include="$(MicrosoftNETCoreApp21PackageVersion)"
-      Feed="$(DotNetAssetRootUrl)"
-      FeedCredential="$(DotNetAssetRootAccessTokenSuffix)" />
-
-    <DotNetCoreRuntime Condition="'$(OS)' == 'Windows_NT'"
-      Include="$(MicrosoftNETCoreApp21PackageVersion)"
-      Arch="x86"
-      Feed="$(DotNetAssetRootUrl)"
-      FeedCredential="$(DotNetAssetRootAccessTokenSuffix)" />
-
-      <!--
-        The build doesn't support compiling the shared runtime on one machine along with running tests,
-        so this is enables installing the shared runtime from a previous build.
-      -->
-      <AspNetCoreRuntime Include="$(PackageVersion)" Feed="$(AspNetCoreFxFeed)" Condition="'$(InstallSharedRuntimeFromPreviousBuild)' == 'true'" />
-  </ItemGroup>
-
-</Project>
--- a/build/sources.props
+++ b/build/sources.props
@ -1,24 +0,0 @@
-<Project>
-
-  <Import Project="$(DotNetRestoreSourcePropsPath)" Condition="'$(DotNetRestoreSourcePropsPath)' != ''"/>
-
-  <PropertyGroup>
-    <RestoreSources>
-      $(DotNetAdditionalRestoreSources);
-      $(DotNetRestoreSources);
-    </RestoreSources>
-    <RestoreSources Condition=" '$(DotNetBuildOffline)' != 'true' ">
-      $(RestoreSources);
-      https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json;
-      https://api.nuget.org/v3/index.json;
-    </RestoreSources>
-    <RestoreSources Condition=" '$(DotNetBuildOffline)' != 'true' AND '$(DisableMyGetRestoreSources)' != 'true' ">
-      $(RestoreSources);
-      https://dotnet.myget.org/F/aspnetcore-tools/api/v3/index.json;
-      https://dotnet.myget.org/F/aspnetcore-master/api/v3/index.json;
-      https://dotnet.myget.org/F/roslyn/api/v3/index.json;
-      https://pkgs.dev.azure.com/azure-public/vside/_packaging/vssdk/nuget/v3/index.json;
-      https://pkgs.dev.azure.com/azure-public/vside/_packaging/vs-impl/nuget/v3/index.json;
-    </RestoreSources>
-  </PropertyGroup>
-</Project>
--- a/build/submodules.props
+++ b/build/submodules.props
@ -1,42 +0,0 @@
-<Project>
-  <ItemDefinitionGroup>
-    <Repository>
-      <Build>true</Build>
-
-      <!--
-        Specifies the ruleset used to determine if a repo should build in a patch update, or not.
-        The default is ProductChangesOnly.
-
-        Rulesets:
-          ProductChangeOnly
-            Only produce new package versions if there were changes to product code.
-            Examples: this is the default. Most repos should use this policy.
-
-          CascadeVersion
-            Produce new package versions if there were changes to product code, or if one of the package dependencies has updated.
-            Examples: metapackages which are not top-level, but should still be used to help users get the latest transitive set of dependencies
-
-          AlwaysUpdate
-            Packages should update in every patch.
-            Examples: top-level metapackages and templates.
-
-       -->
-      <PatchPolicy>ProductChangesOnly</PatchPolicy>
-      <RootPath></RootPath>
-    </Repository>
-    <ShippedRepository>
-      <Build>false</Build>
-      <PatchPolicy>ProductChangesOnly</PatchPolicy>
-      <RootPath></RootPath>
-    </ShippedRepository>
-  </ItemDefinitionGroup>
-
-  <PropertyGroup>
-    <TestsRequiredTheSharedRuntime Condition="'$(RepositoryToBuild)' == 'Templating'">true</TestsRequiredTheSharedRuntime>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <Repository Include="Templating" PatchPolicy="AlwaysUpdateAndCascadeVersions" RootPath="$(RepositoryRoot)src\Templating\" />
-    <ShippedRepository Include="EntityFrameworkCore" />
-  </ItemGroup>
-</Project>
--- a/build/tasks/AddMetapackageReferences.cs
+++ b/build/tasks/AddMetapackageReferences.cs
@ -1,134 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System;
-using System.Linq;
-using System.Xml;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-using NuGet.Versioning;
-using RepoTasks.Utilities;
-
-namespace RepoTasks
-{
-    public class AddMetapackageReferences : Task
-    {
-        [Required]
-        public string ReferencePackagePath { get; set; }
-
-        [Required]
-        public string MetapackageReferenceType { get; set; }
-
-        [Required]
-        public string DependencyVersionRangeType { get; set; }
-
-        // MSBuild doesn't allow binding to enums directly.
-        private enum VersionRangeType
-        {
-            Minimum, // [1.1.1, )
-            MajorMinor, // [1.1.1, 1.2.0)
-        }
-
-        [Required]
-        public ITaskItem[] PackageArtifacts { get; set; }
-
-        [Required]
-        public ITaskItem[] ExternalDependencies { get; set; }
-
-        public override bool Execute()
-        {
-            if (!Enum.TryParse<VersionRangeType>(DependencyVersionRangeType, out var dependencyVersionType))
-            {
-                Log.LogError("Unexpected value {0} for DependencyVersionRangeType", DependencyVersionRangeType);
-                return false;
-            }
-
-            // Parse input
-            var metapackageArtifacts = PackageArtifacts.Where(p => p.GetMetadata(MetapackageReferenceType) == "true");
-            var externalArtifacts = ExternalDependencies.Where(p => p.GetMetadata(MetapackageReferenceType) == "true");
-
-            var xmlDoc = new XmlDocument();
-            xmlDoc.Load(ReferencePackagePath);
-
-            // Project
-            var projectElement = xmlDoc.FirstChild;
-
-            // Items
-            var itemGroupElement = xmlDoc.CreateElement("ItemGroup");
-            Log.LogMessage(MessageImportance.High, $"{MetapackageReferenceType} will include the following packages");
-
-            foreach (var package in metapackageArtifacts)
-            {
-                var packageName = package.ItemSpec;
-                var packageVersion = package.GetMetadata("Version");
-                if (string.IsNullOrEmpty(packageVersion))
-                {
-                    Log.LogError("Missing version information for package {0}", packageName);
-                    continue;
-                }
-
-                var packageVersionValue = GetDependencyVersion(dependencyVersionType, packageName, packageVersion);
-                Log.LogMessage(MessageImportance.High, $" - Package: {packageName} Version: {packageVersionValue}");
-
-                var packageReferenceElement = xmlDoc.CreateElement("PackageReference");
-                packageReferenceElement.SetAttribute("Include", packageName);
-                packageReferenceElement.SetAttribute("Version", packageVersionValue);
-                packageReferenceElement.SetAttribute("PrivateAssets", "None");
-
-                itemGroupElement.AppendChild(packageReferenceElement);
-            }
-
-            foreach (var package in externalArtifacts)
-            {
-                var packageName = package.ItemSpec;
-                var packageVersion = package.GetMetadata("Version");
-
-                if (string.IsNullOrEmpty(packageVersion))
-                {
-                    Log.LogError("Missing version information for package {0}", packageName);
-                    continue;
-                }
-
-                var packageVersionValue =
-                    Enum.TryParse<VersionRangeType>(package.GetMetadata("MetapackageVersionRangeType"), out var packageVersionType)
-                    ? GetDependencyVersion(packageVersionType, packageName, packageVersion)
-                    : GetDependencyVersion(dependencyVersionType, packageName, packageVersion);
-
-                Log.LogMessage(MessageImportance.High, $" - Package: {packageName} Version: {packageVersionValue}");
-
-                var packageReferenceElement = xmlDoc.CreateElement("PackageReference");
-                packageReferenceElement.SetAttribute("Include", packageName);
-                packageReferenceElement.SetAttribute("Version", packageVersionValue);
-                packageReferenceElement.SetAttribute("PrivateAssets", "None");
-
-                itemGroupElement.AppendChild(packageReferenceElement);
-            }
-
-            projectElement.AppendChild(itemGroupElement);
-
-            // Save updated file
-            xmlDoc.AppendChild(projectElement);
-            xmlDoc.Save(ReferencePackagePath);
-
-            return !Log.HasLoggedErrors;
-        }
-
-        private string GetDependencyVersion(VersionRangeType dependencyVersionType, string packageName, string packageVersion)
-        {
-            switch (dependencyVersionType)
-            {
-                case VersionRangeType.MajorMinor:
-                    if (!NuGetVersion.TryParse(packageVersion, out var nugetVersion))
-                    {
-                        Log.LogError("Invalid NuGet version '{0}' for package {1}", packageVersion, packageName);
-                        return null;
-                    }
-                    return $"[{packageVersion}, {nugetVersion.Major}.{nugetVersion.Minor + 1}.0)";
-                case VersionRangeType.Minimum:
-                    return packageVersion;
-                default:
-                    throw new NotImplementedException();
-            }
-        }
-    }
-}
--- a/build/tasks/CheckExpectedPackagesExist.cs
+++ b/build/tasks/CheckExpectedPackagesExist.cs
@ -1,69 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using Microsoft.Build.Framework;
-using NuGet.Packaging;
-using NuGet.Packaging.Core;
-using RepoTasks.Utilities;
-
-namespace RepoTasks
-{
-    public class CheckExpectedPackagesExist : Microsoft.Build.Utilities.Task
-    {
-        /// <summary>
-        /// The item group containing the nuget packages to split in different folders.
-        /// </summary>
-        [Required]
-        public ITaskItem[] Packages { get; set; }
-
-        [Required]
-        public ITaskItem[] Files { get; set; }
-
-        public override bool Execute()
-        {
-            if (Files?.Length == 0)
-            {
-                Log.LogError("No packages were found.");
-                return false;
-            }
-
-            var expectedPackages = new HashSet<string>(Packages.Select(i => i.ItemSpec), StringComparer.OrdinalIgnoreCase);
-
-            foreach (var file in Files)
-            {
-                PackageIdentity identity;
-                using (var reader = new PackageArchiveReader(file.ItemSpec))
-                {
-                    identity = reader.GetIdentity();
-                }
-
-                if (!expectedPackages.Contains(identity.Id))
-                {
-                    Log.LogError($"Unexpected package artifact with id: {identity.Id}");
-                    continue;
-                }
-
-                expectedPackages.Remove(identity.Id);
-            }
-
-            if (expectedPackages.Count != 0)
-            {
-                var error = new StringBuilder();
-                foreach (var id in expectedPackages)
-                {
-                    error.Append(" - ").AppendLine(id);
-                }
-
-                Log.LogError($"Expected the following packages, but they were not found:" + error.ToString());
-                return false;
-            }
-
-            return !Log.HasLoggedErrors;
-        }
-    }
-}
--- a/build/tasks/CheckVersionOverrides.cs
+++ b/build/tasks/CheckVersionOverrides.cs
@ -1,45 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System;
-using System.Linq;
-using Microsoft.Build.Construction;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-
-namespace RepoTasks
-{
-    public class CheckVersionOverrides : Task
-    {
-        [Required]
-        public string DotNetPackageVersionPropsPath { get; set; }
-
-        [Required]
-        public string DependenciesFile { get; set; }
-
-        public override bool Execute()
-        {
-            Log.LogMessage($"Verifying versions set in {DotNetPackageVersionPropsPath} match expected versions set in {DependenciesFile}");
-
-            var versionOverrides = ProjectRootElement.Open(DotNetPackageVersionPropsPath);
-            var dependencies = ProjectRootElement.Open(DependenciesFile);
-            var pinnedVersions = dependencies.PropertyGroups
-                .Where(p => string.Equals("Package Versions: Pinned", p.Label))
-                .SelectMany(p => p.Properties)
-                .ToDictionary(p => p.Name, p => p.Value, StringComparer.OrdinalIgnoreCase);
-
-            foreach (var prop in versionOverrides.Properties)
-            {
-                if (pinnedVersions.TryGetValue(prop.Name, out var pinnedVersion))
-                {
-                    if (!string.Equals(pinnedVersion, prop.Value, StringComparison.OrdinalIgnoreCase))
-                    {
-                        Log.LogError($"The imported package version props file conflicts with a pinned version variable {prop.Name}. Imported value: {prop.Value}, Pinned value: {pinnedVersion}");
-                    }
-                }
-            }
-
-            return !Log.HasLoggedErrors;
-        }
-    }
-}
--- a/build/tasks/CreateLzma.cs
+++ b/build/tasks/CreateLzma.cs
@ -1,70 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System;
-using System.IO;
-using System.Threading;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-using Microsoft.DotNet.Archive;
-
-namespace RepoTasks
-{
-    public class CreateLzma : Task, ICancelableTask
-    {
-        private readonly CancellationTokenSource _cts = new CancellationTokenSource();
-
-        [Required]
-        public string OutputPath { get; set; }
-
-        [Required]
-        public string[] Sources { get; set; }
-
-        public void Cancel() => _cts.Cancel();
-
-        public override bool Execute()
-        {
-            var progress = new MSBuildProgressReport(Log, _cts.Token);
-            using (var archive = new IndexedArchive())
-            {
-                foreach (var source in Sources)
-                {
-                    if (Directory.Exists(source))
-                    {
-                        var trimmedSource = source.TrimEnd(new []{ '\\', '/' });
-                        Log.LogMessage(MessageImportance.High, $"Adding directory: {trimmedSource}");
-                        archive.AddDirectory(trimmedSource, progress);
-                    }
-                    else
-                    {
-                        Log.LogMessage(MessageImportance.High, $"Adding file: {source}");
-                        archive.AddFile(source, Path.GetFileName(source));
-                    }
-                }
-
-                archive.Save(OutputPath, progress);
-            }
-
-            return !Log.HasLoggedErrors;
-        }
-
-        private class MSBuildProgressReport : IProgress<ProgressReport>
-        {
-            private TaskLoggingHelper _log;
-            private readonly CancellationToken _cancellationToken;
-
-            public MSBuildProgressReport(TaskLoggingHelper log, CancellationToken cancellationToken)
-            {
-                _log = log;
-                _cancellationToken = cancellationToken;
-            }
-
-            public void Report(ProgressReport value)
-            {
-                var complete = (double)value.Ticks / value.Total;
-                _log.LogMessage(MessageImportance.Low, $"Progress: {value.Phase} - {complete:P}");
-                _cancellationToken.ThrowIfCancellationRequested(); // because LZMA apis don't take a cancellation token, throw from the logger (yes, its ugly, but it works.)
-            }
-        }
-    }
-}
--- a/build/tasks/GenerateRestoreSourcesPropsFile.cs
+++ b/build/tasks/GenerateRestoreSourcesPropsFile.cs
@ -1,55 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System;
-using System.Linq;
-using System.IO;
-using System.Text;
-using System.Xml;
-using System.Xml.Linq;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-
-namespace RepoTasks
-{
-    public class GenerateRestoreSourcesPropsFile : Task
-    {
-        [Required]
-        public ITaskItem[] Sources { get; set; }
-
-        [Required]
-        public string OutputPath { get; set; }
-
-        public override bool Execute()
-        {
-            OutputPath = OutputPath.Replace('\\', '/');
-            Directory.CreateDirectory(Path.GetDirectoryName(OutputPath));
-
-            var sources = new XElement("DotNetRestoreSources");
-            var propertyGroup = new XElement("PropertyGroup", sources);
-            var doc = new XDocument(new XElement("Project", propertyGroup));
-
-            propertyGroup.Add(new XElement("MSBuildAllProjects", "$(MSBuildAllProjects);$(MSBuildThisFileFullPath)"));
-
-            var sb = new StringBuilder();
-
-            foreach (var source in Sources)
-            {
-                sb.Append(source.ItemSpec).AppendLine(";");
-            }
-
-            sources.SetValue(sb.ToString());
-
-            var settings = new XmlWriterSettings
-            {
-                OmitXmlDeclaration = true,
-            };
-            using (var writer = XmlWriter.Create(OutputPath, settings))
-            {
-                Log.LogMessage(MessageImportance.Normal, $"Generate {OutputPath}");
-                doc.Save(writer);
-            }
-            return !Log.HasLoggedErrors;
-        }
-    }
-}
--- a/build/tasks/GetDocXmlFiles.cs
+++ b/build/tasks/GetDocXmlFiles.cs
@ -1,64 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using Microsoft.Build.Framework;
-using System;
-using System.Collections.Concurrent;
-using System.IO;
-using System.Threading.Tasks;
-using System.Xml.Linq;
-
-namespace RepoTasks
-{
-    /// <summary>
-    /// Filters a list of .xml files to only those that are .NET Xml docs files
-    /// </summary>
-    public class GetDocXmlFiles : Microsoft.Build.Utilities.Task
-    {
-        [Required]
-        public ITaskItem[] Files { get; set; }
-
-        [Output]
-        public ITaskItem[] XmlDocFiles { get; set; }
-
-        public override bool Execute()
-        {
-            var xmlDocs = new ConcurrentBag<ITaskItem>();
-            Parallel.ForEach(Files, f =>
-            {
-                try
-                {
-                    using (var file = File.OpenRead(f.ItemSpec))
-                    using (var reader = new StreamReader(file))
-                    {
-                        string line;
-                        for (var i = 0; i < 2; i++)
-                        {
-                            line = reader.ReadLine();
-                            if (i == 0 && line.StartsWith("<?xml", StringComparison.Ordinal))
-                            {
-                                line = line.Substring(line.IndexOf("?>") + 2);
-                            }
-
-                            if (line.StartsWith("<doc>", StringComparison.OrdinalIgnoreCase) || line.StartsWith("<doc xml:", StringComparison.OrdinalIgnoreCase))
-                            {
-                                xmlDocs.Add(f);
-                                return;
-                            }
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    Log.LogMessage(MessageImportance.Normal, $"Failed to read {f.ItemSpec}: {ex.ToString()}");
-                }
-
-                Log.LogMessage($"Did not detect {f.ItemSpec} as an xml doc file");
-            });
-
-            XmlDocFiles = xmlDocs.ToArray();
-            Log.LogMessage($"Found {XmlDocFiles.Length} xml doc file(s)");
-            return true;
-        }
-    }
-}
--- a/build/tasks/JoinItems.cs
+++ b/build/tasks/JoinItems.cs
@ -1,122 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-
-namespace RepoTasks
-{
-    public class JoinItems : Task
-    {
-        [Required]
-        public ITaskItem[] Left { get; set; }
-
-        [Required]
-        public ITaskItem[] Right { get; set; }
-
-        // The metadata to use as the new item spec. If not specified, LeftKey is used.
-        public string LeftItemSpec { get; set; }
-
-        //  LeftKey and RightKey: The metadata to join on.  If not set, then use the ItemSpec
-        public string LeftKey { get; set; }
-
-        public string RightKey { get; set; }
-
-
-        //  LeftMetadata and RightMetadata: The metadata names to include in the result.  Specify "*" to include all metadata
-        public string[] LeftMetadata { get; set; }
-
-        public string[] RightMetadata { get; set; }
-
-
-        [Output]
-        public ITaskItem[] JoinResult { get; private set; }
-
-        public override bool Execute()
-        {
-            bool useAllLeftMetadata = LeftMetadata != null && LeftMetadata.Length == 1 && LeftMetadata[0] == "*";
-            bool useAllRightMetadata = RightMetadata != null && RightMetadata.Length == 1 && RightMetadata[0] == "*";
-            var newItemSpec = string.IsNullOrEmpty(LeftItemSpec)
-                ? LeftKey
-                : LeftItemSpec;
-
-            JoinResult = Left.Join(Right,
-                item => GetKeyValue(LeftKey, item),
-                item => GetKeyValue(RightKey, item),
-                (left, right) =>
-                {
-                    //  If including all metadata from left items and none from right items, just return left items directly
-                    if (useAllLeftMetadata &&
-                        string.IsNullOrEmpty(LeftKey) &&
-                        string.IsNullOrEmpty(LeftItemSpec) &&
-                        (RightMetadata == null || RightMetadata.Length == 0))
-                    {
-                        return left;
-                    }
-
-                    //  If including all metadata from right items and none from left items, just return the right items directly
-                    if (useAllRightMetadata &&
-                        string.IsNullOrEmpty(RightKey) &&
-                        string.IsNullOrEmpty(LeftItemSpec) &&
-                        (LeftMetadata == null || LeftMetadata.Length == 0))
-                    {
-                        return right;
-                    }
-
-                    var ret = new TaskItem(GetKeyValue(newItemSpec, left));
-
-                    //  Weird ordering here is to prefer left metadata in all cases, as CopyToMetadata doesn't overwrite any existing metadata
-                    if (useAllLeftMetadata)
-                    {
-                        //  CopyMetadata adds an OriginalItemSpec, which we don't want.  So we subsequently remove it
-                        left.CopyMetadataTo(ret);
-                        ret.RemoveMetadata("OriginalItemSpec");
-                    }
-
-                    if (!useAllRightMetadata && RightMetadata != null)
-                    {
-                        foreach (string name in RightMetadata)
-                        {
-                            ret.SetMetadata(name, right.GetMetadata(name));
-                        }
-                    }
-
-                    if (!useAllLeftMetadata && LeftMetadata != null)
-                    {
-                        foreach (string name in LeftMetadata)
-                        {
-                            ret.SetMetadata(name, left.GetMetadata(name));
-                        }
-                    }
-
-                    if (useAllRightMetadata)
-                    {
-                        //  CopyMetadata adds an OriginalItemSpec, which we don't want.  So we subsequently remove it
-                        right.CopyMetadataTo(ret);
-                        ret.RemoveMetadata("OriginalItemSpec");
-                    }
-
-                    return (ITaskItem)ret;
-                },
-                StringComparer.OrdinalIgnoreCase).ToArray();
-
-            return true;
-        }
-
-        static string GetKeyValue(string key, ITaskItem item)
-        {
-            if (string.IsNullOrEmpty(key))
-            {
-                return item.ItemSpec;
-            }
-            else
-            {
-                return item.GetMetadata(key);
-            }
-        }
-    }
-}
--- a/build/tasks/Logger/MSBuildLogger.cs
+++ b/build/tasks/Logger/MSBuildLogger.cs
@ -1,200 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-using NuGet.Common;
-
-namespace NuGet.Build
-{
-    /// <summary>
-    /// TaskLoggingHelper -> ILogger
-    /// </summary>
-    internal class MSBuildLogger : LoggerBase, Common.ILogger
-    {
-        private readonly TaskLoggingHelper _taskLogging;
-
-        private delegate void LogMessageWithDetails(string subcategory,
-            string code,
-            string helpKeyword,
-            string file,
-            int lineNumber,
-            int columnNumber,
-            int endLineNumber,
-            int endColumnNumber,
-            MessageImportance importance,
-            string message,
-            params object[] messageArgs);
-
-        private delegate void LogErrorWithDetails(string subcategory,
-            string code,
-            string helpKeyword,
-            string file,
-            int lineNumber,
-            int columnNumber,
-            int endLineNumber,
-            int endColumnNumber,
-            string message,
-            params object[] messageArgs);
-
-        private delegate void LogMessageAsString(MessageImportance importance,
-            string message,
-            params object[] messageArgs);
-
-        private delegate void LogErrorAsString(string message,
-            params object[] messageArgs);
-
-        public MSBuildLogger(TaskLoggingHelper taskLogging)
-        {
-            _taskLogging = taskLogging ?? throw new ArgumentNullException(nameof(taskLogging));
-        }
-
-        public override void Log(ILogMessage message)
-        {
-            if (DisplayMessage(message.Level))
-            {
-                if (RuntimeEnvironmentHelper.IsMono)
-                {
-                    LogForMono(message);
-                    return;
-                }
-                else
-                {
-                    var logMessage = message as IRestoreLogMessage;
-
-                    if (logMessage == null)
-                    {
-                        logMessage = new RestoreLogMessage(message.Level, message.Message)
-                        {
-                            Code = message.Code,
-                            FilePath = message.ProjectPath
-                        };
-                    }
-                    LogForNonMono(logMessage);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Log using with metadata for non mono platforms.
-        /// </summary>
-        private void LogForNonMono(IRestoreLogMessage message)
-        {
-            switch (message.Level)
-            {
-                case LogLevel.Error:
-                    LogError(message, _taskLogging.LogError, _taskLogging.LogError);
-                    break;
-
-                case LogLevel.Warning:
-                    LogError(message, _taskLogging.LogWarning, _taskLogging.LogWarning);
-                    break;
-
-                case LogLevel.Minimal:
-                    LogMessage(message, MessageImportance.High, _taskLogging.LogMessage, _taskLogging.LogMessage);
-                    break;
-
-                case LogLevel.Information:
-                    LogMessage(message, MessageImportance.Normal, _taskLogging.LogMessage, _taskLogging.LogMessage);
-                    break;
-
-                case LogLevel.Debug:
-                case LogLevel.Verbose:
-                default:
-                    // Default to LogLevel.Debug and low importance
-                    LogMessage(message, MessageImportance.Low, _taskLogging.LogMessage, _taskLogging.LogMessage);
-                    break;
-            }
-        }
-
-        /// <summary>
-        /// Log using basic methods to avoid missing methods on mono.
-        /// </summary>
-        private void LogForMono(ILogMessage message)
-        {
-            switch (message.Level)
-            {
-                case LogLevel.Error:
-                    _taskLogging.LogError(message.Message);
-                    break;
-
-                case LogLevel.Warning:
-                    _taskLogging.LogWarning(message.Message);
-                    break;
-
-                case LogLevel.Minimal:
-                    _taskLogging.LogMessage(MessageImportance.High, message.Message);
-                    break;
-
-                case LogLevel.Information:
-                    _taskLogging.LogMessage(MessageImportance.Normal, message.Message);
-                    break;
-
-                case LogLevel.Debug:
-                case LogLevel.Verbose:
-                default:
-                    // Default to LogLevel.Debug and low importance
-                    _taskLogging.LogMessage(MessageImportance.Low, message.Message);
-                    break;
-            }
-
-            return;
-        }
-
-        private void LogMessage(IRestoreLogMessage logMessage,
-            MessageImportance importance,
-            LogMessageWithDetails logWithDetails,
-            LogMessageAsString logAsString)
-        {
-            if (logMessage.Code > NuGetLogCode.Undefined)
-            {
-                // NuGet does not currently have a subcategory while throwing logs, hence string.Empty
-                logWithDetails(string.Empty,
-                    Enum.GetName(typeof(NuGetLogCode), logMessage.Code),
-                    Enum.GetName(typeof(NuGetLogCode), logMessage.Code),
-                    logMessage.FilePath,
-                    logMessage.StartLineNumber,
-                    logMessage.StartColumnNumber,
-                    logMessage.EndLineNumber,
-                    logMessage.EndColumnNumber,
-                    importance,
-                    logMessage.Message);
-            }
-            else
-            {
-                logAsString(importance, logMessage.Message);
-            }
-        }
-
-        private void LogError(IRestoreLogMessage logMessage,
-            LogErrorWithDetails logWithDetails,
-            LogErrorAsString logAsString)
-        {
-            if (logMessage.Code > NuGetLogCode.Undefined)
-            {
-                // NuGet does not currently have a subcategory while throwing logs, hence string.Empty
-                logWithDetails(string.Empty,
-                    Enum.GetName(typeof(NuGetLogCode), logMessage.Code),
-                    Enum.GetName(typeof(NuGetLogCode), logMessage.Code),
-                    logMessage.FilePath,
-                    logMessage.StartLineNumber,
-                    logMessage.StartColumnNumber,
-                    logMessage.EndLineNumber,
-                    logMessage.EndColumnNumber,
-                    logMessage.Message);
-            }
-            else
-            {
-                logAsString(logMessage.Message);
-            }
-        }
-
-        public override System.Threading.Tasks.Task LogAsync(ILogMessage message)
-        {
-            Log(message);
-
-            return System.Threading.Tasks.Task.FromResult(0);
-        }
-    }
-}
--- a/build/tasks/OrderBy.cs
+++ b/build/tasks/OrderBy.cs
@ -1,28 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System;
-using System.Linq;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-
-namespace RepoTasks
-{
-    public class OrderBy : Task
-    {
-        [Required]
-        [Output]
-        public ITaskItem[] Items { get; set; }
-
-        public string Key { get; set; }
-
-        public override bool Execute()
-        {
-            var key = string.IsNullOrEmpty(Key)
-                ? "Identity"
-                : Key;
-            Items = Items.OrderBy(k => k.GetMetadata(key)).ToArray();
-            return true;
-        }
-    }
-}
--- a/build/tasks/ProcessSharedFrameworkDeps.cs
+++ b/build/tasks/ProcessSharedFrameworkDeps.cs
@ -1,76 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-// Sourced from  https://github.com/dotnet/core-setup/tree/be8d8e3486b2bf598ed69d39b1629a24caaba45e/tools-local/tasks, needs to be kept in sync
-
-using System;
-using System.IO;
-using System.Linq;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-using Microsoft.Extensions.DependencyModel;
-using NuGet.Common;
-using NuGet.ProjectModel;
-using RepoTasks.Utilities;
-
-namespace RepoTasks
-{
-    public partial class ProcessSharedFrameworkDeps : Task
-    {
-        [Required]
-        public string AssetsFilePath { get; set; }
-
-        [Required]
-        public string DepsFilePath { get; set; }
-
-        public string[] PackagesToRemove { get; set; }
-
-        [Required]
-        public string Runtime { get; set; }
-
-        public override bool Execute()
-        {
-            ExecuteCore();
-
-            return true;
-        }
-
-        private void ExecuteCore()
-        {
-            DependencyContext context;
-            using (var depsStream = File.OpenRead(DepsFilePath))
-            {
-                context = new DependencyContextJsonReader().Read(depsStream);
-            }
-
-            LockFile lockFile = LockFileUtilities.GetLockFile(AssetsFilePath, NullLogger.Instance);
-            if (lockFile == null)
-            {
-                throw new ArgumentException($"Could not load a LockFile at '{AssetsFilePath}'.", nameof(AssetsFilePath));
-            }
-
-            var manager = new RuntimeGraphManager();
-            var graph = manager.Collect(lockFile);
-            var expandedGraph = manager.Expand(graph, Runtime);
-
-            var trimmedRuntimeLibraries = context.RuntimeLibraries;
-
-            if (PackagesToRemove != null && PackagesToRemove.Any())
-            {
-                trimmedRuntimeLibraries = RuntimeReference.RemoveReferences(context.RuntimeLibraries, PackagesToRemove);
-            }
-
-            context = new DependencyContext(
-                context.Target,
-                context.CompilationOptions,
-                context.CompileLibraries,
-                trimmedRuntimeLibraries,
-                expandedGraph
-                );
-
-            using (var depsStream = File.Create(DepsFilePath))
-            {
-                new DependencyContextWriter().Write(context, depsStream);
-            }
-        }
-    }
-}
--- a/build/tasks/PublishToAzureBlob.cs
+++ b/build/tasks/PublishToAzureBlob.cs
@ -1,144 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.Build.Framework;
-using Microsoft.WindowsAzure.Storage;
-using Microsoft.WindowsAzure.Storage.Blob;
-
-namespace RepoTasks
-{
-    /// <summary>
-    /// Publish files to an Azure storage blob
-    /// </summary>
-    public class PublishToAzureBlob : Microsoft.Build.Utilities.Task, ICancelableTask
-    {
-        private CancellationTokenSource _cts = new CancellationTokenSource();
-
-        /// <summary>
-        /// The files to publish.
-        /// </summary>
-        [Required]
-        public ITaskItem[] Files { get; set; }
-
-        /// <summary>
-        /// The Azure blob storage account name.
-        /// </summary>
-        [Required]
-        public string AccountName { get; set; }
-
-        /// <summary>
-        /// The SAS token used to write to Azure.
-        /// </summary>
-        [Required]
-        public string SharedAccessToken { get; set; }
-
-        /// <summary>
-        /// The Azure blob storage container name
-        /// </summary>
-        [Required]
-        public string ContainerName { get; set; }
-
-        /// <summary>
-        /// The maximum number of parallel pushes.
-        /// </summary>
-        public int MaxParallelism { get; set; } = 8;
-
-        public void Cancel() => _cts.Cancel();
-
-        public override bool Execute()
-            => ExecuteAsync().Result;
-
-        private async Task<bool> ExecuteAsync()
-        {
-            var connectionString = $"BlobEndpoint=https://{AccountName}.blob.core.windows.net;SharedAccessSignature={SharedAccessToken}";
-
-            var account = CloudStorageAccount.Parse(connectionString);
-            var client = account.CreateCloudBlobClient();
-            var container = client.GetContainerReference(ContainerName);
-
-            var ctx = new OperationContext();
-            var tasks = new List<Task>();
-
-            using (var throttler = new SemaphoreSlim(MaxParallelism))
-            {
-                foreach (var item in Files)
-                {
-                    _cts.Token.ThrowIfCancellationRequested();
-                    await throttler.WaitAsync( _cts.Token);
-                    tasks.Add(
-                        Task.Run(async () =>
-                        {
-                            try
-                            {
-                                await PushFileAsync(ctx, container, item, _cts.Token);
-                            }
-                            finally
-                            {
-                                throttler.Release();
-                            }
-                        }));
-                }
-
-                await Task.WhenAll(tasks);
-            }
-
-            return !Log.HasLoggedErrors;
-        }
-
-        private async Task PushFileAsync(OperationContext ctx, CloudBlobContainer container, ITaskItem item, CancellationToken cancellationToken)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            // normalize slashes
-            var dest = item.GetMetadata("RelativeBlobPath")
-                .Replace('\\', '/')
-                .Replace("//", "/");
-            var contentType = item.GetMetadata("ContentType");
-            var cacheControl = item.GetMetadata("CacheControl");
-
-            if (string.IsNullOrEmpty(dest))
-            {
-                Log.LogError($"Item {item.ItemSpec} is missing required metadata 'RelativeBlobPath'");
-                return;
-            }
-
-            var blob = container.GetBlockBlobReference(dest);
-
-            if (!string.IsNullOrEmpty(cacheControl))
-            {
-                blob.Properties.CacheControl = cacheControl;
-            }
-
-            if (!string.IsNullOrEmpty(contentType))
-            {
-                blob.Properties.ContentType = contentType;
-            }
-
-            Log.LogMessage(MessageImportance.High, $"Beginning push of {item.ItemSpec} to https://{AccountName}.blob.core.windows.net/{ContainerName}/{dest}");
-
-            var accessCondition = bool.TryParse(item.GetMetadata("Overwrite"), out var overwrite) && overwrite
-                ? AccessCondition.GenerateEmptyCondition()
-                : AccessCondition.GenerateIfNotExistsCondition();
-
-            try
-            {
-                await blob.UploadFromFileAsync(item.ItemSpec, accessCondition, new BlobRequestOptions(), ctx, cancellationToken);
-            }
-            catch (Exception ex)
-            {
-                Log.LogError($"Error publishing {item.ItemSpec}: {ex}");
-                return;
-            }
-            finally
-            {
-                Log.LogMessage(MessageImportance.High, $"Done publishing {item.ItemSpec} to https://{AccountName}.blob.core.windows.net/{ContainerName}/{dest}");
-            }
-        }
-    }
-}
--- a/build/tasks/RepoTasks.csproj
+++ b/build/tasks/RepoTasks.csproj
@ -1,19 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <Import Project="$(RepoTasksSdkPath)\Sdk.props" Condition="'$(RepoTasksSdkPath)' != '' "/>
-
-  <PropertyGroup>
-    <TargetFramework Condition="'$(MSBuildRuntimeType)' == 'Core' ">netcoreapp2.1</TargetFramework>
-    <TargetFramework Condition="'$(MSBuildRuntimeType)' != 'Core' ">net461</TargetFramework>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Remove="Internal.AspNetCore.Sdk" />
-    <PackageReference Include="Microsoft.DotNet.Archive" Version="$(MicrosoftDotNetArchivePackageVersion)" />
-    <PackageReference Include="NuGet.Build.Tasks" Version="$(NuGetInMSBuildVersion)" />
-    <PackageReference Include="Microsoft.Extensions.DependencyModel" Version="$(DevDependency_MicrosoftExtensionsDependencyModelPackageVersion)" />
-    <PackageReference Include="WindowsAzure.Storage" Version="$(DevDependency_WindowsAzureStoragePackageVersion)" />
-    <PackageReference Include="Microsoft.DotNet.Build.Tasks.Feed" Version="$(DevDependency_MicrosoftDotNetBuildTasksFeedPackageVersion)" ExcludeAssets="Build" />
-  </ItemGroup>
-
-  <Import Project="$(RepoTasksSdkPath)\Sdk.targets" Condition="'$(RepoTasksSdkPath)' != '' "/>
-</Project>
--- a/build/tasks/RepoTasks.tasks
+++ b/build/tasks/RepoTasks.tasks
@ -1,31 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <_RepoTaskAssembly>$(MSBuildThisFileDirectory)bin\publish\RepoTasks.dll</_RepoTaskAssembly>
-  </PropertyGroup>
-
-  <UsingTask TaskName="RepoTasks.AddMetapackageReferences" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.AnalyzeBuildGraph" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.CheckExpectedPackagesExist" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.CheckRepoGraph" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.CheckVersionOverrides" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.CreateLzma" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.GenerateRestoreSourcesPropsFile" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.GetDocXmlFiles" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.JoinItems" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.OrderBy" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.ProcessSharedFrameworkDeps" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.PublishToAzureBlob" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.ResolveSymbolsRecursivePath" AssemblyFile="$(_RepoTaskAssembly)" />
-  <UsingTask TaskName="RepoTasks.TrimDeps" AssemblyFile="$(_RepoTaskAssembly)" />
-
-  <!-- tools from dotnet-buildtools -->
-  <PropertyGroup>
-    <NuGetPackagesPath>$(NUGET_PACKAGES)</NuGetPackagesPath>
-    <NuGetPackagesPath Condition=" '$(NuGetPackagesPath)' == '' AND '$(USERPROFILE)' != '' ">$(USERPROFILE)\.nuget\packages\</NuGetPackagesPath>
-    <NuGetPackagesPath Condition=" '$(NuGetPackagesPath)' == '' AND '$(HOME)' != '' ">$(HOME)\.nuget\packages\</NuGetPackagesPath>
-    <NuGetPackagesPath>$([MSBuild]::NormalizeDirectory($(NuGetPackagesPath)))</NuGetPackagesPath>
-    <_MicrosoftDotNetBuildTasksFeedTaskDir>$(NuGetPackagesPath)microsoft.dotnet.build.tasks.feed\$(DevDependency_MicrosoftDotNetBuildTasksFeedPackageVersion.ToLowerInvariant())\build\netstandard1.5\</_MicrosoftDotNetBuildTasksFeedTaskDir>
-  </PropertyGroup>
-
-  <UsingTask TaskName="PushToBlobFeed" AssemblyFile="$(_MicrosoftDotNetBuildTasksFeedTaskDir)Microsoft.DotNet.Build.Tasks.Feed.dll"/>
-</Project>
--- a/build/tasks/ResolveSymbolsRecursivePath.cs
+++ b/build/tasks/ResolveSymbolsRecursivePath.cs
@ -1,29 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System;
-using System.IO;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-using RepoTasks.Utilities;
-
-namespace RepoTasks
-{
-    public class ResolveSymbolsRecursivePath : Task
-    {
-        [Required]
-        [Output]
-        public ITaskItem[] Symbols { get; set; }
-
-        public override bool Execute()
-        {
-            foreach (var symbol in Symbols)
-            {
-                var fullPath = symbol.GetMetadata("PortablePDB");
-                symbol.SetMetadata("SymbolsRecursivePath", fullPath.Substring(fullPath.IndexOf($"{Path.DirectorySeparatorChar}lib{Path.DirectorySeparatorChar}")));
-            }
-
-            return true;
-        }
-    }
-}
--- a/build/tasks/TrimDeps.cs
+++ b/build/tasks/TrimDeps.cs
@ -1,60 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System.IO;
-using System.Linq;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-
-namespace RepoTasks
-{
-    public class TrimDeps : Task
-    {
-        [Required]
-        public ITaskItem[] DepsFiles { get; set; }
-
-        public override bool Execute()
-        {
-            foreach (var depsFile in DepsFiles)
-            {
-                ChangeEntryPointLibraryName(depsFile.GetMetadata("Identity"));
-            }
-
-            // Parse input
-            return true;
-        }
-
-
-        private void ChangeEntryPointLibraryName(string depsFile)
-        {
-            JToken deps;
-            using (var file = File.OpenText(depsFile))
-            using (JsonTextReader reader = new JsonTextReader(file))
-            {
-                deps = JObject.ReadFrom(reader);
-            }
-
-            foreach (JProperty target in deps["targets"])
-            {
-                var targetLibrary = target.Value.Children<JProperty>().FirstOrDefault();
-                if (targetLibrary == null)
-                {
-                    continue;
-                }
-
-                targetLibrary.Remove();
-            }
-
-            var library = deps["libraries"].Children<JProperty>().First();
-            library.Remove();
-
-            using (var file = File.CreateText(depsFile))
-            using (var writer = new JsonTextWriter(file) { Formatting = Formatting.Indented })
-            {
-                deps.WriteTo(writer);
-            }
-        }
-    }
-}
--- a/build/tasks/Utilities/KoreBuildErrors.cs
+++ b/build/tasks/Utilities/KoreBuildErrors.cs
@ -1,31 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-namespace RepoTasks.Utilities
-{
-    public static class KoreBuildErrors
-    {
-        public const string Prefix = "KRB";
-
-        // Typically used in repos in Directory.Build.targets
-        public const int PackagesHaveNotYetBeenPinned = 1001;
-
-        // Warnings
-        public const int DotNetAssetVersionIsFloating = 2000;
-        public const int RepoVersionDoesNotMatchProjectVersion = 2001;
-        public const int RepoPackageVersionDoesNotMatchProjectPackageVersion = 2002;
-        public const int DuplicatePackageReference = 2003;
-
-        // NuGet errors
-        public const int InvalidNuspecFile = 4001;
-        public const int PackageReferenceHasVersion = 4002;
-        public const int DotNetCliReferenceReferenceHasVersion = 4003;
-        public const int PackageVersionNotFoundInLineup = 4004;
-        public const int UndefinedExternalDependency = 4005;
-        public const int EmptyPackageReferenceVersion = 4006;
-
-        // Other unknown errors
-        public const int PolicyFailedToApply = 5000;
-        public const int UnknownPolicyType = 5001;
-    }
-}
--- a/build/tasks/Utilities/LoggingExtensions.cs
+++ b/build/tasks/Utilities/LoggingExtensions.cs
@ -1,26 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using Microsoft.Build.Utilities;
-
-namespace RepoTasks.Utilities
-{
-    public static class LoggingExtensions
-    {
-        public static void LogKoreBuildError(this TaskLoggingHelper logger, int code, string message, params object[] messageArgs)
-            => LogKoreBuildError(logger, null, code, message, messageArgs: messageArgs);
-
-        public static void LogKoreBuildError(this TaskLoggingHelper logger, string filename, int code, string message, params object[] messageArgs)
-        {
-            logger.LogError(null, KoreBuildErrors.Prefix + code, null, filename, 0, 0, 0, 0, message, messageArgs: messageArgs);
-        }
-
-        public static void LogKoreBuildWarning(this TaskLoggingHelper logger, int code, string message, params object[] messageArgs)
-            => LogKoreBuildWarning(logger, null, code, message, messageArgs: messageArgs);
-
-        public static void LogKoreBuildWarning(this TaskLoggingHelper logger, string filename, int code, string message, params object[] messageArgs)
-        {
-            logger.LogWarning(null, KoreBuildErrors.Prefix + code, null, filename, 0, 0, 0, 0, message, messageArgs: messageArgs);
-        }
-    }
-}
--- a/build/tasks/Utilities/MSBuildListSplitter.cs
+++ b/build/tasks/Utilities/MSBuildListSplitter.cs
@ -1,45 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace RepoTasks.Utilities
-{
-    internal static class MSBuildListSplitter
-    {
-        private static readonly char[] SemiColon = { ';' };
-
-        public static IEnumerable<string> SplitItemList(string value)
-        {
-            return string.IsNullOrEmpty(value)
-                ? Enumerable.Empty<string>()
-                : value.Split(SemiColon, StringSplitOptions.RemoveEmptyEntries);
-        }
-
-        public static Dictionary<string, string> GetNamedProperties(string input)
-        {
-            var values = new Dictionary<string, string>();
-            if (string.IsNullOrEmpty(input))
-            {
-                return values;
-            }
-
-            foreach (var item in input.Split(SemiColon, StringSplitOptions.RemoveEmptyEntries))
-            {
-                var splitIdx = item.IndexOf('=');
-                if (splitIdx <= 0)
-                {
-                    continue;
-                }
-
-                var key = item.Substring(0, splitIdx).Trim();
-                var value = item.Substring(splitIdx + 1);
-                values[key] = value;
-            }
-
-            return values;
-        }
-    }
-}
--- a/build/tasks/Utilities/RuntimeGraphManager.cs
+++ b/build/tasks/Utilities/RuntimeGraphManager.cs
@ -1,66 +0,0 @@
-// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-// Sourced from  https://github.com/dotnet/core-setup/tree/be8d8e3486b2bf598ed69d39b1629a24caaba45e/tools-local/tasks, needs to be kept in sync
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using Microsoft.Extensions.DependencyModel;
-using NuGet.Frameworks;
-using NuGet.Packaging;
-using NuGet.ProjectModel;
-using NuGet.RuntimeModel;
-
-namespace RepoTasks.Utilities
-{
-    internal class RuntimeGraphManager
-    {
-        private const string RuntimeJsonFileName = "runtime.json";
-
-        public RuntimeGraph Collect(LockFile lockFile)
-        {
-            string userPackageFolder = lockFile.PackageFolders.FirstOrDefault()?.Path;
-            var fallBackFolders = lockFile.PackageFolders.Skip(1).Select(f => f.Path);
-            var packageResolver = new FallbackPackagePathResolver(userPackageFolder, fallBackFolders);
-
-            var graph = RuntimeGraph.Empty;
-            foreach (var library in lockFile.Libraries)
-            {
-                if (string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))
-                {
-                    var runtimeJson = library.Files.FirstOrDefault(f => f == RuntimeJsonFileName);
-                    if (runtimeJson != null)
-                    {
-                        var libraryPath = packageResolver.GetPackageDirectory(library.Name, library.Version);
-                        var runtimeJsonFullName = Path.Combine(libraryPath, runtimeJson);
-                        graph = RuntimeGraph.Merge(graph, JsonRuntimeFormat.ReadRuntimeGraph(runtimeJsonFullName));
-                    }
-                }
-            }
-            return graph;
-        }
-
-        public IEnumerable<RuntimeFallbacks> Expand(RuntimeGraph runtimeGraph, string runtime)
-        {
-            var importers = FindImporters(runtimeGraph, runtime);
-            foreach (var importer in importers)
-            {
-                // ExpandRuntime return runtime itself as first item so we are skiping it
-                yield return new RuntimeFallbacks(importer, runtimeGraph.ExpandRuntime(importer).Skip(1));
-            }
-        }
-
-        private IEnumerable<string> FindImporters(RuntimeGraph runtimeGraph, string runtime)
-        {
-            foreach (var runtimePair in runtimeGraph.Runtimes)
-            {
-                var expanded = runtimeGraph.ExpandRuntime(runtimePair.Key);
-                if (expanded.Contains(runtime))
-                {
-                    yield return runtimePair.Key;
-                }
-            }
-        }
-    }
-}
--- a/build/tasks/Utilities/RuntimeReference.cs
+++ b/build/tasks/Utilities/RuntimeReference.cs
@ -1,63 +0,0 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-// Sourced from  https://github.com/dotnet/core-setup/tree/be8d8e3486b2bf598ed69d39b1629a24caaba45e/tools-local/tasks, needs to be kept in sync
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Microsoft.Extensions.DependencyModel;
-
-namespace RepoTasks.Utilities
-{
-    internal class RuntimeReference
-    {
-        public static List<RuntimeLibrary> RemoveReferences(IReadOnlyList<RuntimeLibrary> runtimeLibraries, IEnumerable<string> packages)
-        {
-            List<RuntimeLibrary> result = new List<RuntimeLibrary>();
-
-            foreach (var runtimeLib in runtimeLibraries)
-            {
-                if (string.IsNullOrEmpty(packages.FirstOrDefault(elem => runtimeLib.Name.Equals(elem, StringComparison.OrdinalIgnoreCase))))
-                {
-                    List<Dependency> toRemoveDependecy = new List<Dependency>();
-                    foreach (var dependency in runtimeLib.Dependencies)
-                    {
-                        if (!string.IsNullOrEmpty(packages.FirstOrDefault(elem => dependency.Name.Equals(elem, StringComparison.OrdinalIgnoreCase))))
-                        {
-                            toRemoveDependecy.Add(dependency);
-                        }
-                    }
-
-                    if (toRemoveDependecy.Count > 0)
-                    {
-                        List<Dependency> modifiedDependencies = new List<Dependency>();
-                        foreach (var dependency in runtimeLib.Dependencies)
-                        {
-                            if (!toRemoveDependecy.Contains(dependency))
-                            {
-                                modifiedDependencies.Add(dependency);
-                            }
-                        }
-
-
-                        result.Add(new RuntimeLibrary(runtimeLib.Type,
-                                                      runtimeLib.Name,
-                                                      runtimeLib.Version,
-                                                      runtimeLib.Hash,
-                                                      runtimeLib.RuntimeAssemblyGroups,
-                                                      runtimeLib.NativeLibraryGroups,
-                                                      runtimeLib.ResourceAssemblies,
-                                                      modifiedDependencies,
-                                                      runtimeLib.Serviceable));
-
-                    }
-                    else if (string.IsNullOrEmpty(packages.FirstOrDefault(elem => runtimeLib.Name.Equals(elem, StringComparison.OrdinalIgnoreCase))))
-                    {
-                        result.Add(runtimeLib);
-                    }
-                }
-            }
-            return result;
-        }
-    }
-}
--- a/build/tasks/tasks.sln
+++ b/build/tasks/tasks.sln
@ -1,34 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.26124.0
-MinimumVisualStudioVersion = 15.0.26124.0
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RepoTasks", "RepoTasks.csproj", "{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Debug|x64 = Debug|x64
-		Debug|x86 = Debug|x86
-		Release|Any CPU = Release|Any CPU
-		Release|x64 = Release|x64
-		Release|x86 = Release|x86
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}.Debug|x64.Build.0 = Debug|Any CPU
-		{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}.Debug|x86.Build.0 = Debug|Any CPU
-		{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}.Release|Any CPU.Build.0 = Release|Any CPU
-		{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}.Release|x64.ActiveCfg = Release|Any CPU
-		{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}.Release|x64.Build.0 = Release|Any CPU
-		{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}.Release|x86.ActiveCfg = Release|Any CPU
-		{A114791F-35B7-4E5B-8E5B-9A91E0B6E4AE}.Release|x86.Build.0 = Release|Any CPU
-	EndGlobalSection
-EndGlobal
--- a/build/tools/docker/rhel.7/Dockerfile
+++ b/build/tools/docker/rhel.7/Dockerfile
@ -1,23 +0,0 @@
-#
-# Copyright (c) .NET Foundation. All rights reserved.
-# Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-#
-
-# Dockerfile that creates a container suitable to build dotnet-cli
-FROM microsoft/dotnet-buildtools-prereqs:rhel-7-rpmpkg-e1b4a89-20175311035359
-
-# Setup User to match Host User, and give superuser permissions
-ARG USER_ID=0
-RUN useradd -m code_executor -u ${USER_ID} -g root
-RUN echo 'code_executor ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
-
-# With the User Change, we need to change permssions on these directories
-RUN chmod -R a+rwx /usr/local
-RUN chmod -R a+rwx /home
-RUN chown root:root /usr/bin/sudo && chmod 4755 /usr/bin/sudo
-
-# Set user to the one we just created
-USER ${USER_ID}
-
-# Set working directory
-WORKDIR /opt/code
--- a/build/tools/docker/ubuntu.14.04/Dockerfile
+++ b/build/tools/docker/ubuntu.14.04/Dockerfile
@ -1,52 +0,0 @@
-#
-# Copyright (c) .NET Foundation. All rights reserved.
-# Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-#
-
-# Dockerfile that creates a container suitable to build dotnet-cli
-FROM ubuntu:14.04
-
-# Misc Dependencies for build
-RUN apt-get update && \
-    apt-get -qqy install \
-        curl \
-        unzip \
-        gettext \
-        sudo \
-        libunwind8 \
-        libkrb5-3 \
-        libicu52 \
-        liblttng-ust0 \
-        libssl1.0.0 \
-        zlib1g \
-        libuuid1 \
-        debhelper \
-        build-essential \
-        devscripts \
-        git \
-        cmake \
-        clang-3.5 \
-        lldb-3.6 \
-        wget && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
-
-# Use clang as c++ compiler
-RUN update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++-3.5 100
-RUN update-alternatives --set c++ /usr/bin/clang++-3.5
-
-# Setup User to match Host User, and give superuser permissions
-ARG USER_ID=0
-RUN useradd -m code_executor -u ${USER_ID} -g sudo
-RUN echo 'code_executor ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
-
-# With the User Change, we need to change permissions on these directories
-RUN chmod -R a+rwx /usr/local
-RUN chmod -R a+rwx /home
-RUN chmod -R 755 /usr/lib/sudo
-
-# Set user to the one we just created
-USER ${USER_ID}
-
-# Set working directory
-WORKDIR /opt/code
--- a/build/tools/packaging/debian_config.json.in
+++ b/build/tools/packaging/debian_config.json.in
@ -1,34 +0,0 @@
-{
-    "maintainer_name": "${MAINTAINER_NAME}",
-    "maintainer_email": "${MAINTAINER_EMAIL}",
-
-    "package_name": "${PACKAGE_NAME}",
-    "install_root": "${INSTALL_ROOT}",
-
-    "short_description": "${SHORT_DESCRIPTION}",
-    "long_description": "${LONG_DESCRIPTION}",
-    "homepage": "${HOMEPAGE}",
-
-    "release":{
-        "package_version":"0.0.0.0",
-        "package_revision":"${PACKAGE_REVISION}",
-        "urgency" : "low",
-        "changelog_message" : ""
-    },
-
-    "control": {
-        "priority":"standard",
-        "section":"devel",
-        "architecture":"any"
-    },
-
-    "copyright": "Microsoft",
-    "license": {
-        "type": "${LICENSE_TYPE}",
-        "full_text": "Copyright (c) .NET Foundation. All rights reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\nthese files except in compliance with the License. You may obtain a copy of the\nLicense at\n\nhttp://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software distributed\nunder the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\nCONDITIONS OF ANY KIND, either express or implied. See the License for the\nspecific language governing permissions and limitations under the License."
-    },
-
-    "debian_dependencies": {
-        ${DEBIAN_DEPENDENCIES}
-    }
-}
--- a/build/tools/templates/SharedFx/SharedFx.csproj
+++ b/build/tools/templates/SharedFx/SharedFx.csproj
@ -1,35 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk" >
-
-  <PropertyGroup>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
-    <DisableImplicitNuGetFallbackFolder>true</DisableImplicitNuGetFallbackFolder>
-    <DisableImplicitFrameworkReferences>true</DisableImplicitFrameworkReferences>
-  </PropertyGroup>
-
-  <ItemGroup>
-   <PackageReference Include="$(SharedFxPackage)" Version="$(SharedFxPackageVersion)" ExcludeAssets="Build" />
-   <PackageReference Include="$(SharedFxDep)" Version="$(SharedFxDepVersion)" Condition="'$(SharedFxDep)' != ''"/>
-   <PackageReference Include="Microsoft.NETCore.App" Version="$(RuntimeFrameworkVersion)" ExcludeAssets="Native"/>
-  </ItemGroup>
-
-  <Target Name="GetPackageDefinitions" Returns="@(_PackageDefinitions)">
-    <ResolvePackageDependencies ProjectPath="$(MSBuildThisFileFullPath)" ProjectAssetsFile="$(ProjectAssetsFile)">
-      <Output TaskParameter="PackageDefinitions" ItemName="_PackageDefinitions" />
-    </ResolvePackageDependencies>
-  </Target>
-
-  <Target Name="GetPublishAssemblies" Returns="@(_PublishAssemblies)">
-    <ResolvePublishAssemblies
-      ProjectPath="$(MSBuildProjectFullPath)"
-      AssetsFilePath="$(ProjectAssetsFile)"
-      TargetFramework="$(TargetFramework)"
-      RuntimeIdentifier="$(RuntimeIdentifier)"
-      PlatformLibraryName="Microsoft.NETCore.App"
-      ExcludeFromPublishPackageReferences="@(_ExcludeFromPublishPackageReference)"
-      IsSelfContained="$(SelfContained)">
-      <Output
-        TaskParameter="AssembliesToPublish"
-        ItemName="_PublishAssemblies" />
-    </ResolvePublishAssemblies>
-  </Target>
-</Project>
--- a/build/tools/templates/SharedFxSymbols/SharedFrameworkSymbols.csproj
+++ b/build/tools/templates/SharedFxSymbols/SharedFrameworkSymbols.csproj
@ -1,30 +0,0 @@
-<Project>
-  <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
-
-  <PropertyGroup>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
-    <Authors>Microsoft</Authors>
-    <Copyright>Copyright © Microsoft Corporation</Copyright>
-    <PackageLicenseUrl>https://raw.githubusercontent.com/aspnet/Home/2.0.0/LICENSE.txt</PackageLicenseUrl>
-    <PackageIconUrl>https://go.microsoft.com/fwlink/?LinkID=288859</PackageIconUrl>
-    <PackageProjectUrl>https://asp.net</PackageProjectUrl>
-    <IncludeSymbols>true</IncludeSymbols>
-    <IncludeBuildOutput>false</IncludeBuildOutput>
-    <PackageTags>aspnetcore</PackageTags>
-    <ContentTargetFolders></ContentTargetFolders>
-    <DisableImplicitFrameworkReferences>true</DisableImplicitFrameworkReferences>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <_SymbolFiles Include="$(SymbolsWorkDir)**\*.pdb;$(SymbolsWorkDir)**\*.map;$(SymbolsWorkDir)**\*.dll" />
-    <Content Include="@(_SymbolFiles)">
-      <PackagePath>%(RecursiveDir)%(Filename)%(Extension)</PackagePath>
-    </Content>
-  </ItemGroup>
-
-  <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
-
-  <Target Name="Compile" />
-  <Target Name="CopyFilesToOutputDirectory" />
-
-</Project>
--- a/clean.cmd
+++ b/clean.cmd
@ -0,0 +1,3 @@
+@ECHO OFF
+SETLOCAL
+PowerShell -NoProfile -NoLogo -ExecutionPolicy ByPass -Command "[System.Threading.Thread]::CurrentThread.CurrentCulture = ''; [System.Threading.Thread]::CurrentThread.CurrentUICulture = ''; try { & '%~dp0clean.ps1' %*; exit $LASTEXITCODE } catch { write-host $_; exit 1 }"
--- a/clean.ps1
+++ b/clean.ps1
@ -0,0 +1,42 @@
+#requires -version 5
+
+<#
+.SYNOPSIS
+Clean this repository.
+
+.DESCRIPTION
+This script cleans this repository interactively, leaving downloaded infrastructure untouched.
+Clean operation is interactive to avoid losing new but unstaged files. Press 'c' then [Enter]
+to perform the proposed deletions.
+
+.EXAMPLE
+Perform default clean operation.
+
+    clean.ps1
+
+.EXAMPLE
+Clean everything but downloaded infrastructure and VS / VS Code folders.
+
+    clean.ps1 -e .vs/ -e .vscode/
+#>
+
+[CmdletBinding(PositionalBinding = $false)]
+param(
+    # Other lifecycle targets
+    [switch]$Help, # Show help
+
+    # Capture the rest
+    [Parameter(ValueFromRemainingArguments = $true)]
+    [string[]]$GitArguments
+)
+
+Set-StrictMode -Version 2
+$ErrorActionPreference = 'Stop'
+
+if ($Help) {
+    Get-Help $PSCommandPath
+    exit 0
+}
+
+git clean -dix -e .dotnet/ -e .tools/ @GitArguments
+git checkout -- $(git ls-files -d)
--- a/clean.sh
+++ b/clean.sh
@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+#
+# Functions
+#
+__usage() {
+    echo "Usage: $(basename "${BASH_SOURCE[0]}") <Arguments>
+
+Arguments:
+    <Arguments>...         Arguments passed to the 'git' command. Any number of arguments allowed.
+
+Description:
+    This script cleans the repository interactively, leaving downloaded infrastructure untouched.
+    Clean operation is interactive to avoid losing new but unstaged files. Press 'c' then [Enter]
+    to perform the proposed deletions.
+"
+}
+
+git_args=()
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -\?|-h|--help)
+            __usage
+            exit 0
+            ;;
+        *)
+            git_args[${#git_args[*]}]="$1"
+            ;;
+    esac
+    shift
+done
+
+# This incantation avoids unbound variable issues if git_args is empty
+# https://stackoverflow.com/questions/7577052/bash-empty-array-expansion-with-set-u
+git clean -dix -e .dotnet/ -e .tools/ ${git_args[@]+"${git_args[@]}"}
--- a/dockerbuild.sh
+++ b/dockerbuild.sh
@ -26,9 +26,10 @@ __usage() {
    echo ""
    echo "Options:"
    echo "    -v, --volume <VOLUME>      An additional volume mount to add to the build container"
+    echo "    -e, --env <NAME=VAL>       Additional environment variables to add to the build container"
    echo ""
    echo "Description:"
-    echo "    This will run build.sh inside the dockerfile as defined in build/docker/\$image.Dockerfile."
+    echo "    This will run build.sh inside the dockerfile as defined in eng/docker/\$image.Dockerfile."

    if [[ "${1:-}" != '--no-exit' ]]; then
        exit 2
@ -69,6 +70,13 @@ while [[ $# -gt 0 ]]; do
            docker_args[${#docker_args[*]}]="--volume"
            docker_args[${#docker_args[*]}]="$volume_spec"
            ;;
+        -e|--env)
+            shift
+            env_var="${1:-}"
+            [ -z "$env_var" ] && __error "Missing value for parameter --env" && __usage
+            docker_args[${#docker_args[*]}]="-e"
+            docker_args[${#docker_args[*]}]="$env_var"
+            ;;
        *)
            build_args[${#build_args[*]}]="$1"
            ;;
@ -87,26 +95,52 @@ if ! __machine_has docker; then
    exit 1
 fi

-dockerfile="$DIR/build/docker/$image.Dockerfile"
+commit_hash="$(git rev-parse HEAD || true)"
+
+if [ ! -z "$commit_hash" ]; then
+    build_args[${#build_args[*]}]="-p:SourceRevisionId=$commit_hash"
+fi
+
+dockerfile="$DIR/eng/docker/$image.Dockerfile"
 tagname="aspnetcore-build-$image"

+# Use docker pull with retries to pre-pull the image need by the dockerfile
+# docker build regularly fails with TLS handshake issues for unclear reasons.
+base_imagename="$(grep -E -o 'FROM (.*)' $dockerfile | cut -c 6-)"
+pull_retries=3
+while [ $pull_retries -gt 0 ]; do
+    failed=false
+    docker pull $base_imagename || failed=true
+    if [ "$failed" = true ]; then
+        let pull_retries=pull_retries-1
+        echo -e "${YELLOW}Failed to pull $base_imagename Retries left: $pull_retries.${RESET}"
+        sleep 1
+    else
+        pull_retries=0
+    fi
+done
+
 docker build "$(dirname "$dockerfile")" \
    --build-arg "USER=$(whoami)" \
    --build-arg "USER_ID=$(id -u)" \
    --build-arg "GROUP_ID=$(id -g)" \
+    --build-arg "WORKDIR=$DIR" \
    --tag $tagname \
    -f "$dockerfile"

 docker run \
    --rm \
    -t \
-    -e CI \
-    -e TEAMCITY_VERSION \
+    -e TF_BUILD \
+    -e BUILD_NUMBER \
+    -e BUILD_BUILDNUMBER \
+    -e BUILD_REPOSITORY_URI \
+    -e BUILD_SOURCEVERSION \
+    -e BUILD_SOURCEBRANCH \
    -e DOTNET_CLI_TELEMETRY_OPTOUT \
    -e Configuration \
-    -v "$DIR:/code/build" \
+    -v "$DIR:$DIR" \
    ${docker_args[@]+"${docker_args[@]}"} \
    $tagname \
    ./build.sh \
-    ${build_args[@]+"${build_args[@]}"} \
-    "-p:HostMachineRepositoryRoot=$DIR"
+    ${build_args[@]+"${build_args[@]}"}
--- a/docs/Artifacts.md
+++ b/docs/Artifacts.md
@ -0,0 +1,38 @@
+Artifacts
+=========
+
+Building this repo produces build artifacts in the directory structure described below. Build outputs are organized into logical groups based on artifact type and the intended usage of the artifacts.
+
+See also https://github.com/dotnet/arcade/blob/master/Documentation/ArcadeSdk.md This repo follows _most_ of the conventions described there.
+
+```
+artifacts/
+  installers/
+    $(Configuration)/
+      *.msi            = Windows installers
+      *.deb, *.rpm     = Linux installers
+      *.zip, *.tar.gz  = archives versions of installers
+  log/
+    runningProcesses*.txt = Process list from just before build completed
+    runningProcesses*.bak = Process list from two minutes before runningProcesses*.txt files were written
+    *.binlog           = Binary logs for a few build phases e.g. site extension build
+    **/
+      *.log            = Log files for test runs and individual tests
+    $(Configuration)/
+      *.binlog         = Binary logs for most build phases
+  packages/
+    $(Configuration)/
+      Shipping/        = Packages which are intended for use by customers. These, along with installers, represent the 'product'.
+        *.nupkg        = NuGet packages which ship to nuget.org
+        *.jar          = Java packages which ship to Maven Central and others
+        *.tgz          = NPM packages which ship to npmjs.org
+      NonShipping/
+        *.nupkg        = NuGet packages for internal use only. Used to hand off bits to Microsoft partner teams. Not intended for use by customers.
+  symbols/
+    $(Configuration)/
+      $(TargetFramework)/
+        *.pdb          = Loose symbol files for symbol server publication. Special cases where *.symbols.nupkg packaging is cumbersome.
+  VSSetup/
+    $(Configuration)/
+      *.vsix           = Visual Studio extensions. None currently exist.
+```
--- a/docs/BuildErrors.md
+++ b/docs/BuildErrors.md
@ -0,0 +1,33 @@
+Build Errors
+------------
+
+This document is for common build errors and how to resolve them.
+
+### Warning BUILD001
+
+> warning BUILD001: Package references changed since the last release...
+
+This warning indicates a breaking change might have been made to a package or assembly due to the removal of a reference which was used
+in a previous release of this assembly. See <./ReferenceResolution.md> for how to suppress.
+
+### Error BUILD002
+
+> error BUILD002: Package references changed since the last release...
+
+Similar to BUILD001, but this error is not suppressable. This error only appears in servicing builds, which should not change references between assemblies or packages.
+
+### Error BUILD003
+
+> error BUILD003: Multiple project files named 'Banana.csproj' exist. Project files should have a unique name to avoid conflicts in build output.
+
+This repo uses a common output directory (artifacts/bin/$(ProjectName) and artifacts/obj/$(ProjectName)). To avoid confllicts in build output, each
+project file should have a unique name.
+
+### Error MSB4236 / Unable to locate the .NET Core SDK
+  
+Executing `.\restore.cmd` or `.\build.cmd` may produce these errors:
+
+> error : Unable to locate the .NET Core SDK. Check that it is installed and that the version specified in global.json (if any) matches the installed version.
+> error MSB4236: The SDK 'Microsoft.NET.Sdk' specified could not be found.
+
+In most cases, this is because the option _Use previews of the .NET Core SDK_ in VS2019 is not checked. Start Visual Studio, go to _Tools > Options_ and check _Use previews of the .NET Core SDK_ under _Environment > Preview Features_.
--- a/docs/BuildFromSource.md
+++ b/docs/BuildFromSource.md
@ -11,16 +11,23 @@ See https://github.com/aspnet/AspNetCore/labels/area-infrastructure for known is

 Building ASP.NET Core on Windows requires:

-* Windows 7 or higher
+* Windows 10, version 1803 or newer
 * At least 10 GB of disk space and a good internet connection (our build scripts download a lot of tools and dependencies)
-* Visual Studio 2017. <https://visualstudio.com>
-    * To install the exact required components, run scripts\install_vs.ps1. This will use VS2017.
+* Visual Studio 2019. <https://visualstudio.com>
+    * To install the exact required components, run [eng/scripts/InstallVisualStudio.ps1](/eng/scripts/InstallVisualStudio.ps1).
+        ```ps1
+        PS> ./eng/scripts/InstallVisualStudio.ps1
+        ```
 * Git. <https://git-scm.org>
-* (Optional) some optional components, like the SignalR Java client, may require
-    * NodeJS <https://nodejs.org>
-    * Java Development Kit 10 or newer. Either:
-        * OpenJDK <http://jdk.java.net/10/>
-        * Oracle's JDK <https://www.oracle.com/technetwork/java/javase/downloads/index.html>
+* NodeJS. LTS version of 10.14.2 or newer <https://nodejs.org>
+* Java Development Kit 11 or newer. Either:
+    * OpenJDK <https://jdk.java.net/>
+    * Oracle's JDK <https://www.oracle.com/technetwork/java/javase/downloads/index.html>
+    * To install a version of the JDK that will only be used by this repo, run [eng/scripts/InstallJdk.ps1](/eng/scripts/InstallJdk.ps1)
+        ```ps1
+        PS> ./eng/scripts/InstallJdk.ps1
+        ```
+* Chrome - Selenium-based tests require a version of Chrome to be installed. Download and install it from [https://www.google.com/chrome]

 ### macOS/Linux

@ -30,11 +37,10 @@ Building ASP.NET Core on macOS or Linux requires:
 * If using Linux, you need a machine with all .NET Core Linux prerequisites: <https://docs.microsoft.com/en-us/dotnet/core/linux-prerequisites>
 * At least 10 GB of disk space and a good internet connection (our build scripts download a lot of tools and dependencies)
 * Git <https://git-scm.org>
-* (Optional) some optional components, like the SignalR Java client, may require
-    * NodeJS  <https://nodejs.org>
-    * Java Development Kit 10 or newer. Either:
-        * OpenJDK <http://jdk.java.net/10/>
-        * Oracle's JDK <https://www.oracle.com/technetwork/java/javase/downloads/index.html>
+* NodeJS. LTS version of 10.14.2 or newer <https://nodejs.org>
+* Java Development Kit 11 or newer. Either:
+    * OpenJDK <https://jdk.java.net/>
+    * Oracle's JDK <https://www.oracle.com/technetwork/java/javase/downloads/index.html>

 ## Clone the source code

@ -50,19 +56,20 @@ To update an existing copy, run:
 git submodule update --init --recursive
 ```

-## Building in Visual Studio / Code
+## Building in Visual Studio

 Before opening our .sln files in Visual Studio or VS Code, you need to perform the following actions.

 1. Executing the following on command-line:
   ```
-   .\build.cmd /p:SkipTests=true /p:_ProjectsOnly=true
+   .\restore.cmd
   ```
   This will download required tools and build the entire repository once. At that point, you should be able to open .sln files to work on the projects you care about.

-2. Use the `startvs.cmd` script to open Visual Studio .sln files. This script first sets required environment variables.
+   > :bulb: Pro tip: you will also want to run this command after pulling large sets of changes. On the master branch, we regularly update the versions of .NET Core SDK required to build the repo.
+   > You will need to restart Visual Studio every time we update the .NET Core SDK.

-> :bulb: Pro tip: you will also want to run this command after pulling large sets of changes. Visual Studio will only build projects in a solution file, and makes a best effort to use other files on disk. If you pull many changes, the files on disk may be stale and will need to re-build.
+2. Use the `startvs.cmd` script to open Visual Studio .sln files. This script first sets required environment variables.

 ### Solution files

@ -75,43 +82,48 @@ Instead, we have many .sln files which include a sub-set of projects. These prin

 > :bulb: Pro tip: `dotnet new sln` and `dotnet sln` are one of the easiest ways to create and modify solutions.

-### Known issue: NU1105
+### Common error: CS0006

-Opening solution files may produce an error code NU1105 with a message such
+Opening solution files and building may produce an error code CS0006 with a message such

-> Unable to find project information for 'C:\src\AspNetCore\src\Hosting\Abstractions\src\Microsoft.AspNetCore.Hosting.Abstractions.csproj'. Inside Visual Studio, this may be because the project is unloaded or not part of current solution. Otherwise the project file may be invalid or missing targets required for restore.
+> Error CS0006 Metadata file 'C:\src\aspnet\AspNetCore\artifacts\bin\Microsoft.AspNetCore.Metadata\Debug\netstandard2.0\Microsoft.AspNetCore.Metadata.dll' could not be found

-This is a known issue in NuGet (<https://github.com/NuGet/Home/issues/5820>) and we are working with them for a solution. See also <https://github.com/aspnet/AspNetCore/issues/4183> to track progress on this.
+The cause of this problem is that the solution you are using does not include the project that produces this .dll. This most often occurs after we have added new projects to the repo, but failed to update our .sln files to include the new project. In some cases, it is sometimes the intended behavior of the .sln which has been crafted to only include a subset of projects.

-**The workaround** for now is to add all projects to the solution.
+**You can fix this in one of two ways**
+1. Build the project on command line. In most cases, running `build.cmd` on command line solve this problem.
+2. Update the solution to include the missing project. You can either do this one by one using `dotnet sln`
+   ```
+   dotnet sln add C:\src\AspNetCore\src\Hosting\Abstractions\src\Microsoft.AspNetCore.Hosting.Abstractions.csproj
+   ```

-    dotnet sln add C:\src\AspNetCore\src\Hosting\Abstractions\src\Microsoft.AspNetCore.Hosting.Abstractions.csproj
+### Common error: Unable to locate the .NET Core SDK

+Executing `.\restore.cmd` or `.\build.cmd` may produce these errors:

-#### PATH
+> error : Unable to locate the .NET Core SDK. Check that it is installed and that the version specified in global.json (if any) matches the installed version.
+> error MSB4236: The SDK 'Microsoft.NET.Sdk' specified could not be found.

-For VS Code and Visual Studio and `dotnet` commands to work correctly, you must place the following location in your PATH.
-Use the following commands to update the PATH variable in a command line window.
+In most cases, this is because the option _Use previews of the .NET Core SDK_ in VS2019 is not checked. Start Visual Studio, go to _Tools > Options_ and check _Use previews of the .NET Core SDK_ under _Environment > Preview Features_.

-Windows (Command Prompt)
+## Building with Visual Studio Code

-```batch
-set PATH=%USERPROFILE%\.dotnet\x64;%PATH%
-```
-
-Windows (Powershell)
+Using Visual Studio Code with this repo requires setting environment variables on command line first.
+Use these command to launch VS Code with the right settings.

+On Windows (requires PowerShell):
 ```ps1
-$env:PATH="$env:USERPROFILE\.dotnet\x64;$env:PATH"
+# The extra dot at the beginning is required to 'dot source' this file into the right scope.
+
+. .\activate.ps1
+code .
 ```

-Linux/macOS:
-
-```sh
-export PATH="$HOME/.dotnet:$PATH"
+On macOS/Linux:
+```
+source activate.sh
+code .
 ```
-
-On Windows, we recommend using the `startvs.cmd` command to launch Visual Studio.

 ## Building on command-line

@ -127,15 +139,47 @@ On macOS/Linux:
 ./build.sh
 ```

-### Building a subset of the code
+By default, all of the C# projects are built. Some C# projects requires NodeJS to be installed to compile JavaScript assets which are then checked in as source. If NodeJS is detected on the path, the NodeJS projects will be compiled as part of building C# projects. If NodeJS is not detected on the path, the JavaScript assets checked in previously will be used instead. To disable building NodeJS projects, specify /p:BuildNodeJs=false on the command line.
+
+### Using `dotnet` on command line in this repo
+
+Because we are using pre-release versions of .NET Core, you have to set a handful of environment variables
+to make the .NET Core command line tool work well. You can set these environment variables like this
+
+On Windows (requires PowerShell):
+
+```ps1
+# The extra dot at the beginning is required to 'dot source' this file into the right scope.
+
+. .\activate.ps1
+```
+
+On macOS/Linux:
+```bash
+source ./activate.sh
+```
+
+## Running tests on command-line
+
+Tests are not run by default. Use the `-test` option to run tests in addition to building.
+
+On Windows:
+```
+.\build.cmd -test
+```
+
+On macOS/Linux:
+```
+./build.sh --test
+```
+
+## Building a subset of the code

 This repository is large. Look for `build.cmd`/`.sh` scripts in subfolders. These scripts can be used to invoke build and test on a smaller set of projects.

-#### Known issue: not every subfolder has a build.cmd script
+Furthermore, you can use flags on `build.cmd`/`.sh` to build subsets based on language type, like C++, TypeScript, or C#. Run `build.sh --help` or `build.cmd -help` for details.

-We'll be adding more. See https://github.com/aspnet/AspNetCore/issues/4247.
-
-#### Build properties
+## Build properties

 Additional properties can be added as an argument in the form `/property:$name=$value`, or `/p:$name=$value` for short. For example:
 ```
@ -146,16 +190,16 @@ Common properties include:

 Property                 | Description
 -------------------------|-------------------------------------------------------------------------------------------------------------
-BuildNumberSuffix        | (string). A specific build number, typically from a CI counter, which is appended to the pre-release label.
 Configuration            | `Debug` or `Release`. Default = `Debug`.
-SkipTests                | `true` or `false`. When true, builds without running tests.
-NoBuild                  | `true` or `false`. Runs tests without rebuilding.
+TargetArchitecture       | The CPU architecture to build for (x64, x86, arm, arm64).
+TargetOsName             | The base runtime identifier to build for (win, linux, osx, linux-musl).

 ## Use the result of your build

 After building ASP.NET Core from source, you will need to install and use your local version of ASP.NET Core.
+See ["Artifacts"](./Artifacts.md) for more explanation of the different folders produced by a build.

- Run the installers produced in `artifacts/{Debug, Release}/installers/` for your platform.
+- Run the installers produced in `artifacts/installers/{Debug, Release}/` for your platform.
 - Add a NuGet.Config to your project directory with the following content:

  ```xml
@ -163,7 +207,7 @@ After building ASP.NET Core from source, you will need to install and use your l
  <configuration>
      <packageSources>
          <clear />
-          <add key="MyBuildOfAspNetCore" value="C:\src\aspnet\AspNetCore\artifacts\build\" />
+          <add key="MyBuildOfAspNetCore" value="C:\src\aspnet\AspNetCore\artifacts\packages\Debug\Shipping\" />
          <add key="NuGet.org" value="https://api.nuget.org/v3/index.json" />
      </packageSources>
  </configuration>
@ -174,10 +218,13 @@ After building ASP.NET Core from source, you will need to install and use your l
 - Update the versions on `PackageReference` items in your .csproj project file to point to the version from your local build.
  ```xml
  <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.SpaServices" Version="3.0.0-preview-0" />
+    <PackageReference Include="Microsoft.AspNetCore.SpaServices" Version="3.0.0-dev" />
  </ItemGroup>
  ```

-
 Some features, such as new target frameworks, may require prerelease tooling builds for Visual Studio.
 These are available in the [Visual Studio Preview](https://www.visualstudio.com/vs/preview/).
+
+## Resx files
+
+If you need to make changes to a .resx file, run `dotnet msbuild /t:Resx <path to csproj>`. This will update the generated C#.
--- a/docs/DailyBuilds.md
+++ b/docs/DailyBuilds.md
@ -5,7 +5,7 @@ Daily builds include the latest source code changes. They are not supported for

 If you want to download the latest daily build and use it in a project, then you need to:

- Obtain the latest [build of the .NET Core SDK](https://github.com/dotnet/core-sdk#installers-and-binaries)
+- Obtain the latest [build of the .NET Core SDK](https://github.com/dotnet/core-sdk#installers-and-binaries).
 - Add a NuGet.Config to your project directory with the following content:

  ```xml
@ -13,7 +13,13 @@ If you want to download the latest daily build and use it in a project, then you
  <configuration>
      <packageSources>
          <clear />
-          <add key="dotnet-core" value="https://dotnet.myget.org/F/dotnet-core/api/v3/index.json" />
+          <add key="dotnet-core" value="https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json" />
+          <add key="extensions" value="https://dotnetfeed.blob.core.windows.net/aspnet-extensions/index.json" />
+          <add key="entityframeworkcore" value="https://dotnetfeed.blob.core.windows.net/aspnet-entityframeworkcore/index.json" />
+          <add key="entityframework6" value="https://dotnetfeed.blob.core.windows.net/aspnet-entityframework6/index.json" />
+          <add key="aspnetcore-tooling" value="https://dotnetfeed.blob.core.windows.net/aspnet-aspnetcore-tooling/index.json" />
+          <add key="aspnetcore" value="https://dotnetfeed.blob.core.windows.net/aspnet-aspnetcore/index.json" />
+          <add key="aspnet-blazor" value="https://dotnetfeed.blob.core.windows.net/aspnet-blazor/index.json" />
          <add key="NuGet.org" value="https://api.nuget.org/v3/index.json" />
      </packageSources>
  </configuration>
@ -24,76 +30,9 @@ If you want to download the latest daily build and use it in a project, then you
 Some features, such as new target frameworks, may require prerelease tooling builds for Visual Studio.
 These are available in the [Visual Studio Preview](https://www.visualstudio.com/vs/preview/).

-## NuGet packages
+#### To debug daily builds using Visual Studio

-Daily builds of ackages can be found on <https://dotnet.myget.org/gallery/dotnet-core>. This feed may include
-packages that will not be supported in a officially released build.
-
-Commonly referenced packages:
-
-[app-metapackage-myget]:  https://dotnet.myget.org/feed/dotnet-core/package/nuget/Microsoft.AspNetCore.App
-[app-metapackage-myget-badge]: https://img.shields.io/dotnet.myget/dotnet-core/vpre/Microsoft.AspNetCore.App.svg?style=flat-square&label=myget
-
-[metapackage-myget]:  https://dotnet.myget.org/feed/dotnet-core/package/nuget/Microsoft.AspNetCore
-[metapackage-myget-badge]: https://img.shields.io/dotnet.myget/dotnet-core/vpre/Microsoft.AspNetCore.svg?style=flat-square&label=myget
-
-Package                           | MyGet
-:---------------------------------|:---------------------------------------------------------
-Microsoft.AspNetCore.App          | [![][app-metapackage-myget-badge]][app-metapackage-myget]
-Microsoft.AspNetCore              | [![][metapackage-myget-badge]][metapackage-myget]
-
-## Runtime installers
-
-Updated versions of the ASP.NET Core runtime can be installed separately from SDK updates. Runtime-only installers can be downloaded here:
-
-[badge-master]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/master/aspnetcore-runtime-win-x64-version-badge.svg
-[win-x64-zip]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/master/aspnetcore-runtime-latest-win-x64.zip
-[win-x64-exe]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/master/aspnetcore-runtime-latest-win-x64.exe
-[win-x86-zip]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/master/aspnetcore-runtime-latest-win-x86.zip
-[win-x86-exe]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/master/aspnetcore-runtime-latest-win-x86.exe
-[linux-x64-tar]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/master/aspnetcore-runtime-latest-linux-x64.tar.gz
-[linux-arm-tar]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/master/aspnetcore-runtime-latest-linux-arm.tar.gz
-[linux-arm64-tar]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/master/aspnetcore-runtime-latest-linux-arm64.tar.gz
-[osx-x64-tar]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/master/aspnetcore-runtime-latest-osx-x64.tar.gz
-[debian-x64-deb]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/master/aspnetcore-runtime-latest-x64.deb
-[redhat-x64-rpm]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/master/aspnetcore-runtime-latest-x64.rpm
-[linux-musl-x64-tar]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/master/aspnetcore-runtime-latest-linux-musl-x64.tar.gz
-
-[badge-rel-22]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.2/aspnetcore-runtime-win-x64-version-badge.svg
-[win-x64-zip-rel-22]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.2/aspnetcore-runtime-latest-win-x64.zip
-[win-x64-exe-rel-22]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.2/aspnetcore-runtime-latest-win-x64.exe
-[win-x86-zip-rel-22]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.2/aspnetcore-runtime-latest-win-x86.zip
-[win-x86-exe-rel-22]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.2/aspnetcore-runtime-latest-win-x86.exe
-[linux-x64-tar-rel-22]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.2/aspnetcore-runtime-latest-linux-x64.tar.gz
-[osx-x64-tar-rel-22]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.2/aspnetcore-runtime-latest-osx-x64.tar.gz
-[debian-x64-deb-rel-22]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.2/aspnetcore-runtime-latest-x64.deb
-[redhat-x64-rpm-rel-22]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.2/aspnetcore-runtime-latest-x64.rpm
-[linux-arm-tar-rel-22]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.2/aspnetcore-runtime-latest-linux-arm.tar.gz
-[linux-musl-x64-tar-rel-22]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.2/aspnetcore-runtime-latest-linux-musl-x64.tar.gz
-
-[badge-rel-21]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.1/aspnetcore-runtime-win-x64-version-badge.svg
-[win-x64-zip-rel-21]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.1/aspnetcore-runtime-latest-win-x64.zip
-[win-x64-exe-rel-21]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.1/aspnetcore-runtime-latest-win-x64.exe
-[win-x86-zip-rel-21]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.1/aspnetcore-runtime-latest-win-x86.zip
-[win-x86-exe-rel-21]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.1/aspnetcore-runtime-latest-win-x86.exe
-[linux-x64-tar-rel-21]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.1/aspnetcore-runtime-latest-linux-x64.tar.gz
-[osx-x64-tar-rel-21]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.1/aspnetcore-runtime-latest-osx-x64.tar.gz
-[debian-x64-deb-rel-21]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.1/aspnetcore-runtime-latest-x64.deb
-[redhat-x64-rpm-rel-21]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.1/aspnetcore-runtime-latest-x64.rpm
-[linux-arm-tar-rel-21]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.1/aspnetcore-runtime-latest-linux-arm.tar.gz
-[linux-musl-x64-tar-rel-21]: https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/release/2.1/aspnetcore-runtime-latest-linux-musl-x64.tar.gz
-
-Platform              | Latest (master branch) <br> ![][badge-master]                      | release/2.2 <br> ![][badge-rel-22] | release/2.1 <br> ![][badge-rel-21]
-:---------------------|:----------------------------------------------------------------|:------------------------------------------------------------------------- |:-------------------------------------------------------------------------
-Channel name<sup>1</sup> | `master` | `release/2.2` | `release/2.1`
-Windows (x64)         | [Installer (exe)][win-x64-exe]<br>[Archive (zip)][win-x64-zip]   | [Installer (exe)][win-x64-exe-rel-22]<br>[Archive (zip)][win-x64-zip-rel-22] | [Installer (exe)][win-x64-exe-rel-21]<br>[Archive (zip)][win-x64-zip-rel-21]
-Windows (x86)         | [Installer (exe)][win-x86-exe]<br>[Archive (zip)][win-x86-zip]   | [Installer (exe)][win-x86-exe-rel-22]<br>[Archive (zip)][win-x86-zip-rel-22] | [Installer (exe)][win-x86-exe-rel-21]<br>[Archive (zip)][win-x86-zip-rel-21]
-macOS (x64)           | [Archive (tar.gz)][osx-x64-tar]                                  | [Archive (tar.gz)][osx-x64-tar-rel-22] | [Archive (tar.gz)][osx-x64-tar-rel-21]
-Linux (x64)<br>_(for glibc based OS - most common)_ | [Archive (tar.gz)][linux-x64-tar]                                | [Archive (tar.gz)][linux-x64-tar-rel-22] | [Archive (tar.gz)][linux-x64-tar-rel-21]
-Linux (x64 - musl)<br>_(for musl based OS, such as Alpine Linux)_ | [Archive (tar.gz)][linux-musl-x64-tar]                           | [Archive (tar.gz)][linux-musl-x64-tar-rel-22] | [Archive (tar.gz)][linux-musl-x64-tar-rel-21]
-Linux (arm32)         | [Archive (tar.gz)][linux-arm-tar]                                | [Archive (tar.gz)][linux-arm-tar-rel-22] | [Archive (tar.gz)][linux-arm-tar-rel-21]
-Linux (arm64)         | [Archive (tar.gz)][linux-arm64-tar]                                | |
-Debian/Ubuntu (x64)   | [Installer (deb)][debian-x64-deb]                                | [Installer (deb)][debian-x64-deb-rel-22] | [Installer (deb)][debian-x64-deb-rel-21]
-RedHat/Fedora (x64)   | [Installer (rpm)][redhat-x64-rpm]                                | [Installer (rpm)][redhat-x64-rpm-rel-22] | [Installer (rpm)][redhat-x64-rpm-rel-21]
-
-> <sup>1</sup> For use with the `-Channel` argument in [dotnet-install.ps1/sh](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-install-script).
+* *Enable Source Link support* in Visual Studio should be enabled.
+* *Enable source server support* in Visual should be enabled.
+* *Enable Just My Code* should be disabled
+* Under Symbols enable the *Microsoft Symbol Servers* setting.
--- a/docs/Helix.md
+++ b/docs/Helix.md
@ -0,0 +1,66 @@
+Helix testing in ASP.NET Core
+==============================
+
+Helix is the distributed test platform that we use to run tests.  We build a helix payload that contains the publish directory of every test project that we want to test
+send a job with with this payload to a set of queues for the various combinations of OS that we want to test
+for example: `Windows.10.Amd64.ClientRS4.VS2017.Open`, `OSX.1012.Amd64.Open`, `Ubuntu.1804.Amd64.Open`. Helix takes care of unzipping, running the job, and reporting results.
+
+For more info about helix see: [SDK](https://github.com/dotnet/arcade/blob/master/src/Microsoft.DotNet.Helix/Sdk/Readme.md), [JobSender](https://github.com/dotnet/arcade/blob/master/src/Microsoft.DotNet.Helix/Sdk/Readme.md)
+
+## Running helix tests locally
+
+To run Helix tests for one particular test project:
+
+```
+cd src/MyCode/test
+dotnet msbuild /t:Helix
+```
+
+To run tests for the entire repo, run:
+
+```
+.\eng\scripts\TestHelix.ps1
+```
+
+This will restore, and then publish all of the test projects including some bootstrapping scripts that will install the correct dotnet runtime/sdk before running the test assemblies on the helix machine, and upload the job to helix.
+
+
+## How do I look at the results of a helix run on Azure Pipelines?
+There's a link embedded in the build.cmd log of the helix target on Azure Pipelines, near the bottom right that will look something like this:
+```
+2019-02-07T21:55:48.1516089Z   Results will be available from https://mc.dot.net/#/user/aspnetcore/pr~2Faspnet~2Faspnetcore/ci/20190207.34
+2019-02-07T21:56:43.2209607Z   Job 0dedeef6-210e-4815-89f9-fd07513179fe is completed with 108 finished work items.
+2019-02-07T21:56:43.5091018Z   Job 4c45a464-9464-4321-906c-2503320066b0 is completed with 108 finished work items.
+2019-02-07T21:56:43.6863473Z   Job 91a826de-fd51-42c2-9e7e-84bbe18b16cf is completed with 108 finished work items.
+2019-02-07T21:56:43.8591328Z   Job b3595ab8-049d-4775-9cea-d1140a0cb446 is completed with 108 finished work items.
+2019-02-07T21:56:44.0384313Z   Job 2f174f2b-f6b1-4683-8303-3f120865c341 is completed with 108 finished work items.
+2019-02-07T21:56:44.2069520Z   Job b9387311-e670-4e18-9c84-479b7bfe67d1 is completed with 111 finished work items.
+2019-02-07T21:56:44.3946686Z   Job 43582e31-5648-47be-ac42-8a5e4129f15f is completed with 108 finished work items.
+2019-02-07T21:56:44.5568847Z   Job 1e6b0051-21a4-4b75-93f3-f739bb71d5dc is completed with 108 finished work items.
+2019-02-07T22:01:26.0028154Z   Job d597c581-f81b-446c-8daf-7c6511b526f7 is completed with 108 finished work items.
+2019-02-07T22:06:33.6898567Z   Job 82f27d4c-9099-4f0e-b383-870c24d8dc2c is completed with 108 finished work items.
+```
+
+The link will take you to an overview of all the tests with clickable links to the logs and each run broken down by queue.
+
+All of the helix runs for aspnetcore can be found here https://mc.dot.net/#/user/aspnetcore/builds
+
+## What do I do if a test fails?
+You can simulate how most tests run locally:
+```
+dotnet publish
+cd <the publish directory>
+dotnet vstest My.Tests.dll
+```
+
+If that doesn't help, you can try the Get Repro environment link from mission control and try to debug that way.
+
+## Differences from running tests locally
+Most tests that don't just work on helix automatically are ones that depend on the source code being accessible. The helix payloads only contain whatever is in the publish directories, so any thing else that test depends on will need to be included to the payload (TBD how to do this).
+
+## How to skip tests on helix
+There are two main ways to opt out of helix
+- Skipping the entire test project via `<BuildHelixPayload>false</BuildHelixPayload>` in csproj (the default value for this is IsTestProject).
+- Skipping an individual test via `[SkipOnHelix("url to github issue")]` which might require including a compile reference to: `<Compile Include="$(SharedSourceRoot)test\SkipOnHelixAttribute.cs" />`
+
+Make sure to file an issue for any skipped tests and include that in a comment next to either of these
--- a/docs/PackageArchives.md
+++ b/docs/PackageArchives.md
@ -42,14 +42,9 @@ The result of this typically means including the transitive graph of the followi
  - Packages that match bundled runtimes
    - Microsoft.NETCore.App
    - Microsoft.AspNetCore.App
-    - Microsoft.AspNetCore.All
  - Packages that Microsoft.NET.Sdk adds implicitly
    - Microsoft.NETCore.App
    - NETStandard.Library
-  - Packages that are a PackageReference/DotNetCliToolReference in basic ASP.NET Core templates. In addition to packages above, this typically includes:
-    - Microsoft.EntityFrameworkCore.Tools{.DotNet}
-    - Microsoft.VisualStudio.Web.CodeGeneration.Design
-    - Microsoft.VisualStudio.Web.BrowserLink

 ### Example

@ -64,5 +59,4 @@ Given the following parameters:
 The LZMA should contain
  - Microsoft.NETCore.App/2.1.0 + netcoreapp2.1 dependencies (Microsoft.NET.Sdk will implicitly reference "2.1", which NuGet to 2.1.0)
  - Microsoft.NETCore.App/2.1.8 + netcoreapp2.1 dependencies (Matches the runtime in shared/Microsoft.NETCore.App/2.1.8/)
-  - Microsoft.AspNetCore.All/2.1.7 + netcoreapp2.1 dependencies (Matches the runtime in shared/Microsoft.AspNetCore.All/2.1.7/)
  - NETStandard.Library/2.0.1 + netstandard2.0 dependencies (Microsoft.NET.Sdk will implicitly reference "2.0.1")
--- a/docs/PreparingPatchUpdates.md
+++ b/docs/PreparingPatchUpdates.md
@ -3,45 +3,12 @@ Preparing new servicing updates

 In order to prepare this repo to build a new servicing update, the following changes need to be made.

-* Increment the patch version in the [version.props](/version.props) file in the repository root.
+* Increment the patch version in the [eng/Versions.props](/eng/Versions.props) file in the repository root.

    ```diff
    -  <AspNetCorePatchVersion>7</AspNetCorePatchVersion>
    +  <AspNetCorePatchVersion>8</AspNetCorePatchVersion>
    ```

-* Update the package archive baselines. This is used to make sure each build of the package archives we give to Azure only contains new files and does
-  not require overwriting existing files. See [src/PackageArchive/ZipManifestGenerator/](/src/PackageArchive/ZipManifestGenerator/README.md) for instructions on how to run this tool.
-
 * Update the package baselines. This is used to ensure packages keep a consistent set of dependencies between releases.
  See [eng/tools/BaselineGenerator/](/eng/tools/BaselineGenerator/README.md) for instructions on how to run this tool.
-
-* **For the subset of external dependencies mentioned at the top of [build/dependencies.props](/build/dependencies.props):**
-  If a package (Microsoft.NetCore.App for example) shipped in the last release, update the package version properties.
-
-  * Changes made above to external dependencies listed in [eng/Baseline.Designer.props](/eng/Baseline.Designer.props)
-    should _not_ require further updates. The versions of affected packages should have been updated in
-    [build/dependencies.props](/build/dependencies.props) during the previous patching cycle.
-
-* **For packages with source code in this repo (not a submodule):** Update the list of packages in [eng/PatchConfig.props](/eng/PatchConfig.props) to list which packages should be patching in this release.
-
-* **For packages still building from submodules:** Update the list of repositories which will contain changes in [build/submodules.props](/build/submodules.props).
-
-  * `<ShippedRepository>` items represent repos which were released in a previous patch, and will not contain servicing updates in the next patch.
-  * `<Repository>` items represent repos which will produce new packages in this patch.
-  * It is usually best to move everything to `<ShippedRepository>` and then iteratively add them back to `<Repository>` as new repos receive approval to patch.
-    * But, do not change the Templating item at all. That is only _treated_ as a submodule.
-  * Don't change the `PatchPolicy` attribute. The build system uses this to ensure patching rules are obeyed.
-
-* **For each repository still listed as a `<Repository>`:** Update the version.props file in that submodule. For example, https://github.com/aspnet/EntityFrameworkCore/pull/15369/files#diff-2a92b4d7f8df251ffd3a0aa63e97aad5
-
-  * This leaves holes in versioning, which is okay. This may mean you increment the patch value by more than one. Example:
-    * EF Core ships patches in 2.1.8 as "2.1.8"
-    * EF Core does not ship patches in 2.1.9 or 2.1.10
-    * EF Core ships in 2.1.11, therefore, EFCore's version.props file should jump from 2.1.8 to 2.1.11.
-
-    ```diff
-    <!-- Example change to modules/EntityFrameworkCore/version.props -->
-    - <PatchVersion>8</PatchVersion>
-    + <PatchVersion>11</PatchVersion>
-    ```
--- a/docs/ProjectProperties.md
+++ b/docs/ProjectProperties.md
@ -0,0 +1,12 @@
+Project Properties
+==================
+
+In addition to the standard set of MSBuild properties supported by Microsoft.NET.Sdk, projects in this repo often use these additional properties.
+
+Property name      | Meaning
+-------------------|--------------------------------------------------------------------------------------------
+IsPackable         | Set to `true` when the project should produce a package. That package may or may not ship to customers (depending on `IsShippingPackage`). Defaults to `true` for analyzer and implementation projects; `false` otherwise.
+IsShipping         | Set to `true` when the project output is intended for use by customers. Defaults to `true` for analyzer, implementation and specification test projects; `false` otherwise.
+IsShippingPackage  | Set to `true` when a package produced from project is intended for use by customers. Defaults to `IsShipping`. Note this may be `true` even for projects with `IsPackable` set to `false`.
+IsAspNetCoreApp    | Set to `true` when the assembly is part of the [Microsoft.AspNetCore.App shared framework](./SharedFramework.md) and is not available as a NuGet package (unless `IsPackable` is also set to `true` -- the default). Defaults to `false`.
+TestDependsOnMssql | Set to `true` when your tests depends on SQL Server. This will ensure distribute tests on Helix install LocalDB ([more information on Helix](./Helix.md)). Defaults to `false`.
--- a/docs/README.md
+++ b/docs/README.md
@ -2,4 +2,4 @@ Contributor documentation
 =========================

 The primary audience for documentation in this folder is contributors to ASP.NET Core.
-If you are looking for documentation on to *use* ASP.NET Core, go to <https://docs.asp.net>.
+If you are looking for documentation on how to *use* ASP.NET Core, go to <https://docs.asp.net>.
--- a/docs/ReferenceAssemblies.md
+++ b/docs/ReferenceAssemblies.md
@ -0,0 +1,25 @@
+Reference assemblies
+========================
+
+Most projects in this repo have a `ref` directory next to their `src` that contains the project and source code for a reference assembly.
+Reference assemblies contain the public API surface of libraries and are used for ASP.NET Core targeting pack generation.
+
+### When changing public API
+
+Run `dotnet msbuild /t:GenerateReferenceSource` in that project's `src` directory
+
+### When adding a new project
+
+Run `.\eng\scripts\GenerateProjectList.ps1` from the repository root and `dotnet msbuild /t:GenerateReferenceSource` in that project's `src` directory
+
+### To set project properties in a reference assembly project
+
+`ref.csproj` is automaticaly generated and shouldn't be edited. To set project properties on a reference assembly project place a `Directory.Build.props` next to it and add the properties there.
+
+### My project doesn't need a reference assembly
+
+Set `<HasReferenceAssembly>false</HasReferenceAssembly>` in the implementation (`src`) project and re-run `.\eng\scripts\GenerateProjectList.ps1`.
+
+### Regenerate reference assemblies for all projects
+
+Run `.\eng\scripts\GenerateReferenceAssemblies.ps1` from repository root.
--- a/docs/ReferenceResolution.md
+++ b/docs/ReferenceResolution.md
@ -1,5 +1,4 @@
-`<Reference>` resolution
-========================
+# `<Reference>` resolution

 Most project files in this repo should use `<Reference>` instead of `<ProjectReference>` or `<PackageReference>`.
 This was done to enable ASP.NET Core's unique requirements without requiring most ASP.NET Core contributors
@ -18,17 +17,91 @@ The requirements that led to this system are:

 ## Recommendations for writing a .csproj

-* Use `<Reference>`
-* Do not use `<PackageReference>`
-* Only use `<ProjectReference>` in test projects
+* Use `<Reference>`.
+* Do not use `<PackageReference>`.
+* If you need to use a new package, add it to `eng/Dependencies.props` and `eng/Versions.props`.
+* If the package comes from a partner team and needs to have versions automatically updated, also add an entry `eng/Version.Details.xml`.
+* Only use `<ProjectReference>` in test projects.
 * Name the .csproj file to match the assembly name.
-* Run `build.cmd /t:GenerateProjectList` when adding new projects
+* Run `eng/scripts/GenerateProjectList.ps1` (or `build.cmd /t:GenerateProjectList`) when adding new projects
 * Use [eng/tools/BaseLineGenerator/](/eng/tools/BaselineGenerator/README.md) if you need to update baselines.
+* If you need to make a breaking change to dependencies, you may need to add `<SuppressBaselineReference>`.

 ## Important files

 * [eng/Baseline.xml](/eng/Baseline.xml) - this contains the 'baseline' of the latest servicing release for this branch. It should be modified and used to update the generated file, Baseline.Designer.props.
 * [eng/Dependencies.props](/eng/Dependencies.props) - contains a list of all package references that might be used in the repo.
-* [eng/PatchConfig.props](/eng/PatchConfig.props) - lists which assemblies or packages are patching in the current build.
-* [eng/ProjectReferences.props](/eng/ProjectReferences.props) - lists which assemblies or packages might be available to be referenced as a local project
-* [eng/Versions.props](/eng/Versions.props) - contains a list of versions which may be updated by automation.
+* [eng/ProjectReferences.props](/eng/ProjectReferences.props) - lists which assemblies or packages might be available to be referenced as a local project.
+* [eng/Versions.props](/eng/Versions.props) - contains a list of versions which may be updated by automation. This is used by MSBuild to restore and build.
+* [eng/Version.Details.xml](/eng/Version.Details.xml) - used by automation to update dependencies variables in other files.
+
+## Example: adding a new project
+
+Steps for adding a new project to this repo.
+
+1. Create the .csproj
+2. Run `eng/scripts/GenerateProjectList.ps1`
+3. Add it to Extensions.sln
+
+## Example: adding a new dependency
+
+Steps for adding a new package dependency to an existing project. Let's say I'm adding a dependency on System.Banana.
+
+1. Add the package to the .csproj file using `<Reference Include="System.Banana" />`
+2. Add an entry to [eng/Dependencies.props](/eng/Dependencies.props), `<LatestPackageReference Include="System.Banana" Version="0.0.1-beta-1" />`
+3. If this package comes from another dotnet team and should be updated automatically by our bot...
+    1. Change the LatestPackageReference entry to `Version="$(SystemBananaPackageVersion)"`.
+    2. Add an entry to [eng/Versions.props](/eng/Versions.props) like this `<SystemBananaPackageVersion>0.0.1-beta-1</SystemBananaPackageVersion>`.
+    3. Add an entry to [eng/Version.Details.xml](/eng/Version.Details.xml) like this:
+
+        ```xml
+        <ProductDependencies>
+          <!-- ... -->
+          <Dependency Name="System.Banana" Version="0.0.1-beta-1">
+            <Uri>https://github.com/dotnet/corefx</Uri>
+            <Sha>000000</Sha>
+          </Dependency>
+          <!-- ... -->
+        </ProductDependencies>
+        ```
+
+       If you don't know the commit hash of the source code used to produce "0.0.1-beta-1", you can use `000000` as a placeholder for `Sha`
+       as its value is unimportant and will be updated the next time the bot runs.
+
+        If the new dependency comes from dotnet/CoreFx, dotnet/code-setup or aspnet/Extensions, add a
+        `CoherentParentDependency` attribute to the `<Dependency>` element as shown below. This example indicates the
+        dotnet/CoreFx dependency version should be determined based on the build that produced the chosen
+        Microsoft.NETCore.App. That is, the dotnet/CoreFx dependency and Microsoft.NETCore.App should be
+        coherent.
+
+        ```xml
+        <Dependency Name="System.Banana" Version="0.0.1-beta-1" CoherentParentDependency="Microsoft.NETCore.App">
+          <!-- ... -->
+        </Dependency>
+        ```
+
+        The attribute value should be `"Microsoft.Extensions.Logging"` for dotnet/core-setup dependencies and
+        `"Microsoft.CodeAnalysis.Razor"` for aspnet/Extensions dependencies.
+
+## Example: make a breaking change to references
+
+If Microsoft.AspNetCore.Banana in 2.1 had a reference to `Microsoft.AspNetCore.Orange`, but in 3.0 this reference is changing to `Microsoft.AspNetCore.BetterThanOrange`, you would need to make these changes to the .csproj file
+
+```diff
+<!-- in Microsoft.AspNetCore.Banana.csproj -->
+  <ItemGroup>
+-    <Reference Include="Microsoft.AspNetCore.Orange" /> <!-- the old dependency -->
+    <Reference Include="Microsoft.AspNetCore.BetterThanOrange" /> <!-- the new dependency -->
+    <SuppressBaselineReference Include="Microsoft.AspNetCore.Orange" /> <!-- suppress as a known breaking change -->
+  </ItemGroup>
+```
+
+## Updating dependencies manually
+
+If the `dotnet-maestro` bot has not correctly updated the dependencies, it may be worthwhile running `darc` manually:
+
+1. Install `darc` as described in https://github.com/dotnet/arcade/blob/master/Documentation/Darc.md#setting-up-your-darc-client
+2. Run `darc update-dependencies --channel '.NET Core 3 Dev'`
+   * Use `'.NET Core 3 Release'` in a `release/3.0-*` branch
+3. `git diff` to confirm the tool's changes
+4. Proceed with usual commit and PR
--- a/docs/SharedFramework.md
+++ b/docs/SharedFramework.md
@ -0,0 +1,30 @@
+ASP.NET Core Shared Framework
+=============================
+
+Guidance on developing the ASP.NET Core shared framework (`Microsoft.AspNetCore.App`).
+
+### What goes into the shared framework?
+
+The ASP.NET Core shared framework contains assemblies that are fully developed, supported, and serviceable by Microsoft. You can think of this as constituting the ASP.NET Core *platform*. As such, all assemblies which are included in the shared framework are expected to meet specific requirements. Here are the principles we are using to guide our decisions about what is allowed in the shared framework.
+
+* Breaking changes are highly discouraged. Therefore,
+  * If it's in, it must be broadly useful and expected to be supported for at least several years.
+  * The API for all assemblies in shared framework MUST NOT make breaking changes in patch or minor releases.
+* The complete closure of all assemblies must be in the shared framework, or must be in the "base framework", Microsoft.NETCore.App
+* No 3rd party dependencies. All packages must be fully serviceable by Microsoft.
+* Teams which own components in the shared framework must coordinate security fixes, patches, and updates with the .NET Core team.
+* Code must be open-source and buildable using only open-source tools
+* Usage
+   * How much an API is used is an important metric, but not the only factor
+   * API we believe is essential for central experiences in .NET Core should be in the shared framework
+   * Examples of central experiences: MVC, Kestrel, Razor, SignalR
+* New API can ship as out-of-band packages first, and move into the base framework later when it meets these standards
+
+### How to adjust what is in the shared framework
+
+The contents of the shared framework are defined in two ways:
+
+* [eng/SharedFramework.Local.props](/eng/SharedFramework.Local.props) - this file is generated from the .csproj files in this repo
+  by looking for projects which have set `<IsAspNetCoreApp>true</IsAspNetCoreApp>`.
+* [eng/SharedFramework.External.props](/eng/SharedFramework.External.props) - this file lists all assemblies shipped
+  in Microsoft.AspNetCore.App which are built by source code found in other repositories.
--- a/eng/AfterSigning.targets
+++ b/eng/AfterSigning.targets
@ -0,0 +1,33 @@
+<Project>
+
+  <Import Project="Sdk.props" Sdk="Microsoft.DotNet.Arcade.Sdk" Condition="'$(GenerateChecksums)' == 'true'" />
+
+  <PropertyGroup Condition="'$(GenerateChecksums)' == 'true'">
+    <!-- The one use of ArtifactsDir in Publish.proj adds an additional slash, confusing itself. -->
+    <ArtifactsDir Condition=" HasTrailingSlash('$(ArtifactsDir)') ">$(ArtifactsDir.Substring(0, $([MSBuild]::Subtract($(ArtifactsDir.Length), 1))))</ArtifactsDir>
+    <!-- $(InstallersOutputPath) is not defined. Root Directory.Build.props is not imported. -->
+    <InstallersOutputPath>$(ArtifactsDir)\installers\</InstallersOutputPath>
+  </PropertyGroup>
+
+  <Target Name="PopulateGenerateChecksumItems"
+          Condition="'$(GenerateChecksums)' == 'true'"
+          AfterTargets="Build"
+          BeforeTargets="GenerateChecksums" >
+
+    <ItemGroup>
+      <InstallerFiles Include="$(InstallersOutputPath)**\*.msi" />
+      <InstallerFiles Include="$(InstallersOutputPath)**\*.exe" />
+      <InstallerFiles Include="$(InstallersOutputPath)**\*.zip" />
+      <InstallerFiles Include="$(InstallersOutputPath)**\*.tar.gz" />
+      <InstallerFiles Include="$(InstallersOutputPath)**\*.wixlib" />
+      <InstallerFiles Include="$(InstallersOutputPath)**\*.rpm" />
+      <GenerateChecksumItems Include="%(InstallerFiles.Identity)" >
+        <DestinationPath>%(FullPath).sha512</DestinationPath>
+      </GenerateChecksumItems>
+    </ItemGroup>
+
+  </Target>
+
+  <Import Project="Sdk.targets" Sdk="Microsoft.DotNet.Arcade.Sdk" Condition="'$(GenerateChecksums)' == 'true'" />
+
+</Project>
--- a/eng/AfterSolutionBuild.targets
+++ b/eng/AfterSolutionBuild.targets
@ -0,0 +1,20 @@
+<Project>
+
+  <Import Project="tools\RepoTasks\RepoTasks.tasks" />
+  <Import Project="SharedFramework.External.props" />
+  <Import Project="SharedFramework.Local.props" />
+
+  <!-- This is temporary until we can use FrameworkReference to build our own packages. -->
+  <Target Name="RemoveSharedFrameworkOnlyRefsFromNuspec" AfterTargets="Pack">
+    <ItemGroup>
+      <_BuildOutput Include="$(ArtifactsShippingPackagesDir)*.nupkg"
+                    Exclude="$(ArtifactsShippingPackagesDir)*.symbols.nupkg" />
+    </ItemGroup>
+
+    <RepoTasks.RemoveSharedFrameworkDependencies Condition="@(_BuildOutput->Count()) != 0"
+      Files="@(_BuildOutput)"
+      FrameworkOnlyPackages="@(AspNetCoreAppReference)"
+      SharedFrameworkTargetFramework="netcoreapp$(AspNetCoreMajorVersion).$(AspNetCoreMinorVersion)" />
+  </Target>
+
+</Project>
--- a/eng/Baseline.Designer.props
+++ b/eng/Baseline.Designer.props
--- a/eng/Baseline.xml
+++ b/eng/Baseline.xml
@ -1,130 +1,83 @@
 <!--

-This file contains a list of all the packages and their versions which were released in the last servicing
-build of ASP.NET Core 2.1.x. Update this list when preparing for a new patch.
+This file contains a list of all the packages and their versions which were released in ASP.NET Core 3.1.0.
+Update this list when preparing for a new patch.

 -->
-<Baseline Version="2.1.18">
-  <Package Id="dotnet-dev-certs" Version="2.1.1" />
-  <Package Id="dotnet-sql-cache" Version="2.1.1" />
-  <Package Id="dotnet-user-secrets" Version="2.1.1" />
-  <Package Id="dotnet-watch" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Antiforgery" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.ApplicationInsights.HostingStartup" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Authentication.Abstractions" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Authentication.AzureAD.UI" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Authentication.AzureADB2C.UI" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Authentication.Cookies" Version="2.1.16" />
-  <Package Id="Microsoft.AspNetCore.Authentication.Core" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Authentication.Facebook" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Authentication.Google" Version="2.1.8" />
-  <Package Id="Microsoft.AspNetCore.Authentication.JwtBearer" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Authentication.MicrosoftAccount" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Authentication.OAuth" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Authentication.OpenIdConnect" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Authentication.Twitter" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Authentication.WsFederation" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Authentication" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Authorization.Policy" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Authorization" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.AzureAppServices.HostingStartup" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.AzureAppServicesIntegration" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Connections.Abstractions" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.CookiePolicy" Version="2.1.14" />
-  <Package Id="Microsoft.AspNetCore.Cors" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Cryptography.Internal" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Cryptography.KeyDerivation" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.DataProtection.Abstractions" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.DataProtection.AzureKeyVault" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.DataProtection.AzureStorage" Version="2.1.13" />
-  <Package Id="Microsoft.AspNetCore.DataProtection.Extensions" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.DataProtection.Redis" Version="0.4.1" />
-  <Package Id="Microsoft.AspNetCore.DataProtection.SystemWeb" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.DataProtection" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Diagnostics.Abstractions" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Diagnostics" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.HostFiltering" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Hosting.Abstractions" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Hosting.Server.Abstractions" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Hosting.WindowsServices" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Hosting" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Html.Abstractions" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Http.Abstractions" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Http.Connections.Client" Version="1.0.4" />
-  <Package Id="Microsoft.AspNetCore.Http.Connections.Common" Version="1.0.4" />
-  <Package Id="Microsoft.AspNetCore.Http.Connections" Version="1.0.15" />
-  <Package Id="Microsoft.AspNetCore.Http.Extensions" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Http.Features" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Http" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.HttpOverrides" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.HttpsPolicy" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="2.1.6" />
-  <Package Id="Microsoft.AspNetCore.Identity.Specification.Tests" Version="2.1.6" />
-  <Package Id="Microsoft.AspNetCore.Identity.UI" Version="2.1.11" />
-  <Package Id="Microsoft.AspNetCore.Identity" Version="2.1.6" />
-  <Package Id="Microsoft.AspNetCore.JsonPatch" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Localization.Routing" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Localization" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.MiddlewareAnalysis" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Mvc.Abstractions" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Mvc.Analyzers" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Mvc.ApiExplorer" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Mvc.Core" Version="2.1.16" />
-  <Package Id="Microsoft.AspNetCore.Mvc.Cors" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Mvc.DataAnnotations" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Mvc.Formatters.Json" Version="2.1.18" />
-  <Package Id="Microsoft.AspNetCore.Mvc.Formatters.Xml" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Mvc.Localization" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Mvc.Razor.Extensions" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Mvc.Razor" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Mvc.Razor.ViewCompilation" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Mvc.RazorPages" Version="2.1.11" />
-  <Package Id="Microsoft.AspNetCore.Mvc.TagHelpers" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Mvc.Testing" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Mvc.ViewFeatures" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Mvc.WebApiCompatShim" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Mvc" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.NodeServices" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Owin" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Razor.Design" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Razor.Language" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Razor.Runtime" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.Razor" Version="2.1.2" />
-  <Package Id="Microsoft.AspNetCore.ResponseCaching.Abstractions" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.ResponseCaching" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.ResponseCompression" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Rewrite" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Routing.Abstractions" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Routing" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.Server.HttpSys" Version="2.1.12" />
-  <Package Id="Microsoft.AspNetCore.Server.IISIntegration" Version="2.1.7" />
-  <Package Id="Microsoft.AspNetCore.Server.Kestrel.Core" Version="2.1.7" />
-  <Package Id="Microsoft.AspNetCore.Server.Kestrel.Https" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Server.Kestrel.Transport.Abstractions" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Server.Kestrel.Transport.Libuv" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Server.Kestrel" Version="2.1.3" />
-  <Package Id="Microsoft.AspNetCore.Session" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.SignalR.Client.Core" Version="1.0.4" />
-  <Package Id="Microsoft.AspNetCore.SignalR.Client" Version="1.0.4" />
-  <Package Id="Microsoft.AspNetCore.SignalR.Common" Version="1.0.4" />
-  <Package Id="Microsoft.AspNetCore.SignalR.Core" Version="1.0.15" />
-  <Package Id="Microsoft.AspNetCore.SignalR.Protocols.Json" Version="1.0.4" />
-  <Package Id="Microsoft.AspNetCore.SignalR.Protocols.MessagePack" Version="1.0.11" />
-  <Package Id="Microsoft.AspNetCore.SignalR.Redis" Version="1.0.11" />
-  <Package Id="Microsoft.AspNetCore.SignalR" Version="1.0.4" />
-  <Package Id="Microsoft.AspNetCore.SpaServices.Extensions" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.SpaServices" Version="2.1.13" />
-  <Package Id="Microsoft.AspNetCore.StaticFiles" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.TestHost" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore.WebSockets" Version="2.1.7" />
-  <Package Id="Microsoft.AspNetCore.WebUtilities" Version="2.1.1" />
-  <Package Id="Microsoft.AspNetCore" Version="2.1.7" />
-  <Package Id="Microsoft.CodeAnalysis.Razor" Version="2.1.2" />
-  <Package Id="Microsoft.Extensions.Identity.Core" Version="2.1.6" />
-  <Package Id="Microsoft.Extensions.Identity.Stores" Version="2.1.6" />
-  <Package Id="Microsoft.Net.Http.Headers" Version="2.1.14" />
-  <Package Id="Microsoft.Net.Sdk.Razor" Version="2.1.2" />
-  <Package Id="Microsoft.Owin.Security.Interop" Version="2.1.2" />
+<Baseline Version="3.1.5">
+  <Package Id="AspNetCoreRuntime.3.0.x64" Version="3.0.3" />
+  <Package Id="AspNetCoreRuntime.3.0.x86" Version="3.0.3" />
+  <Package Id="dotnet-sql-cache" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.ApiAuthorization.IdentityServer" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.App.Runtime.win-x64" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Authentication.AzureAD.UI" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Authentication.AzureADB2C.UI" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Authentication.Certificate" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Authentication.Facebook" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Authentication.Google" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Authentication.JwtBearer" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Authentication.MicrosoftAccount" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Authentication.Negotiate" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Authentication.OpenIdConnect" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Authentication.Twitter" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Authentication.WsFederation" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Authorization" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.AzureAppServices.HostingStartup" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.AzureAppServices.SiteExtension" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.AzureAppServicesIntegration" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Components" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Components.Analyzers" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Components.Authorization" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Components.Forms" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Components.Web" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.ConcurrencyLimiter" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Connections.Abstractions" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Cryptography.Internal" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Cryptography.KeyDerivation" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.DataProtection" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.DataProtection.Abstractions" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.DataProtection.AzureKeyVault" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.DataProtection.AzureStorage" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.DataProtection.EntityFrameworkCore" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.DataProtection.Extensions" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.DataProtection.StackExchangeRedis" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.HeaderPropagation" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Hosting.WindowsServices" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Http.Connections.Client" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Http.Connections.Common" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Http.Features" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Identity.Specification.Tests" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Identity.UI" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.JsonPatch" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Metadata" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.MiddlewareAnalysis" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Mvc.Testing" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.NodeServices" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Owin" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.Server.Kestrel.Transport.Libuv" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.SignalR.Client" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.SignalR.Client.Core" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.SignalR.Common" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.SignalR.Protocols.Json" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.SignalR.Protocols.MessagePack" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.SignalR.Protocols.NewtonsoftJson" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.SignalR.Specification.Tests" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.SignalR.StackExchangeRedis" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.SpaServices" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.SpaServices.Extensions" Version="3.1.5" />
+  <Package Id="Microsoft.AspNetCore.TestHost" Version="3.1.5" />
+  <Package Id="Microsoft.dotnet-openapi" Version="3.1.5" />
+  <Package Id="Microsoft.DotNet.Web.Client.ItemTemplates" Version="3.1.5" />
+  <Package Id="Microsoft.DotNet.Web.ItemTemplates" Version="3.1.5" />
+  <Package Id="Microsoft.DotNet.Web.ProjectTemplates.3.1" Version="3.1.5" />
+  <Package Id="Microsoft.DotNet.Web.Spa.ProjectTemplates.3.1" Version="3.1.5" />
+  <Package Id="Microsoft.Extensions.ApiDescription.Client" Version="3.1.5" />
+  <Package Id="Microsoft.Extensions.ApiDescription.Server" Version="3.1.5" />
+  <Package Id="Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore" Version="3.1.5" />
+  <Package Id="Microsoft.Extensions.Identity.Core" Version="3.1.5" />
+  <Package Id="Microsoft.Extensions.Identity.Stores" Version="3.1.5" />
 </Baseline>
--- a/eng/Build.props
+++ b/eng/Build.props
@ -0,0 +1,197 @@
+<Project>
+  <PropertyGroup>
+    <TargetRuntimeIdentifier Condition="'$(TargetRuntimeIdentifier)' == ''">$(TargetOsName)-$(TargetArchitecture)</TargetRuntimeIdentifier>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(BuildAllProjects)' == 'true' ">
+    <BuildNative Condition="'$(BuildNative)' == ''">true</BuildNative>
+    <BuildManaged Condition="'$(BuildManaged)' == ''">true</BuildManaged>
+    <BuildNodeJS Condition="'$(BuildNodeJS)' == ''">true</BuildNodeJS>
+    <BuildJava Condition="'$(BuildJava)' == ''">true</BuildJava>
+  </PropertyGroup>
+
+  <!-- These projects are always excluded, even when -projects is specified on command line. -->
+  <ItemGroup>
+    <!-- Explicitly excluded projects -->
+    <ProjectToExclude Include="$(ProjectToExclude)" />
+
+    <!-- These projects use 'legacy' csproj, which is not supported by dotnet-msbuild. -->
+    <ProjectToExclude Include="
+                      $(RepoRoot)src\Servers\HttpSys\samples\TestClient\TestClient.csproj;
+                      $(RepoRoot)src\Middleware\WebSockets\samples\TestServer\WebSockets.TestServer.csproj;
+                      "
+                      Condition=" '$(MSBuildRuntimeType)' == 'Core' " />
+
+    <!-- Exclude the websockets samples for now because they use classic .csproj, which is not yet supported in our build. -->
+    <ProjectToExclude Include="$(RepoRoot)src\Middleware\WebSockets\samples\**\*.csproj" />
+
+    <!-- These projects are meant to be executed by tests. -->
+    <ProjectToExclude Include="
+                      $(RepoRoot)src\Tools\dotnet-watch\test\TestProjects\**\*.csproj;
+                      $(RepoRoot)src\Tools\Tests.Common\TestProjects\**\*.csproj;
+                      $(RepoRoot)src\Razor\Razor.Design\test\testassets\**\*.*proj;
+                      $(RepoRoot)src\submodules\**\*.*proj;
+                      $(RepoRoot)src\Installers\**\*.*proj;
+                      $(RepoRoot)src\SignalR\clients\ts\**\node_modules\**\*.*proj;
+                      $(RepoRoot)src\Components\Web.JS\node_modules\**\*.*proj;
+                      $(RepoRoot)src\Components\Blazor\Templates\src\content\**\*.*proj;
+                      $(RepoRoot)src\ProjectTemplates\Web.ProjectTemplates\content\**\*.csproj;
+                      $(RepoRoot)src\ProjectTemplates\Web.ProjectTemplates\content\**\*.fsproj;
+                      $(RepoRoot)src\ProjectTemplates\Web.Spa.ProjectTemplates\content\**\*.csproj;
+                      " />
+
+    <!-- Exclude the benchmarks because they use <PackageReference>. -->
+    <ProjectToExclude Include="
+                      $(RepoRoot)src\Components\benchmarkapps\**\*.csproj;
+                      $(RepoRoot)src\Mvc\benchmarkapps\**\*.csproj;
+                      $(RepoRoot)src\Servers\Kestrel\perf\PlatformBenchmarks\**\*.csproj;
+                      $(RepoRoot)src\SignalR\perf\benchmarkapps\**\*.csproj;
+                      " />
+  </ItemGroup>
+
+  <Choose>
+    <!-- Project selection can be overridden on the command line by passing in -projects -->
+    <When Condition="'$(ProjectToBuild)' != ''">
+      <ItemGroup>
+        <ProjectToBuild Include="$(ProjectToBuild)" Exclude="@(ProjectToExclude);$(RepoRoot)**\bin\**\*;$(RepoRoot)**\obj\**\*">
+          <RestoreInParallel Condition="'%(Extension)' == '.npmproj'">false</RestoreInParallel>
+        </ProjectToBuild>
+      </ItemGroup>
+    </When>
+    <Otherwise>
+      <ItemGroup Condition=" '$(BuildInstallers)' == 'true' AND '$(TargetOsName)' == 'win' ">
+        <!-- Build the ANCM custom action -->
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\AspNetCoreModule-Setup\CustomAction\aspnetcoreCA.vcxproj" AdditionalProperties="Platform=x64" />
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\AspNetCoreModule-Setup\CustomAction\aspnetcoreCA.vcxproj" AdditionalProperties="Platform=Win32" />
+
+        <!-- Build the ANCM msis -->
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\AspNetCoreModule-Setup\ANCMIISExpressV2\AncmIISExpressV2.wixproj" AdditionalProperties="Platform=x64" />
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\AspNetCoreModule-Setup\ANCMIISExpressV2\AncmIISExpressV2.wixproj" AdditionalProperties="Platform=x86" />
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\AspNetCoreModule-Setup\ANCMV2\ANCMV2.wixproj" AdditionalProperties="Platform=x64" />
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\AspNetCoreModule-Setup\ANCMV2\ANCMV2.wixproj" AdditionalProperties="Platform=x86" />
+
+        <!-- Build the targeting pack installers -->
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\TargetingPack\TargetingPack.wixproj" AdditionalProperties="Platform=x64" />
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\TargetingPack\TargetingPack.wixproj" AdditionalProperties="Platform=x86" />
+
+        <!-- Build the SharedFramework installers -->
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\SharedFrameworkBundle\SharedFrameworkBundle.wixproj" AdditionalProperties="Platform=x64" />
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\SharedFrameworkBundle\SharedFrameworkBundle.wixproj" AdditionalProperties="Platform=x86" />
+
+        <!-- Build the SharedFramework wixlib -->
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\SharedFrameworkLib\SharedFrameworkLib.wixproj" AdditionalProperties="Platform=x64" />
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\SharedFrameworkLib\SharedFrameworkLib.wixproj" AdditionalProperties="Platform=x86" />
+
+        <!-- Windows hosting bundled -->
+        <ProjectToBuild Include="$(RepoRoot)src\Installers\Windows\WindowsHostingBundle\WindowsHostingBundle.wixproj" AdditionalProperties="Platform=x86" />
+      </ItemGroup>
+
+      <ItemGroup Condition="'$(BuildInstallers)' == 'true' AND '$(TargetRuntimeIdentifier)' == 'linux-x64'">
+        <ProjectToBuild Condition=" '$(LinuxInstallerType)' == 'deb' "
+                        Include="$(RepoRoot)src\Installers\Debian\**\*.*proj" />
+        <ProjectToBuild Condition=" '$(LinuxInstallerType)' == 'rpm' "
+                        Include="$(RepoRoot)src\Installers\Rpm\**\*.*proj" />
+      </ItemGroup>
+
+      <ItemGroup>
+        <NativeProjects Condition=" '$(TargetOsName)' == 'win' AND ('$(TargetArchitecture)' == 'x86' OR '$(TargetArchitecture)' == 'x64') "
+                        Include="$(RepoRoot)src\**\*.vcxproj" Exclude="@(ProjectToExclude)">
+          <!-- Required to prevent triggering double-builds. See src\Servers\IIS\ResolveIisReferences.targets for details. -->
+          <AdditionalProperties Condition="'$(TargetArchitecture)' == 'x64'">Platform=x64</AdditionalProperties>
+          <AdditionalProperties Condition="'$(TargetArchitecture)' == 'x86'">Platform=Win32</AdditionalProperties>
+        </NativeProjects>
+
+        <ProjectToBuild Condition=" '$(BuildNative)' == 'true'" Include="@(NativeProjects)" Exclude="@(ProjectToExclude)" />
+        <ProjectToExclude Condition=" '$(BuildNative)' != 'true'" Include="@(NativeProjects)" />
+
+        <NodeJsProjects Include="
+                          $(RepoRoot)src\Components\Web.JS\Microsoft.AspNetCore.Components.Web.JS.npmproj;
+                          $(RepoRoot)src\SignalR\**\*.npmproj;
+                          $(RepoRoot)src\Middleware\**\*.npmproj;
+                          "
+                        RestoreInParallel="false"
+                        Exclude="@(ProjectToExclude)" />
+
+        <ProjectToBuild Condition=" '$(BuildNodeJS)' == 'true'" Include="@(NodeJsProjects)" Exclude="@(ProjectToExclude)" />
+        <ProjectToExclude Condition=" '$(BuildNodeJS)' != 'true'" Include="@(NodeJsProjects)" />
+
+        <JavaProjects Include="$(RepoRoot)src\SignalR\**\*.javaproj"
+                      Exclude="@(ProjectToExclude)" />
+
+        <ProjectToBuild Condition=" '$(BuildJava)' == 'true'" Include="@(JavaProjects)" Exclude="@(ProjectToExclude)" />
+        <ProjectToExclude Condition=" '$(BuildJava)' != 'true'" Include="@(JavaProjects)" />
+
+        <!--
+          Use caution to avoid deep recursion. If the globbing pattern picks up something which exceeds MAX_PATH,
+          the entire pattern will silently fail to evaluate correctly.
+        -->
+        <DotNetProjects Include="
+                          $(RepoRoot)src\Framework\ref\Microsoft.AspNetCore.App.Ref.csproj;
+                          $(RepoRoot)src\Framework\src\Microsoft.AspNetCore.App.Runtime.csproj;
+                          $(RepoRoot)src\Framework\test\Microsoft.AspNetCore.App.UnitTests.csproj;
+                          $(RepoRoot)src\DefaultBuilder\**\*.*proj;
+                          $(RepoRoot)src\Features\JsonPatch\**\*.*proj;
+                          $(RepoRoot)src\DataProtection\**\*.*proj;
+                          $(RepoRoot)src\Antiforgery\**\*.*proj;
+                          $(RepoRoot)src\Hosting\**\*.*proj;
+                          $(RepoRoot)src\Http\**\*.*proj;
+                          $(RepoRoot)src\Html\**\*.*proj;
+                          $(RepoRoot)src\Identity\**\*.*proj;
+                          $(RepoRoot)src\Servers\**\*.csproj;
+                          $(RepoRoot)src\Security\**\*.*proj;
+                          $(RepoRoot)src\SiteExtensions\Microsoft.Web.Xdt.Extensions\**\*.csproj;
+                          $(RepoRoot)src\SiteExtensions\LoggingAggregate\test\**\*.csproj;
+                          $(RepoRoot)src\Shared\**\*.*proj;
+                          $(RepoRoot)src\Tools\**\*.*proj;
+                          $(RepoRoot)src\Middleware\**\*.csproj;
+                          $(RepoRoot)src\Razor\**\*.*proj;
+                          $(RepoRoot)src\Mvc\**\*.*proj;
+                          $(RepoRoot)src\Azure\**\*.*proj;
+                          $(RepoRoot)src\MusicStore\**\*.*proj;
+                          $(RepoRoot)src\SignalR\**\*.csproj;
+                          $(RepoRoot)src\Components\**\*.csproj;
+                          $(RepoRoot)src\Analyzers\**\*.csproj;
+                          $(RepoRoot)src\ProjectTemplates\*\*.csproj;
+                          $(RepoRoot)src\ProjectTemplates\testassets\*\*.csproj;
+                          "
+                        Exclude="
+                          @(ProjectToBuild);
+                          @(ProjectToExclude);
+                          $(RepoRoot)**\node_modules\**\*;
+                          $(RepoRoot)**\bin\**\*;
+                          $(RepoRoot)**\obj\**\*;"
+                        Condition=" '$(BuildMainlyReferenceProviders)' != 'true' " />
+        <DotNetProjects Include="
+                          $(RepoRoot)src\DefaultBuilder\**\src\*.csproj;
+                          $(RepoRoot)src\Features\JsonPatch\**\src\*.csproj;
+                          $(RepoRoot)src\DataProtection\**\src\*.csproj;
+                          $(RepoRoot)src\Antiforgery\**\src\*.csproj;
+                          $(RepoRoot)src\Hosting\**\src\*.csproj;
+                          $(RepoRoot)src\Http\**\src\*.csproj;
+                          $(RepoRoot)src\Html\**\src\*.csproj;
+                          $(RepoRoot)src\Identity\**\src\*.csproj;
+                          $(RepoRoot)src\Servers\**\src\*.csproj;
+                          $(RepoRoot)src\Security\**\src\*.csproj;
+                          $(RepoRoot)src\SiteExtensions\**\src\*.csproj;
+                          $(RepoRoot)src\Tools\**\src\*.csproj;
+                          $(RepoRoot)src\Middleware\**\src\*.csproj;
+                          $(RepoRoot)src\Razor\**\src\*.csproj;
+                          $(RepoRoot)src\Mvc\**\src\*.csproj;
+                          $(RepoRoot)src\Azure\**\src\*.csproj;
+                          $(RepoRoot)src\SignalR\**\src\*.csproj;
+                          $(RepoRoot)src\Components\**\src\*.csproj;
+                          "
+                        Exclude="
+                          @(ProjectToBuild);
+                          @(ProjectToExclude);
+                          $(RepoRoot)**\node_modules\**\*;
+                          $(RepoRoot)**\bin\**\*;
+                          $(RepoRoot)**\obj\**\*;"
+                        Condition=" '$(BuildMainlyReferenceProviders)' == 'true' " />
+
+        <ProjectToBuild Condition=" '$(BuildManaged)' == 'true'" Include="@(DotNetProjects)" Exclude="@(ProjectToExclude)" />
+        <ProjectToExclude Condition=" '$(BuildManaged)' != 'true'" Include="@(DotNetProjects)" />
+      </ItemGroup>
+    </Otherwise>
+  </Choose>
+</Project>
--- a/eng/CodeGen.proj
+++ b/eng/CodeGen.proj
@ -0,0 +1,88 @@
+<Project>
+
+  <PropertyGroup>
+    <BuildManaged>true</BuildManaged>
+    <RepoRoot>$([MSBuild]::NormalizeDirectory('$(MSBuildThisFileDirectory)', '..'))</RepoRoot>
+    <BuildMainlyReferenceProviders>true</BuildMainlyReferenceProviders>
+  </PropertyGroup>
+
+  <Import Project="Build.props" />
+
+  <Target Name="GenerateProjectList">
+    <Message Importance="High" Text="Analyzing @(ProjectToBuild->Count()) projects" />
+
+    <MSBuild Projects="@(ProjectToBuild)"
+             Targets="GetReferencesProvided"
+             BuildInParallel="true"
+             SkipNonexistentTargets="true"
+             SkipNonexistentProjects="true" >
+      <Output TaskParameter="TargetOutputs" ItemName="_ProjectReferenceProvider"/>
+    </MSBuild>
+
+    <ItemGroup>
+      <_SharedFrameworkAndPackageRef Include="@(_ProjectReferenceProvider->WithMetadataValue('IsAspNetCoreApp','true')->WithMetadataValue('IsPackable', 'true')->Distinct())" />
+      <_SharedFrameworkRef Include="@(_ProjectReferenceProvider->WithMetadataValue('IsAspNetCoreApp','true')->WithMetadataValue('IsPackable', 'false')->Distinct())" />
+      <_ProjectReferenceProviderWithRefAssembly Include="@(_ProjectReferenceProvider->HasMetadata('ReferenceAssemblyProjectFileRelativePath'))" />
+      <_ProjectReferenceProvider Remove="@(_ProjectReferenceProviderWithRefAssembly)" />
+    </ItemGroup>
+
+    <PropertyGroup>
+      <ProjectListFile>$(MSBuildThisFileDirectory)ProjectReferences.props</ProjectListFile>
+      <ProjectListContent><![CDATA[<!--
+  This file is automatically generated. Run `./eng/scripts/GenerateProjectList.ps1` to update.
+
+  This file contains a map of assembly names to the projects that build them.
+-->
+<Project>
+  <ItemGroup>
+    @(_ProjectReferenceProvider->'<ProjectReferenceProvider Include="%(Identity)" ProjectPath="%24(RepoRoot)%(ProjectFileRelativePath)"  />', '%0A    ')
+    @(_ProjectReferenceProviderWithRefAssembly->'<ProjectReferenceProvider Include="%(Identity)" ProjectPath="%24(RepoRoot)%(ProjectFileRelativePath)" RefProjectPath="%24(RepoRoot)%(ReferenceAssemblyProjectFileRelativePath)" />', '%0A    ')
+  </ItemGroup>
+</Project>
+]]></ProjectListContent>
+    </PropertyGroup>
+
+    <!-- Workaround https://github.com/Microsoft/msbuild/issues/1024 -->
+    <WriteLinesToFile Condition="'$(OS)' == 'Windows_NT'"
+                      File="$(ProjectListFile)" Lines="$([MSBuild]::Escape($(ProjectListContent)))" Overwrite="true" />
+    <Exec Condition="'$(OS)' != 'Windows_NT'"
+          Command="echo '$(ProjectListContent.Replace('\t','\\t'))' > $(ProjectListFile)" />
+    <Message Importance="High" Text="Generated $(ProjectListFile)" />
+
+    <PropertyGroup>
+      <SharedFxDepList>$(MSBuildThisFileDirectory)SharedFramework.Local.props</SharedFxDepList>
+      <SharedFxDepListContent>
+      <![CDATA[
+<!--
+  This file is automatically generated. Run `./eng/scripts/GenerateProjectList.ps1` to update.
+
+  This file contains a complete list of the assemblies which are part of the shared framework.
+
+  This project is generated using the <IsAspNetCoreApp> and <IsPackable> properties from each .csproj in this repository.
+-->
+<Project>
+  <ItemGroup>
+    <!-- These assemblies are available as both a NuGet package and in the shared framework -->
+    @(_SharedFrameworkAndPackageRef->'<AspNetCoreAppReferenceAndPackage Include="%(Identity)" />', '%0A    ')
+
+    <!-- These assemblies are only in the shared framework -->
+    @(_SharedFrameworkRef->'<AspNetCoreAppReference Include="%(Identity)" />', '%0A    ')
+  </ItemGroup>
+</Project>
+      ]]>
+      </SharedFxDepListContent>
+    </PropertyGroup>
+
+    <WriteLinesToFile File="$(SharedFxDepList)" Lines="$(SharedFxDepListContent)" Overwrite="true" />
+    <Message Importance="High" Text="Generated $(SharedFxDepList)" />
+  </Target>
+
+  <Target Name="GenerateReferenceSources">
+      <MSBuild
+          Projects="@(ProjectToBuild)"
+          Targets="GenerateReferenceSource"
+          SkipNonexistentTargets="true"
+          SkipNonexistentProjects="true" />
+  </Target>
+
+</Project>
--- a/eng/Dependencies.props
+++ b/eng/Dependencies.props
@ -19,107 +19,185 @@ and are generated based on the last package release.
    </LatestPackageReference>
  </ItemDefinitionGroup>

-  <!-- This import is temporary and necessary while we work on https://github.com/aspnet/AspNetCore/issues/4246. -->
-  <Import Project="dependencies.temp.props" />
-
-  <!-- These dependencies must use version variables because they may be overriden by ProdCon builds. -->
-  <ItemGroup Label="ProdCon dependencies">
-    <LatestPackageReference Include="Microsoft.AspNetCore.BenchmarkRunner.Sources" Version="$(MicrosoftAspNetCoreBenchmarkRunnerSourcesPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.AspNetCore.Testing" Version="$(MicrosoftAspNetCoreTestingPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.Build.Framework" Version="$(MicrosoftBuildFrameworkPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.Build.Tasks.Core" Version="$(MicrosoftBuildTasksCorePackageVersion)" />
-    <LatestPackageReference Include="Microsoft.Build.Utilities.Core" Version="$(MicrosoftBuildUtilitiesCorePackageVersion)" />
+  <ItemGroup Label=".NET team dependencies">
+    <LatestPackageReference Include="Microsoft.AspNetCore.Mvc.Razor.Extensions" Version="$(MicrosoftAspNetCoreMvcRazorExtensionsPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.AspNetCore.Razor.Language" Version="$(MicrosoftAspNetCoreRazorLanguagePackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesPackageVersion)" />
    <LatestPackageReference Include="Microsoft.CodeAnalysis.Common" Version="$(MicrosoftCodeAnalysisCommonPackageVersion)" />
    <LatestPackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="$(MicrosoftCodeAnalysisCSharpWorkspacesPackageVersion)" />
    <LatestPackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="$(MicrosoftCodeAnalysisCSharpPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.CodeAnalysis.Razor" Version="$(MicrosoftCodeAnalysisRazorPackageVersion)" />
    <LatestPackageReference Include="Microsoft.CSharp" Version="$(MicrosoftCSharpPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="$(MicrosoftEntityFrameworkCoreInMemoryPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="$(MicrosoftEntityFrameworkCoreSqlitePackageVersion)" />
-    <LatestPackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="$(MicrosoftEntityFrameworkCoreSqlServerPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="$(MicrosoftEntityFrameworkCoreToolsPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.DotNet.GenAPI" Version="$(MicrosoftDotNetGenApiPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="$(MicrosoftDotNetPlatformAbstractionsPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.ActivatorUtilities.Sources" Version="$(MicrosoftExtensionsActivatorUtilitiesSourcesPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="$(MicrosoftExtensionsCachingAbstractionsPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Caching.Memory" Version="$(MicrosoftExtensionsCachingMemoryPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.Extensions.Caching.Redis" Version="$(MicrosoftExtensionsCachingRedisPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.Extensions.Caching.SqlServer" Version="$(MicrosoftExtensionsCachingSqlServerPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.CommandLineUtils.Sources" Version="$(MicrosoftExtensionsCommandLineUtilsSourcesPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="$(MicrosoftExtensionsConfigurationAbstractionsPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="$(MicrosoftExtensionsConfigurationBinderPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="$(MicrosoftExtensionsConfigurationCommandLinePackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="$(MicrosoftExtensionsConfigurationEnvironmentVariablesPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="$(MicrosoftExtensionsConfigurationEnvironmentVariablesPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="$(MicrosoftExtensionsConfigurationFileExtensionsPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Configuration.Ini" Version="$(MicrosoftExtensionsConfigurationIniPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Configuration.Json" Version="$(MicrosoftExtensionsConfigurationJsonPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Configuration.KeyPerFile" Version="$(MicrosoftExtensionsConfigurationKeyPerFilePackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" Version="$(MicrosoftExtensionsConfigurationUserSecretsPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Configuration.Xml" Version="$(MicrosoftExtensionsConfigurationXmlPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Configuration" Version="$(MicrosoftExtensionsConfigurationPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="$(MicrosoftExtensionsDependencyInjectionAbstractionsPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.DependencyInjection" Version="$(MicrosoftExtensionsDependencyInjectionPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.DependencyModel" Version="$(MicrosoftExtensionsDependencyModelPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.DiagnosticAdapter" Version="$(MicrosoftExtensionsDiagnosticAdapterPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions" Version="$(MicrosoftExtensionsDiagnosticsHealthChecksAbstractionsPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="$(MicrosoftExtensionsDiagnosticsHealthChecksPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.FileProviders.Abstractions" Version="$(MicrosoftExtensionsFileProvidersAbstractionsPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.FileProviders.Composite" Version="$(MicrosoftExtensionsFileProvidersCompositePackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.FileProviders.Embedded" Version="$(MicrosoftExtensionsFileProvidersEmbeddedPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.FileProviders.Physical" Version="$(MicrosoftExtensionsFileProvidersPhysicalPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.FileSystemGlobbing" Version="$(MicrosoftExtensionsFileSystemGlobbingPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.HashCodeCombiner.Sources" Version="$(MicrosoftExtensionsHashCodeCombinerSourcesPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.HostFactoryResolver.Sources" Version="$(MicrosoftExtensionsHostFactoryResolverSourcesPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="$(MicrosoftExtensionsHostingAbstractionsPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Hosting" Version="$(MicrosoftExtensionsHostingPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Http" Version="$(MicrosoftExtensionsHttpPackageVersion)"  />
    <LatestPackageReference Include="Microsoft.Extensions.Localization.Abstractions" Version="$(MicrosoftExtensionsLocalizationAbstractionsPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Localization" Version="$(MicrosoftExtensionsLocalizationPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="$(MicrosoftExtensionsLoggingAbstractionsPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Logging.Configuration" Version="$(MicrosoftExtensionsLoggingConfigurationPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Logging.Console" Version="$(MicrosoftExtensionsLoggingConsolePackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Logging.Debug" Version="$(MicrosoftExtensionsLoggingDebugPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.Extensions.Logging.Testing" Version="$(MicrosoftExtensionsLoggingTestingPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.Extensions.Logging.Debug" Version="$(MicrosoftExtensionsLoggingPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Logging.EventSource" Version="$(MicrosoftExtensionsLoggingEventSourcePackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Logging.EventLog" Version="$(MicrosoftExtensionsLoggingEventLogPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Logging.TraceSource" Version="$(MicrosoftExtensionsLoggingTraceSourcePackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Logging" Version="$(MicrosoftExtensionsLoggingPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.ObjectPool" Version="$(MicrosoftExtensionsObjectPoolPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="$(MicrosoftExtensionsOptionsConfigurationExtensionsPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Options.DataAnnotations" Version="$(MicrosoftExtensionsOptionsDataAnnotationsPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.Options" Version="$(MicrosoftExtensionsOptionsPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.ParameterDefaultValue.Sources" Version="$(MicrosoftExtensionsParameterDefaultValueSourcesPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Primitives" Version="$(MicrosoftExtensionsPrimitivesPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.TypeNameHelper.Sources" Version="$(MicrosoftExtensionsTypeNameHelperSourcesPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.ValueStopWatch.Sources" Version="$(MicrosoftExtensionsValueStopwatchSourcesPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Extensions.WebEncoders" Version="$(MicrosoftExtensionsWebEncodersPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.IdentityModel.Clients.ActiveDirectory" Version="$(MicrosoftIdentityModelClientsActiveDirectoryPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.Owin.Security.Cookies" Version="$(MicrosoftOwinSecurityCookiesPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.Owin.Testing" Version="$(MicrosoftOwinTestingPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.NETCore.Windows.ApiSets" Version="$(MicrosoftNETCoreWindowsApiSetsPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.JSInterop" Version="$(MicrosoftJSInteropPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Win32.Registry" Version="$(MicrosoftWin32RegistryPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Win32.SystemEvents" Version="$(MicrosoftWin32SystemEventsPackageVersion)" />
    <LatestPackageReference Include="System.Buffers" Version="$(SystemBuffersPackageVersion)" />
-    <LatestPackageReference Include="System.Data.SqlClient" Version="$(SystemDataSqlClientPackageVersion)" />
-    <LatestPackageReference Include="System.Diagnostics.DiagnosticSource" Version="$(SystemDiagnosticsDiagnosticSourcePackageVersion)" />
+    <LatestPackageReference Include="System.CodeDom" Version="$(SystemCodeDomPackageVersion)" />
+    <LatestPackageReference Include="System.CommandLine.Experimental" Version="$(SystemCommandlineExperimentalPackageVersion)" />
+    <LatestPackageReference Include="System.ComponentModel" Version="$(SystemComponentModelPackageVersion)" />
+    <LatestPackageReference Include="System.ComponentModel.Annotations" Version="$(SystemComponentModelAnnotationsPackageVersion)" />
+    <LatestPackageReference Include="System.Diagnostics.EventLog" Version="$(SystemDiagnosticsEventLogPackageVersion)" />
+    <LatestPackageReference Include="System.Drawing.Common" Version="$(SystemDrawingCommonPackageVersion)" />
    <LatestPackageReference Include="System.IO.Pipelines" Version="$(SystemIOPipelinesPackageVersion)" />
-    <LatestPackageReference Include="System.Memory" Version="$(SystemMemoryPackageVersion)" />
-    <LatestPackageReference Include="System.Net.WebSockets.WebSocketProtocol" Version="$(SystemNetWebSocketsWebSocketProtocolPackageVersion)" />
-    <LatestPackageReference Include="System.Net.Http.WinHttpHandler" Version="$(SystemNetHttpWinHttpHandlerPackageVersion)" />
-    <LatestPackageReference Include="System.Numerics.Vectors" Version="$(SystemNumericsVectorsPackageVersion)" />
+    <LatestPackageReference Include="System.Net.Http" Version="$(SystemNetHttpPackageVersion)" />
    <LatestPackageReference Include="System.Reflection.Metadata" Version="$(SystemReflectionMetadataPackageVersion)" />
    <LatestPackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="$(SystemRuntimeCompilerServicesUnsafePackageVersion)" />
    <LatestPackageReference Include="System.Security.Cryptography.Cng" Version="$(SystemSecurityCryptographyCngPackageVersion)" />
+    <LatestPackageReference Include="System.Security.Cryptography.Pkcs" Version="$(SystemSecurityCryptographyPkcsPackageVersion)" />
+    <LatestPackageReference Include="System.Security.Cryptography.Xml" Version="$(SystemSecurityCryptographyXmlPackageVersion)" />
+    <LatestPackageReference Include="System.Security.Permissions" Version="$(SystemSecurityPermissionsPackageVersion)" />
    <LatestPackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsPackageVersion)" />
+    <LatestPackageReference Include="System.Text.Json" Version="$(SystemTextJsonPackageVersion)" />
    <LatestPackageReference Include="System.Threading.Channels" Version="$(SystemThreadingChannelsPackageVersion)" />
-    <LatestPackageReference Include="System.Threading.Tasks.Extensions" Version="$(SystemThreadingTasksExtensionsPackageVersion)" />
-    <LatestPackageReference Include="System.Text.Encodings.Web" Version="$(SystemTextEncodingsWebPackageVersion)" />
+    <LatestPackageReference Include="System.Windows.Extensions" Version="$(SystemWindowsExtensionsPackageVersion)" />

+    <!-- Runtime packages required for crossgen -->
+    <LatestPackageReference Include="microsoft.netcore.app.runtime.win-x64" Version="$(MicrosoftNETCoreAppRuntimeVersion)" />
+    <LatestPackageReference Include="microsoft.netcore.app.runtime.win-x86" Version="$(MicrosoftNETCoreAppRuntimeVersion)" />
+    <LatestPackageReference Include="microsoft.netcore.app.runtime.win-arm" Version="$(MicrosoftNETCoreAppRuntimeVersion)" />
+    <LatestPackageReference Include="microsoft.netcore.app.runtime.win-arm64" Version="$(MicrosoftNETCoreAppRuntimeVersion)" />
+    <LatestPackageReference Include="microsoft.netcore.app.runtime.osx-x64" Version="$(MicrosoftNETCoreAppRuntimeVersion)" />
+    <LatestPackageReference Include="microsoft.netcore.app.runtime.linux-x64" Version="$(MicrosoftNETCoreAppRuntimeVersion)" />
+    <LatestPackageReference Include="microsoft.netcore.app.runtime.linux-arm" Version="$(MicrosoftNETCoreAppRuntimeVersion)" />
+    <LatestPackageReference Include="microsoft.netcore.app.runtime.linux-arm64" Version="$(MicrosoftNETCoreAppRuntimeVersion)" />
+    <LatestPackageReference Include="microsoft.netcore.app.runtime.linux-musl-x64" Version="$(MicrosoftNETCoreAppRuntimeVersion)" />
+    <LatestPackageReference Include="microsoft.netcore.app.runtime.linux-musl-arm64" Version="$(MicrosoftNETCoreAppRuntimeVersion)" />
  </ItemGroup>

-  <ItemGroup Label="External dependencies">
+  <ItemGroup Label=".NET team dependencies (Non-source-build)" Condition="'$(DotNetBuildFromSource)' != 'true'">
+    <LatestPackageReference Include="Microsoft.AspNet.WebApi.Client" Version="$(MicrosoftAspNetWebApiClientPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.AspNetCore.Analyzer.Testing" Version="$(MicrosoftAspNetCoreAnalyzerTestingPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.AspNetCore.AzureAppServices.SiteExtension.2.1" Version="$(MicrosoftAspNetCoreAzureAppServicesSiteExtension21PackageVersion)" />
+    <LatestPackageReference Include="Microsoft.AspNetCore.AzureAppServices.SiteExtension.2.2" Version="$(MicrosoftAspNetCoreAzureAppServicesSiteExtension22PackageVersion)" />
+    <LatestPackageReference Include="Microsoft.AspNetCore.BenchmarkRunner.Sources" Version="$(MicrosoftAspNetCoreBenchmarkRunnerSourcesPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.AspNetCore.Blazor.Mono" Version="$(MicrosoftAspNetCoreBlazorMonoPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.AspNetCore.Testing" Version="$(MicrosoftAspNetCoreTestingPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="$(MicrosoftEntityFrameworkCoreInMemoryPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="$(MicrosoftEntityFrameworkCoreRelationalPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="$(MicrosoftEntityFrameworkCoreSqlitePackageVersion)" />
+    <LatestPackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="$(MicrosoftEntityFrameworkCoreSqlServerPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="$(MicrosoftEntityFrameworkCoreToolsPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.EntityFrameworkCore" Version="$(MicrosoftEntityFrameworkCorePackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Caching.SqlServer" Version="$(MicrosoftExtensionsCachingSqlServerPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="$(MicrosoftExtensionsCachingStackExchangeRedisPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Logging.AzureAppServices" Version="$(MicrosoftExtensionsLoggingAzureAppServicesPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Extensions.Logging.Testing" Version="$(MicrosoftExtensionsLoggingTestingPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.IdentityModel.Clients.ActiveDirectory" Version="$(MicrosoftIdentityModelClientsActiveDirectoryPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.IdentityModel.Protocols.OpenIdConnect" Version="$(MicrosoftIdentityModelProtocolsOpenIdConnectPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.IdentityModel.Protocols.WsFederation" Version="$(MicrosoftIdentityModelProtocolsWsFederationPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Internal.AspNetCore.H2Spec.All" Version="$(MicrosoftInternalAspNetCoreH2SpecAllPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Internal.Extensions.Refs" Version="$(MicrosoftInternalExtensionsRefsPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.NETCore.Windows.ApiSets" Version="$(MicrosoftNETCoreWindowsApiSetsPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Owin.Security.Cookies" Version="$(MicrosoftOwinSecurityCookiesPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Owin.Testing" Version="$(MicrosoftOwinTestingPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Web.Administration" Version="$(MicrosoftWebAdministrationPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Web.Xdt" Version="$(MicrosoftWebXdtPackageVersion)" />
+    <LatestPackageReference Include="System.IdentityModel.Tokens.Jwt" Version="$(SystemIdentityModelTokensJwtPackageVersion)" />
+    <LatestPackageReference Include="System.Net.Http.WinHttpHandler" Version="$(SystemNetHttpWinHttpHandlerPackageVersion)" />
+    <LatestPackageReference Include="System.Net.WebSockets.WebSocketProtocol" Version="$(SystemNetWebSocketsWebSocketProtocolPackageVersion)" />
+    <LatestPackageReference Include="System.ServiceProcess.ServiceController" Version="$(SystemServiceProcessServiceControllerPackageVersion)" />
+    <LatestPackageReference Include="System.Threading.Tasks.Extensions" Version="$(SystemThreadingTasksExtensionsPackageVersion)" />
+  </ItemGroup>
+
+  <ItemGroup Label="MSBuild">
+    <LatestPackageReference Include="Microsoft.Build" Version="$(MicrosoftBuildPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Build.Framework" Version="$(MicrosoftBuildFrameworkPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Build.Locator" Version="$(MicrosoftBuildLocatorPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Build.Utilities.Core" Version="$(MicrosoftBuildUtilitiesCorePackageVersion)" />
+  </ItemGroup>
+
+  <ItemGroup Label="External dependencies available in source build" >
+    <LatestPackageReference Include="Newtonsoft.Json" Version="$(NewtonsoftJsonPackageVersion)" />
+  </ItemGroup>
+
+  <ItemGroup Label="External dependencies" Condition="'$(DotNetBuildFromSource)' != 'true'">
    <LatestPackageReference Include="AngleSharp" Version="$(AngleSharpPackageVersion)" />
    <LatestPackageReference Include="BenchmarkDotNet" Version="$(BenchmarkDotNetPackageVersion)" />
    <LatestPackageReference Include="FSharp.Core" Version="$(FSharpCorePackageVersion)" />
+    <LatestPackageReference Include="Google.ProtoBuf" Version="$(GoogleProtoBufPackageVersion)" />
+    <LatestPackageReference Include="IdentityServer4" Version="$(IdentityServer4PackageVersion)" />
+    <LatestPackageReference Include="IdentityServer4.AspNetIdentity" Version="$(IdentityServer4AspNetIdentityPackageVersion)" />
+    <LatestPackageReference Include="IdentityServer4.EntityFramework" Version="$(IdentityServer4EntityFrameworkPackageVersion)" />
+    <LatestPackageReference Include="IdentityServer4.EntityFramework.Storage" Version="$(IdentityServer4EntityFrameworkStoragePackageVersion)" />
+    <LatestPackageReference Include="IdentityServer4.Storage" Version="$(IdentityServer4StoragePackageVersion)" />
+    <LatestPackageReference Include="Libuv" Version="$(LibuvPackageVersion)" />
    <LatestPackageReference Include="MessagePack" Version="$(MessagePackPackageVersion)" />
-    <LatestPackageReference Include="Microsoft.NET.Test.Sdk" Version="$(MicrosoftNETTestSdkPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Azure.KeyVault" Version="$(MicrosoftAzureKeyVaultPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Azure.Storage.Blob" Version="$(MicrosoftAzureStorageBlobPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Data.OData" Version="$(MicrosoftDataODataPackageVersion)" />
    <LatestPackageReference Include="Microsoft.Data.Services.Client" Version="$(MicrosoftDataServicesClientPackageVersion)" />
+    <LatestPackageReference Include="Mono.Cecil" Version="$(MonoCecilPackageVersion)" />
+    <LatestPackageReference Include="Mono.WebAssembly.Interop" Version="$(MonoWebAssemblyInteropPackageVersion)" />
    <LatestPackageReference Include="Moq" Version="$(MoqPackageVersion)" />
-    <LatestPackageReference Include="Google.ProtoBuf" Version="$(GoogleProtoBufPackageVersion)" />
-    <!-- This version is required by MSBuild tasks or Visual Studio extensions. -->
-    <LatestPackageReference Include="Newtonsoft.Json" Version="9.0.1" Condition="'$(UseMSBuildJsonNet)' == 'true'" />
-    <!-- This version should be used by runtime packages -->
-    <LatestPackageReference Include="Newtonsoft.Json" Version="11.0.2" Condition="'$(UseMSBuildJsonNet)' != 'true'" />
+    <LatestPackageReference Include="Newtonsoft.Json.Bson" Version="$(NewtonsoftJsonBsonPackageVersion)" />
+    <LatestPackageReference Include="NSwag.ApiDescription.Client" Version="$(NSwagApiDescriptionClientPackageVersion)" />
+    <LatestPackageReference Include="Selenium.Support" Version="$(SeleniumSupportPackageVersion)" />
+    <LatestPackageReference Include="Selenium.WebDriver" Version="$(SeleniumWebDriverPackageVersion)" />
+    <LatestPackageReference Include="Selenium.WebDriver.ChromeDriver" Version="$(SeleniumWebDriverChromeDriverPackageVersion)" />
+    <LatestPackageReference Include="Selenium.WebDriver.MicrosoftDriver" Version="$(SeleniumWebDriverMicrosoftDriverPackageVersion)" />
    <LatestPackageReference Include="Serilog.Extensions.Logging" Version="$(SerilogExtensionsLoggingPackageVersion)" />
    <LatestPackageReference Include="Serilog.Sinks.File" Version="$(SerilogSinksFilePackageVersion)" />
-    <LatestPackageReference Include="StackExchange.Redis.StrongName" Version="$(StackExchangeRedisStrongNamePackageVersion)" />
+    <LatestPackageReference Include="StackExchange.Redis" Version="$(StackExchangeRedisPackageVersion)" />
    <LatestPackageReference Include="System.Reactive.Linq" Version="$(SystemReactiveLinqPackageVersion)" />
-    <LatestPackageReference Include="Utf8Json" Version="$(Utf8JsonPackageVersion)" />
    <LatestPackageReference Include="xunit.abstractions" Version="$(XunitAbstractionsPackageVersion)" />
    <LatestPackageReference Include="xunit.analyzers" Version="$(XunitAnalyzersPackageVersion)" />
    <LatestPackageReference Include="xunit.assert" Version="$(XunitAssertPackageVersion)" />
    <LatestPackageReference Include="xunit.extensibility.core" Version="$(XunitExtensibilityCorePackageVersion)" />
    <LatestPackageReference Include="xunit.extensibility.execution" Version="$(XunitExtensibilityExecutionPackageVersion)" />
-    <LatestPackageReference Include="xunit.runner.visualstudio" Version="$(XunitRunnerVisualStudioPackageVersion)" />
-    <LatestPackageReference Include="xunit" Version="$(XunitPackageVersion)" />
+    <LatestPackageReference Include="xunit.extensibility.execution" Version="$(XunitExtensibilityExecutionPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Data.SqlClient" Version="$(MicrosoftDataSqlClientPackageVersion)" />
  </ItemGroup>

 </Project>
--- a/eng/FlakyTests.AfterArcade.props
+++ b/eng/FlakyTests.AfterArcade.props
@ -0,0 +1,7 @@
+<Project>
+  <!-- Override where xUnit logs and results go if we're doing the flaky run -->
+  <PropertyGroup Condition="'$(RunFlakyTests)' == 'true'">
+    <ArtifactsLogDir>$(ArtifactsDir)log\$(Configuration)\Flaky\</ArtifactsLogDir>
+    <ArtifactsTestResultsDir>$(ArtifactsDir)TestResults\$(Configuration)\Flaky\</ArtifactsTestResultsDir>
+  </PropertyGroup>
+</Project>
--- a/Show More
+++ b/Show More