Merge branch 'master' into master

21 files changed, 307 insertions, 161 deletions

diff --git a/toolsrc/include/BinaryParagraph.h b/toolsrc/include/BinaryParagraph.h
index 1e12dd8a6..61e03343a 100644
--- a/toolsrc/include/BinaryParagraph.h
+++ b/toolsrc/include/BinaryParagraph.h
@@ -31,5 +31,11 @@ namespace vcpkg
         std::vector<std::string> depends;
     };
 
+    struct BinaryControlFile
+    {
+        BinaryParagraph core_paragraph;
+        std::vector<BinaryParagraph> features;
+    };
+
     void serialize(const BinaryParagraph& pgh, std::string& out_str);
 }
\ No newline at end of file
diff --git a/toolsrc/include/PackageSpec.h b/toolsrc/include/PackageSpec.h
index 15b5e5b9b..c5ce767f9 100644
--- a/toolsrc/include/PackageSpec.h
+++ b/toolsrc/include/PackageSpec.h
@@ -1,14 +1,22 @@
 #pragma once
+
 #include "PackageSpecParseResult.h"
-#include "SourceParagraph.h"
 #include "Triplet.h"
 #include "vcpkg_expected.h"
 
 namespace vcpkg
 {
+    struct ParsedSpecifier
+    {
+        std::string name;
+        std::vector<std::string> features;
+        std::string triplet;
+
+        static ExpectedT<ParsedSpecifier, PackageSpecParseResult> from_string(const std::string& input);
+    };
+
     struct PackageSpec
     {
-        static std::string to_string(const std::string& name, const Triplet& triplet);
         static ExpectedT<PackageSpec, PackageSpecParseResult> from_name_and_triplet(const std::string& name,
                                                                                     const Triplet& triplet);
 
@@ -25,15 +33,45 @@ namespace vcpkg
         Triplet m_triplet;
     };
 
+    struct FeatureSpec
+    {
+        FeatureSpec(const PackageSpec& spec, const std::string& feature) : m_spec(spec), m_feature(feature) {}
+
+        const std::string& name() const { return m_spec.name(); }
+        const std::string& feature() const { return m_feature; }
+        const Triplet& triplet() const { return m_spec.triplet(); }
+
+        const PackageSpec& spec() const { return m_spec; }
+
+        std::string to_string() const;
+
+        static std::vector<FeatureSpec> from_strings_and_triplet(const std::vector<std::string>& depends,
+                                                                 const Triplet& t);
+
+    private:
+        PackageSpec m_spec;
+        std::string m_feature;
+    };
+
     struct FullPackageSpec
     {
         PackageSpec package_spec;
         std::vector<std::string> features;
 
+        static std::vector<FeatureSpec> to_feature_specs(const std::vector<FullPackageSpec>& specs);
+
         static ExpectedT<FullPackageSpec, PackageSpecParseResult> from_string(const std::string& spec_as_string,
                                                                               const Triplet& default_triplet);
     };
 
+    struct Features
+    {
+        std::string name;
+        std::vector<std::string> features;
+
+        static ExpectedT<Features, PackageSpecParseResult> from_string(const std::string& input);
+    };
+
     bool operator==(const PackageSpec& left, const PackageSpec& right);
     bool operator!=(const PackageSpec& left, const PackageSpec& right);
 }
diff --git a/toolsrc/include/Paragraphs.h b/toolsrc/include/Paragraphs.h
index 60f509266..aae46f7da 100644
--- a/toolsrc/include/Paragraphs.h
+++ b/toolsrc/include/Paragraphs.h
@@ -20,7 +20,7 @@ namespace vcpkg::Paragraphs
 
     Parse::ParseExpected<SourceControlFile> try_load_port(const Files::Filesystem& fs, const fs::path& control_path);
 
-    Expected<BinaryParagraph> try_load_cached_package(const VcpkgPaths& paths, const PackageSpec& spec);
+    Expected<BinaryControlFile> try_load_cached_control_package(const VcpkgPaths& paths, const PackageSpec& spec);
 
     struct LoadResults
     {
diff --git a/toolsrc/include/SourceParagraph.h b/toolsrc/include/SourceParagraph.h
index 7ddf999cc..1357b3769 100644
--- a/toolsrc/include/SourceParagraph.h
+++ b/toolsrc/include/SourceParagraph.h
@@ -1,27 +1,32 @@
 #pragma once
 
+#include "PackageSpec.h"
 #include "Span.h"
 #include "vcpkg_Parse.h"
 #include "vcpkg_System.h"
 #include "vcpkg_expected.h"
 
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 namespace vcpkg
 {
-    extern bool g_feature_packages;
-
-    struct Triplet;
-
     struct Dependency
     {
-        std::string name;
+        Features depend;
         std::string qualifier;
+
+        std::string name() const;
+        static Dependency parse_dependency(std::string name, std::string qualifier);
     };
 
-    const std::string& to_string(const Dependency& dep);
+    std::vector<std::string> filter_dependencies(const std::vector<Dependency>& deps, const Triplet& t);
+    std::vector<FeatureSpec> filter_dependencies_to_specs(const std::vector<Dependency>& deps, const Triplet& t);
+
+    // zlib[uwp] becomes Dependency{"zlib", "uwp"}
+    std::vector<Dependency> expand_qualified_dependencies(const std::vector<std::string>& depends);
+
+    std::string to_string(const Dependency& dep);
 
     struct FeatureParagraph
     {
@@ -58,12 +63,6 @@ namespace vcpkg
         return print_error_message({&error_info_list, 1});
     }
 
-    std::vector<std::string> filter_dependencies(const std::vector<Dependency>& deps, const Triplet& t);
-
-    // zlib[uwp] becomes Dependency{"zlib", "uwp"}
-    std::vector<Dependency> expand_qualified_dependencies(const std::vector<std::string>& depends);
-    std::vector<std::string> parse_comma_list(const std::string& str);
-
     struct Supports
     {
         static ExpectedT<Supports, std::vector<std::string>> parse(const std::vector<std::string>& strs);
diff --git a/toolsrc/include/StatusParagraphs.h b/toolsrc/include/StatusParagraphs.h
index 2af177219..1a9ee6a03 100644
--- a/toolsrc/include/StatusParagraphs.h
+++ b/toolsrc/include/StatusParagraphs.h
@@ -17,6 +17,8 @@ namespace vcpkg
         const_iterator find(const PackageSpec& spec) const { return find(spec.name(), spec.triplet()); }
         const_iterator find(const std::string& name, const Triplet& triplet) const;
         iterator find(const std::string& name, const Triplet& triplet);
+        std::vector<std::unique_ptr<StatusParagraph>*> find_all(const std::string& name, const Triplet& triplet);
+        iterator find(const std::string& name, const Triplet& triplet, const std::string& feature);
 
         const_iterator find_installed(const PackageSpec& spec) const
         {
diff --git a/toolsrc/include/VcpkgPaths.h b/toolsrc/include/VcpkgPaths.h
index 95cd4bc28..d55c95fe1 100644
--- a/toolsrc/include/VcpkgPaths.h
+++ b/toolsrc/include/VcpkgPaths.h
@@ -8,11 +8,19 @@
 
 namespace vcpkg
 {
+    struct ToolsetArchOption
+    {
+        CWStringView name;
+        System::CPUArchitecture host_arch;
+        System::CPUArchitecture target_arch;
+    };
+
     struct Toolset
     {
         fs::path dumpbin;
         fs::path vcvarsall;
         CWStringView version;
+        std::vector<ToolsetArchOption> supported_architectures;
     };
 
     struct VcpkgPaths
@@ -21,6 +29,7 @@ namespace vcpkg
 
         fs::path package_dir(const PackageSpec& spec) const;
         fs::path port_dir(const PackageSpec& spec) const;
+        fs::path port_dir(const std::string& name) const;
         fs::path build_info_file_path(const PackageSpec& spec) const;
         fs::path listfile_path(const BinaryParagraph& pgh) const;
 
diff --git a/toolsrc/include/coff_file_reader.h b/toolsrc/include/coff_file_reader.h
index 09f6447c2..7287211a1 100644
--- a/toolsrc/include/coff_file_reader.h
+++ b/toolsrc/include/coff_file_reader.h
@@ -3,7 +3,7 @@
 #include "filesystem_fs.h"
 #include <vector>
 
-namespace vcpkg::COFFFileReader
+namespace vcpkg::CoffFileReader
 {
     struct DllInfo
     {
diff --git a/toolsrc/include/metrics.h b/toolsrc/include/metrics.h
index 1f5ae2f32..8eae426de 100644
--- a/toolsrc/include/metrics.h
+++ b/toolsrc/include/metrics.h
@@ -2,19 +2,27 @@
 
 #include <string>
 
+#include "vcpkg_Util.h"
+
 namespace vcpkg::Metrics
 {
-    void set_send_metrics(bool should_send_metrics);
-    void set_print_metrics(bool should_print_metrics);
-    void set_user_information(const std::string& user_id, const std::string& first_use_time);
-    void init_user_information(std::string& user_id, std::string& first_use_time);
+    struct Metrics : Util::ResourceBase
+    {
+        void set_send_metrics(bool should_send_metrics);
+        void set_print_metrics(bool should_print_metrics);
+        void set_user_information(const std::string& user_id, const std::string& first_use_time);
+        void init_user_information(std::string& user_id, std::string& first_use_time);
 
-    void track_metric(const std::string& name, double value);
-    void track_property(const std::string& name, const std::string& value);
-    void track_property(const std::string& name, const std::wstring& value);
-    bool get_compiled_metrics_enabled();
-    std::wstring get_SQM_user();
+        void track_metric(const std::string& name, double value);
+        void track_property(const std::string& name, const std::string& value);
+        void track_property(const std::string& name, const std::wstring& value);
+
+        void upload(const std::string& payload);
+        void flush();
+    };
 
-    void upload(const std::string& payload);
-    void flush();
+    extern Util::LockGuarded<Metrics> g_metrics;
+
+    std::wstring get_SQM_user();
+    bool get_compiled_metrics_enabled();
 }
diff --git a/toolsrc/include/pch.h b/toolsrc/include/pch.h
index 406d0741e..770bcf07a 100644
--- a/toolsrc/include/pch.h
+++ b/toolsrc/include/pch.h
@@ -7,6 +7,7 @@
 
 #include <algorithm>
 #include <array>
+#include <atomic>
 #include <cassert>
 #include <cctype>
 #include <chrono>
@@ -22,6 +23,7 @@
 #include <iterator>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <process.h>
 #include <regex>
 #include <set>
diff --git a/toolsrc/include/triplet.h b/toolsrc/include/triplet.h
index be3bcf5b3..46a52f8e6 100644
--- a/toolsrc/include/triplet.h
+++ b/toolsrc/include/triplet.h
@@ -9,7 +9,7 @@ namespace vcpkg
     struct Triplet
     {
     public:
-        constexpr Triplet() : m_instance(&default_instance) {}
+        constexpr Triplet() : m_instance(&DEFAULT_INSTANCE) {}
 
         static Triplet from_canonical_name(const std::string& triplet_as_string);
 
@@ -26,7 +26,7 @@ namespace vcpkg
         bool operator==(const Triplet& other) const;
 
     private:
-        static const TripletInstance default_instance;
+        static const TripletInstance DEFAULT_INSTANCE;
 
         constexpr Triplet(const TripletInstance* ptr) : m_instance(ptr) {}
 
diff --git a/toolsrc/include/vcpkg_Build.h b/toolsrc/include/vcpkg_Build.h
index c4f3e6746..78e89d4de 100644
--- a/toolsrc/include/vcpkg_Build.h
+++ b/toolsrc/include/vcpkg_Build.h
@@ -9,7 +9,6 @@
 
 #include <array>
 #include <map>
-#include <unordered_map>
 #include <vector>
 
 namespace vcpkg::Build
@@ -52,13 +51,15 @@ namespace vcpkg::Build
         SUCCEEDED,
         BUILD_FAILED,
         POST_BUILD_CHECKS_FAILED,
+        FILE_CONFLICTS,
         CASCADED_DUE_TO_MISSING_DEPENDENCIES
     };
 
-    static constexpr std::array<BuildResult, 4> BuildResult_values = {
+    static constexpr std::array<BuildResult, 5> BUILD_RESULT_VALUES = {
         BuildResult::SUCCEEDED,
         BuildResult::BUILD_FAILED,
         BuildResult::POST_BUILD_CHECKS_FAILED,
+        BuildResult::FILE_CONFLICTS,
         BuildResult::CASCADED_DUE_TO_MISSING_DEPENDENCIES};
 
     const std::string& to_string(const BuildResult build_result);
@@ -141,7 +142,7 @@ namespace vcpkg::Build
         COUNT,
     };
 
-    constexpr std::array<BuildPolicy, size_t(BuildPolicy::COUNT)> g_all_policies = {
+    constexpr std::array<BuildPolicy, size_t(BuildPolicy::COUNT)> G_ALL_POLICIES = {
         BuildPolicy::EMPTY_PACKAGE,
         BuildPolicy::DLLS_WITHOUT_LIBS,
         BuildPolicy::ONLY_RELEASE_CRT,
@@ -157,9 +158,9 @@ namespace vcpkg::Build
         BuildPolicies() = default;
         BuildPolicies(std::map<BuildPolicy, bool>&& map) : m_policies(std::move(map)) {}
 
-        inline bool is_enabled(BuildPolicy policy) const
+        bool is_enabled(BuildPolicy policy) const
         {
-            auto it = m_policies.find(policy);
+            const auto it = m_policies.find(policy);
             if (it != m_policies.cend()) return it->second;
             return false;
         }
diff --git a/toolsrc/include/vcpkg_Checks.h b/toolsrc/include/vcpkg_Checks.h
index 6d8ff5711..ce486ac19 100644
--- a/toolsrc/include/vcpkg_Checks.h
+++ b/toolsrc/include/vcpkg_Checks.h
@@ -5,41 +5,50 @@
 
 namespace vcpkg::Checks
 {
+    void register_console_ctrl_handler();
+
+    // Indicate that an internal error has occurred and exit the tool. This should be used when invariants have been
+    // broken.
     [[noreturn]] void unreachable(const LineInfo& line_info);
 
     [[noreturn]] void exit_with_code(const LineInfo& line_info, const int exit_code);
 
+    // Exit the tool without an error message.
     [[noreturn]] inline void exit_fail(const LineInfo& line_info) { exit_with_code(line_info, EXIT_FAILURE); }
 
+    // Exit the tool successfully.
     [[noreturn]] inline void exit_success(const LineInfo& line_info) { exit_with_code(line_info, EXIT_SUCCESS); }
 
-    // Part of the reason these exist is to not include extra headers in this one to avoid circular #includes.
-    [[noreturn]] void exit_with_message(const LineInfo& line_info, const CStringView errorMessage);
+    // Display an error message to the user and exit the tool.
+    [[noreturn]] void exit_with_message(const LineInfo& line_info, const CStringView error_message);
 
     template<class Arg1, class... Args>
+    // Display an error message to the user and exit the tool.
     [[noreturn]] void exit_with_message(const LineInfo& line_info,
-                                        const char* errorMessageTemplate,
-                                        const Arg1 errorMessageArg1,
-                                        const Args&... errorMessageArgs)
+                                        const char* error_message_template,
+                                        const Arg1 error_message_arg1,
+                                        const Args&... error_message_args)
     {
-        exit_with_message(line_info, Strings::format(errorMessageTemplate, errorMessageArg1, errorMessageArgs...));
+        exit_with_message(line_info,
+                          Strings::format(error_message_template, error_message_arg1, error_message_args...));
     }
 
     void check_exit(const LineInfo& line_info, bool expression);
 
-    void check_exit(const LineInfo& line_info, bool expression, const CStringView errorMessage);
+    void check_exit(const LineInfo& line_info, bool expression, const CStringView error_message);
 
     template<class Conditional, class Arg1, class... Args>
     void check_exit(const LineInfo& line_info,
                     Conditional&& expression,
-                    const char* errorMessageTemplate,
-                    const Arg1 errorMessageArg1,
-                    const Args&... errorMessageArgs)
+                    const char* error_message_template,
+                    const Arg1 error_message_arg1,
+                    const Args&... error_message_args)
     {
         if (!expression)
         {
             // Only create the string if the expression is false
-            exit_with_message(line_info, Strings::format(errorMessageTemplate, errorMessageArg1, errorMessageArgs...));
+            exit_with_message(line_info,
+                              Strings::format(error_message_template, error_message_arg1, error_message_args...));
         }
     }
 }
diff --git a/toolsrc/include/vcpkg_Commands.h b/toolsrc/include/vcpkg_Commands.h
index 8348a64e4..590f0208c 100644
--- a/toolsrc/include/vcpkg_Commands.h
+++ b/toolsrc/include/vcpkg_Commands.h
@@ -33,6 +33,22 @@ namespace vcpkg::Commands
 
     namespace Install
     {
+        enum class KeepGoing
+        {
+            NO = 0,
+            YES
+        };
+
+        inline KeepGoing to_keep_going(const bool value) { return value ? KeepGoing::YES : KeepGoing::NO; }
+
+        enum class PrintSummary
+        {
+            NO = 0,
+            YES
+        };
+
+        inline PrintSummary to_print_summary(const bool value) { return value ? PrintSummary::YES : PrintSummary::NO; }
+
         struct InstallDir
         {
             static InstallDir from_destination_root(const fs::path& destination_root,
@@ -55,12 +71,26 @@ namespace vcpkg::Commands
                                                        const Build::BuildPackageOptions& install_plan_options,
                                                        StatusParagraphs& status_db);
 
+        enum class InstallResult
+        {
+            FILE_CONFLICTS,
+            SUCCESS,
+        };
+
         void install_files_and_write_listfile(Files::Filesystem& fs,
                                               const fs::path& source_dir,
                                               const InstallDir& dirs);
-        void install_package(const VcpkgPaths& paths,
-                             const BinaryParagraph& binary_paragraph,
-                             StatusParagraphs* status_db);
+        InstallResult install_package(const VcpkgPaths& paths,
+                                      const BinaryControlFile& binary_paragraph,
+                                      StatusParagraphs* status_db);
+
+        void perform_and_exit(const std::vector<Dependencies::AnyAction>& action_plan,
+                              const Build::BuildPackageOptions& install_plan_options,
+                              const KeepGoing keep_going,
+                              const PrintSummary print_summary,
+                              const VcpkgPaths& paths,
+                              StatusParagraphs& status_db);
+
         void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
     }
 
@@ -76,6 +106,19 @@ namespace vcpkg::Commands
 
     namespace Remove
     {
+        enum class Purge
+        {
+            NO = 0,
+            YES
+        };
+
+        inline Purge to_purge(const bool value) { return value ? Purge::YES : Purge::NO; }
+
+        void perform_remove_plan_action(const VcpkgPaths& paths,
+                                        const Dependencies::RemovePlanAction& action,
+                                        const Purge purge,
+                                        StatusParagraphs& status_db);
+
         void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
         void remove_package(const VcpkgPaths& paths, const PackageSpec& spec, StatusParagraphs* status_db);
     }
@@ -167,6 +210,7 @@ namespace vcpkg::Commands
     namespace Version
     {
         const std::string& version();
+        void warn_if_vcpkg_version_mismatch(const VcpkgPaths& paths);
         void perform_and_exit(const VcpkgCmdArguments& args);
     }
 
diff --git a/toolsrc/include/vcpkg_Dependencies.h b/toolsrc/include/vcpkg_Dependencies.h
index e3af0fd28..d67122e48 100644
--- a/toolsrc/include/vcpkg_Dependencies.h
+++ b/toolsrc/include/vcpkg_Dependencies.h
@@ -3,6 +3,7 @@
 #include "StatusParagraphs.h"
 #include "VcpkgPaths.h"
 #include "vcpkg_Graphs.h"
+#include "vcpkg_Util.h"
 #include "vcpkg_optional.h"
 #include <vector>
 
@@ -22,7 +23,7 @@ namespace vcpkg::Dependencies
         std::vector<PackageSpec> dependencies(const Triplet& triplet) const;
 
         Optional<StatusParagraph> status_paragraph;
-        Optional<BinaryParagraph> binary_paragraph;
+        Optional<BinaryControlFile> binary_control_file;
         Optional<SourceParagraph> source_paragraph;
         Optional<const SourceControlFile*> source_control_file;
     };
@@ -30,44 +31,6 @@ namespace vcpkg::Dependencies
 
 namespace vcpkg::Dependencies
 {
-    struct FeatureSpec
-    {
-        PackageSpec spec;
-        std::string feature_name;
-    };
-
-    struct FeatureNodeEdges
-    {
-        std::vector<FeatureSpec> remove_edges;
-        std::vector<FeatureSpec> build_edges;
-        bool plus = false;
-    };
-    std::vector<FeatureSpec> to_feature_specs(const std::vector<std::string>& depends, const Triplet& t);
-
-    struct Cluster
-    {
-        std::vector<StatusParagraph> status_paragraphs;
-        Optional<const SourceControlFile*> source_control_file;
-        PackageSpec spec;
-        std::unordered_map<std::string, FeatureNodeEdges> edges;
-        std::unordered_set<std::string> to_install_features;
-        std::unordered_set<std::string> original_features;
-        bool will_remove = false;
-        bool transient_uninstalled = true;
-        Cluster() = default;
-
-    private:
-        Cluster(const Cluster&) = delete;
-        Cluster& operator=(const Cluster&) = delete;
-    };
-
-    struct ClusterPtr
-    {
-        Cluster* ptr;
-    };
-
-    bool operator==(const ClusterPtr& l, const ClusterPtr& r);
-
     enum class InstallPlanType
     {
         UNKNOWN,
@@ -76,20 +39,22 @@ namespace vcpkg::Dependencies
         ALREADY_INSTALLED
     };
 
-    struct InstallPlanAction
+    struct InstallPlanAction : Util::MoveOnlyBase
     {
         static bool compare_by_name(const InstallPlanAction* left, const InstallPlanAction* right);
 
         InstallPlanAction();
+
+        InstallPlanAction(const PackageSpec& spec,
+                          const std::unordered_set<std::string>& features,
+                          const RequestType& request_type);
         InstallPlanAction(const PackageSpec& spec, const AnyParagraph& any_paragraph, const RequestType& request_type);
         InstallPlanAction(const PackageSpec& spec,
                           const SourceControlFile& any_paragraph,
                           const std::unordered_set<std::string>& features,
                           const RequestType& request_type);
-        InstallPlanAction(const InstallPlanAction&) = delete;
-        InstallPlanAction(InstallPlanAction&&) = default;
-        InstallPlanAction& operator=(const InstallPlanAction&) = delete;
-        InstallPlanAction& operator=(InstallPlanAction&&) = default;
+
+        std::string displayname() const;
 
         PackageSpec spec;
         AnyParagraph any_paragraph;
@@ -105,16 +70,12 @@ namespace vcpkg::Dependencies
         REMOVE
     };
 
-    struct RemovePlanAction
+    struct RemovePlanAction : Util::MoveOnlyBase
     {
         static bool compare_by_name(const RemovePlanAction* left, const RemovePlanAction* right);
 
         RemovePlanAction();
         RemovePlanAction(const PackageSpec& spec, const RemovePlanType& plan_type, const RequestType& request_type);
-        RemovePlanAction(const RemovePlanAction&) = delete;
-        RemovePlanAction(RemovePlanAction&&) = default;
-        RemovePlanAction& operator=(const RemovePlanAction&) = delete;
-        RemovePlanAction& operator=(RemovePlanAction&&) = default;
 
         PackageSpec spec;
         RemovePlanType plan_type;
@@ -123,8 +84,13 @@ namespace vcpkg::Dependencies
 
     struct AnyAction
     {
+        AnyAction(InstallPlanAction&& iplan) : install_plan(std::move(iplan)) {}
+        AnyAction(RemovePlanAction&& rplan) : remove_plan(std::move(rplan)) {}
+
         Optional<InstallPlanAction> install_plan;
         Optional<RemovePlanAction> remove_plan;
+
+        const PackageSpec& spec() const;
     };
 
     enum class ExportPlanType
@@ -134,16 +100,12 @@ namespace vcpkg::Dependencies
         ALREADY_BUILT
     };
 
-    struct ExportPlanAction
+    struct ExportPlanAction : Util::MoveOnlyBase
     {
         static bool compare_by_name(const ExportPlanAction* left, const ExportPlanAction* right);
 
         ExportPlanAction();
         ExportPlanAction(const PackageSpec& spec, const AnyParagraph& any_paragraph, const RequestType& request_type);
-        ExportPlanAction(const ExportPlanAction&) = delete;
-        ExportPlanAction(ExportPlanAction&&) = default;
-        ExportPlanAction& operator=(const ExportPlanAction&) = delete;
-        ExportPlanAction& operator=(ExportPlanAction&&) = default;
 
         PackageSpec spec;
         AnyParagraph any_paragraph;
@@ -151,25 +113,21 @@ namespace vcpkg::Dependencies
         RequestType request_type;
     };
 
-    __interface PortFileProvider { virtual const SourceControlFile& get_control_file(const PackageSpec& spec) const; };
+    __interface PortFileProvider { virtual const SourceControlFile& get_control_file(const std::string& spec) const; };
 
-    struct MapPortFile : PortFileProvider
+    struct MapPortFile : Util::ResourceBase, PortFileProvider
     {
-        const std::unordered_map<PackageSpec, SourceControlFile>& ports;
-        explicit MapPortFile(const std::unordered_map<PackageSpec, SourceControlFile>& map);
-        const SourceControlFile& get_control_file(const PackageSpec& spec) const override;
+        const std::unordered_map<std::string, SourceControlFile>& ports;
+        explicit MapPortFile(const std::unordered_map<std::string, SourceControlFile>& map);
+        const SourceControlFile& get_control_file(const std::string& spec) const override;
     };
 
-    struct PathsPortFile : PortFileProvider
+    struct PathsPortFile : Util::ResourceBase, PortFileProvider
     {
         const VcpkgPaths& ports;
-        mutable std::unordered_map<PackageSpec, SourceControlFile> cache;
+        mutable std::unordered_map<std::string, SourceControlFile> cache;
         explicit PathsPortFile(const VcpkgPaths& paths);
-        const SourceControlFile& get_control_file(const PackageSpec& spec) const override;
-
-    private:
-        PathsPortFile(const PathsPortFile&) = delete;
-        PathsPortFile& operator=(const PathsPortFile&) = delete;
+        const SourceControlFile& get_control_file(const std::string& spec) const override;
     };
 
     std::vector<InstallPlanAction> create_install_plan(const PortFileProvider& port_file_provider,
@@ -182,31 +140,8 @@ namespace vcpkg::Dependencies
     std::vector<ExportPlanAction> create_export_plan(const VcpkgPaths& paths,
                                                      const std::vector<PackageSpec>& specs,
                                                      const StatusParagraphs& status_db);
-}
-
-template<>
-struct std::hash<vcpkg::Dependencies::ClusterPtr>
-{
-    size_t operator()(const vcpkg::Dependencies::ClusterPtr& value) const
-    {
-        return std::hash<vcpkg::PackageSpec>()(value.ptr->spec);
-    }
-};
 
-namespace vcpkg::Dependencies
-{
-    struct GraphPlan
-    {
-        Graphs::Graph<ClusterPtr> remove_graph;
-        Graphs::Graph<ClusterPtr> install_graph;
-    };
-    bool mark_plus(const std::string& feature,
-                   Cluster& cluster,
-                   std::unordered_map<PackageSpec, Cluster>& pkg_to_cluster,
-                   GraphPlan& graph_plan);
-    void mark_minus(Cluster& cluster, std::unordered_map<PackageSpec, Cluster>& pkg_to_cluster, GraphPlan& graph_plan);
-
-    std::vector<AnyAction> create_feature_install_plan(const std::unordered_map<PackageSpec, SourceControlFile>& map,
-                                                       const std::vector<FullPackageSpec>& specs,
+    std::vector<AnyAction> create_feature_install_plan(const std::unordered_map<std::string, SourceControlFile>& map,
+                                                       const std::vector<FeatureSpec>& specs,
                                                        const StatusParagraphs& status_db);
 }
diff --git a/toolsrc/include/vcpkg_Files.h b/toolsrc/include/vcpkg_Files.h
index ad29ffa14..855e8ea45 100644
--- a/toolsrc/include/vcpkg_Files.h
+++ b/toolsrc/include/vcpkg_Files.h
@@ -38,4 +38,6 @@ namespace vcpkg::Files
     bool has_invalid_chars_for_filesystem(const std::string& s);
 
     void print_paths(const std::vector<fs::path>& paths);
+
+    std::vector<fs::path> find_from_PATH(const std::wstring& name);
 }
diff --git a/toolsrc/include/vcpkg_GlobalState.h b/toolsrc/include/vcpkg_GlobalState.h
new file mode 100644
index 000000000..6522a25bf
--- /dev/null
+++ b/toolsrc/include/vcpkg_GlobalState.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <atomic>
+
+#include "vcpkg_Chrono.h"
+#include "vcpkg_Util.h"
+
+namespace vcpkg
+{
+    struct GlobalState
+    {
+        static Util::LockGuarded<ElapsedTime> timer;
+        static std::atomic<bool> debugging;
+        static std::atomic<bool> feature_packages;
+
+        static std::atomic<int> g_init_console_cp;
+        static std::atomic<int> g_init_console_output_cp;
+    };
+}
\ No newline at end of file
diff --git a/toolsrc/include/vcpkg_Parse.h b/toolsrc/include/vcpkg_Parse.h
index a2eb152dc..2dda033b3 100644
--- a/toolsrc/include/vcpkg_Parse.h
+++ b/toolsrc/include/vcpkg_Parse.h
@@ -26,11 +26,13 @@ namespace vcpkg::Parse
         ParagraphParser(RawParagraph&& fields) : fields(std::move(fields)) {}
 
         void required_field(const std::string& fieldname, std::string& out);
-        std::string optional_field(const std::string& fieldname);
+        std::string optional_field(const std::string& fieldname) const;
         std::unique_ptr<ParseControlErrorInfo> error_info(const std::string& name) const;
 
     private:
         RawParagraph&& fields;
         std::vector<std::string> missing_fields;
     };
+
+    std::vector<std::string> parse_comma_list(const std::string& str);
 }
diff --git a/toolsrc/include/vcpkg_Strings.h b/toolsrc/include/vcpkg_Strings.h
index 325a2cb4c..61f6fab61 100644
--- a/toolsrc/include/vcpkg_Strings.h
+++ b/toolsrc/include/vcpkg_Strings.h
@@ -19,10 +19,12 @@ namespace vcpkg::Strings::details
 
     inline long long to_printf_arg(const long long s) { return s; }
 
-    inline double to_printf_arg(const double s) { return s; }
+    inline unsigned long to_printf_arg(const unsigned long s) { return s; }
 
     inline size_t to_printf_arg(const size_t s) { return s; }
 
+    inline double to_printf_arg(const double s) { return s; }
+
     std::string format_internal(const char* fmtstr, ...);
 
     inline const wchar_t* to_wprintf_arg(const std::wstring& s) { return s.c_str(); }
@@ -34,6 +36,9 @@ namespace vcpkg::Strings::details
 
 namespace vcpkg::Strings
 {
+    static constexpr const char* EMPTY = "";
+    static constexpr const wchar_t* WEMPTY = L"";
+
     template<class... Args>
     std::string format(const char* fmtstr, const Args&... args)
     {
@@ -63,20 +68,20 @@ namespace vcpkg::Strings
     template<class Container, class Transformer, class CharType>
     std::basic_string<CharType> join(const CharType* delimiter, const Container& v, Transformer transformer)
     {
-        if (v.size() == 0)
+        const auto begin = v.begin();
+        const auto end = v.end();
+
+        if (begin == end)
         {
             return std::basic_string<CharType>();
         }
 
         std::basic_string<CharType> output;
-        size_t size = v.size();
-
-        output.append(transformer(v[0]));
-
-        for (size_t i = 1; i < size; ++i)
+        output.append(transformer(*begin));
+        for (auto it = std::next(begin); it != end; ++it)
         {
             output.append(delimiter);
-            output.append(transformer(v[i]));
+            output.append(transformer(*it));
         }
 
         return output;
@@ -84,7 +89,7 @@ namespace vcpkg::Strings
     template<class Container, class CharType>
     std::basic_string<CharType> join(const CharType* delimiter, const Container& v)
     {
-        using Element = decltype(v[0]);
+        using Element = decltype(*v.begin());
         return join(delimiter, v, [](const Element& x) -> const Element& { return x; });
     }
 
diff --git a/toolsrc/include/vcpkg_System.h b/toolsrc/include/vcpkg_System.h
index 2ea0241f6..65f80ae6d 100644
--- a/toolsrc/include/vcpkg_System.h
+++ b/toolsrc/include/vcpkg_System.h
@@ -23,7 +23,7 @@ namespace vcpkg::System
 
     ExitCodeAndOutput cmd_execute_and_capture_output(const CWStringView cmd_line);
 
-    std::wstring create_powershell_script_cmd(const fs::path& script_path, const CWStringView args = L"");
+    std::wstring create_powershell_script_cmd(const fs::path& script_path, const CWStringView args = Strings::WEMPTY);
 
     enum class Color
     {
@@ -32,6 +32,7 @@ namespace vcpkg::System
         warning = 14,
     };
 
+    void println();
     void print(const CStringView message);
     void println(const CStringView message);
     void print(const Color c, const CStringView message);
@@ -77,9 +78,11 @@ namespace vcpkg::System
 
     CPUArchitecture get_host_processor();
 
-    const fs::path& get_ProgramFiles_32_bit();
+    std::vector<CPUArchitecture> get_supported_host_architectures();
 
-    const fs::path& get_ProgramFiles_platform_bitness();
+    const fs::path& get_program_files_32_bit();
+
+    const fs::path& get_program_files_platform_bitness();
 }
 
 namespace vcpkg::Debug
diff --git a/toolsrc/include/vcpkg_Util.h b/toolsrc/include/vcpkg_Util.h
index 671997e7e..c76ca01ac 100644
--- a/toolsrc/include/vcpkg_Util.h
+++ b/toolsrc/include/vcpkg_Util.h
@@ -1,20 +1,19 @@
 #pragma once
 
 #include <map>
+#include <mutex>
 #include <utility>
 #include <vector>
 
 namespace vcpkg::Util
 {
     template<class Cont, class Func>
-    using FmapOut = decltype(std::declval<Func>()(std::declval<Cont>()[0]));
+    using FmapOut = decltype(std::declval<Func>()(*begin(std::declval<Cont>())));
 
     template<class Cont, class Func, class Out = FmapOut<Cont, Func>>
-    std::vector<Out> fmap(const Cont& xs, Func&& f)
+    std::vector<Out> fmap(Cont&& xs, Func&& f)
     {
-        using O = decltype(f(xs[0]));
-
-        std::vector<O> ret;
+        std::vector<Out> ret;
         ret.reserve(xs.size());
 
         for (auto&& x : xs)
@@ -23,6 +22,21 @@ namespace vcpkg::Util
         return ret;
     }
 
+    template<class Cont, class Func>
+    using FmapFlattenOut = std::decay_t<decltype(*begin(std::declval<Func>()(*begin(std::declval<Cont>()))))>;
+
+    template<class Cont, class Func, class Out = FmapFlattenOut<Cont, Func>>
+    std::vector<Out> fmap_flatten(Cont&& xs, Func&& f)
+    {
+        std::vector<Out> ret;
+
+        for (auto&& x : xs)
+            for (auto&& y : f(x))
+                ret.push_back(std::move(y));
+
+        return ret;
+    }
+
     template<class Container, class Pred>
     void unstable_keep_if(Container& cont, Pred pred)
     {
@@ -62,4 +76,54 @@ namespace vcpkg::Util
             (*output)[key].push_back(&element);
         }
     }
+
+    struct MoveOnlyBase
+    {
+        MoveOnlyBase() = default;
+        MoveOnlyBase(const MoveOnlyBase&) = delete;
+        MoveOnlyBase(MoveOnlyBase&&) = default;
+
+        MoveOnlyBase& operator=(const MoveOnlyBase&) = delete;
+        MoveOnlyBase& operator=(MoveOnlyBase&&) = default;
+    };
+
+    struct ResourceBase
+    {
+        ResourceBase() = default;
+        ResourceBase(const ResourceBase&) = delete;
+        ResourceBase(ResourceBase&&) = delete;
+
+        ResourceBase& operator=(const ResourceBase&) = delete;
+        ResourceBase& operator=(ResourceBase&&) = delete;
+    };
+
+    template<class T>
+    struct LockGuardPtr;
+
+    template<class T>
+    struct LockGuarded
+    {
+        friend struct LockGuardPtr<T>;
+
+        LockGuardPtr<T> lock() { return *this; }
+
+    private:
+        std::mutex m_mutex;
+        T m_t;
+    };
+
+    template<class T>
+    struct LockGuardPtr
+    {
+        T& operator*() { return m_ptr; }
+        T* operator->() { return &m_ptr; }
+
+        T* get() { return &m_ptr; }
+
+        LockGuardPtr(LockGuarded<T>& sync) : m_lock(sync.m_mutex), m_ptr(sync.m_t) {}
+
+    private:
+        std::unique_lock<std::mutex> m_lock;
+        T& m_ptr;
+    };
 }
\ No newline at end of file
diff --git a/toolsrc/include/vcpkglib.h b/toolsrc/include/vcpkglib.h
index bd2400b77..0bb75f9b5 100644
--- a/toolsrc/include/vcpkglib.h
+++ b/toolsrc/include/vcpkglib.h
@@ -6,8 +6,6 @@
 
 namespace vcpkg
 {
-    extern bool g_debugging;
-
     StatusParagraphs database_load_check(const VcpkgPaths& paths);
 
     void write_update(const VcpkgPaths& paths, const StatusParagraph& p);
@@ -36,5 +34,5 @@ namespace vcpkg
                                 const fs::path& cmake_script,
                                 const std::vector<CMakeVariable>& pass_variables);
 
-    std::string shorten_description(const std::string& desc);
+    std::string shorten_text(const std::string& desc, size_t length);
 } // namespace vcpkg