diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe5ed046fe5..61f95911802 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 Note: This is in reverse chronological order, so newer entries are added to the top.
 
-Swift Next
+Swift 6.0
 -----------
 
 * [#7202]
@@ -8,11 +8,22 @@ Swift Next
   Package manifests can now access information about the Git repository the given package is in via the context object's 
   `gitInformation` property. This allows to determine the current tag (if any), the current commit and whether or not there are uncommited changes.
 
+* [#7201]
+
+  `// swift-tools-version:` can now be specified on subsequent lines of `Package.swift`, for example when first few lines are required to contain a licensing comment header.
+
+* [#7118]
+
+  Macros cross-compiled by SwiftPM with Swift SDKs are now correctly built, loaded, and evaluated for the host triple.
+
+Swift 5.10
+-----------
+
 * [#7010]
 
   On macOS, `swift build` and `swift run` now produce binaries that allow backtraces in debug builds. Pass `SWIFT_BACKTRACE=enable=yes` environment variable to enable backtraces on such binaries when running them.
 
-* [7101]
+* [#7101]
 
    Binary artifacts are now cached along side repository checkouts so they do not need to be re-downloaded across projects.
 
@@ -387,4 +398,8 @@ Swift 3.0
 [#6276]: https://github.com/apple/swift-package-manager/pull/6276
 [#6540]: https://github.com/apple/swift-package-manager/pull/6540
 [#6663]: https://github.com/apple/swift-package-manager/pull/6663
+[#7010]: https://github.com/apple/swift-package-manager/pull/7010
 [#7101]: https://github.com/apple/swift-package-manager/pull/7101
+[#7118]: https://github.com/apple/swift-package-manager/pull/7118
+[#7201]: https://github.com/apple/swift-package-manager/pull/7201
+[#7202]: https://github.com/apple/swift-package-manager/pull/7202
diff --git a/Sources/Basics/Collections/IdentifiableSet.swift b/Sources/Basics/Collections/IdentifiableSet.swift
index b3bfec3071f..59bda6bdd85 100644
--- a/Sources/Basics/Collections/IdentifiableSet.swift
+++ b/Sources/Basics/Collections/IdentifiableSet.swift
@@ -45,13 +45,22 @@ public struct IdentifiableSet<Element: Identifiable>: Collection {
     }
 
     public subscript(id: Element.ID) -> Element? {
-        self.storage[id]
+        get {
+            self.storage[id]
+        }
+        set {
+            self.storage[id] = newValue
+        }
     }
 
     public func index(after i: Index) -> Index {
         Index(storageIndex: self.storage.index(after: i.storageIndex))
     }
 
+    public mutating func insert(_ element: Element) {
+        self.storage[element.id] = element
+    }
+
     public func union(_ otherSequence: some Sequence<Element>) -> Self {
         var result = self
         for element in otherSequence {
diff --git a/Sources/Build/BuildDescription/ClangTargetBuildDescription.swift b/Sources/Build/BuildDescription/ClangTargetBuildDescription.swift
index 4c62450d3c3..a1e22c52d6e 100644
--- a/Sources/Build/BuildDescription/ClangTargetBuildDescription.swift
+++ b/Sources/Build/BuildDescription/ClangTargetBuildDescription.swift
@@ -53,7 +53,7 @@ package final class ClangTargetBuildDescription {
 
     /// Path to the bundle generated for this module (if any).
     var bundlePath: AbsolutePath? {
-        guard !resources.isEmpty else {
+        guard !self.resources.isEmpty else {
             return .none
         }
 
@@ -133,7 +133,7 @@ package final class ClangTargetBuildDescription {
         self.target = target
         self.toolsVersion = toolsVersion
         self.buildParameters = buildParameters
-        self.tempsPath = buildParameters.buildPath.appending(component: target.c99name + ".build")
+        self.tempsPath = target.tempsPath(buildParameters)
         self.derivedSources = Sources(paths: [], root: tempsPath.appending("DerivedSources"))
 
         // We did not use to apply package plugins to C-family targets in prior tools-versions, this preserves the behavior.
@@ -225,7 +225,7 @@ package final class ClangTargetBuildDescription {
         if self.buildParameters.triple.isDarwin() {
             args += ["-fobjc-arc"]
         }
-        args += try buildParameters.targetTripleArgs(for: target)
+        args += try self.buildParameters.tripleArgs(for: target)
 
         args += optimizationArguments
         args += activeCompilationConditions
diff --git a/Sources/Build/BuildDescription/ProductBuildDescription.swift b/Sources/Build/BuildDescription/ProductBuildDescription.swift
index 2c5538cbb3e..2277a6f638f 100644
--- a/Sources/Build/BuildDescription/ProductBuildDescription.swift
+++ b/Sources/Build/BuildDescription/ProductBuildDescription.swift
@@ -321,7 +321,7 @@ package final class ProductBuildDescription: SPMBuildCore.ProductBuildDescriptio
         // setting is the package-level right now. We might need to figure out a better
         // answer for libraries if/when we support specifying deployment target at the
         // target-level.
-        args += try self.buildParameters.targetTripleArgs(for: self.product.targets[self.product.targets.startIndex])
+        args += try self.buildParameters.tripleArgs(for: self.product.targets[self.product.targets.startIndex])
 
         // Add arguments from declared build settings.
         args += self.buildSettingsFlags
@@ -356,7 +356,7 @@ package final class ProductBuildDescription: SPMBuildCore.ProductBuildDescriptio
         // Library search path for the toolchain's copy of SwiftSyntax.
         #if BUILD_MACROS_AS_DYLIBS
         if product.type == .macro {
-            args += try ["-L", buildParameters.toolchain.hostLibDir.pathString]
+            args += try ["-L", defaultBuildParameters.toolchain.hostLibDir.pathString]
         }
         #endif
 
diff --git a/Sources/Build/BuildDescription/ResolvedModule+BuildDescription.swift b/Sources/Build/BuildDescription/ResolvedModule+BuildDescription.swift
new file mode 100644
index 00000000000..59e5e2abacd
--- /dev/null
+++ b/Sources/Build/BuildDescription/ResolvedModule+BuildDescription.swift
@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2015-2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import struct Basics.AbsolutePath
+import struct PackageGraph.ResolvedModule
+
+import SPMBuildCore
+
+extension ResolvedModule {
+    func tempsPath(_ buildParameters: BuildParameters) -> AbsolutePath {
+        let suffix = buildParameters.suffix(triple: self.buildTriple)
+        return buildParameters.buildPath.appending(component: "\(self.c99name)\(suffix).build")
+    }
+}
diff --git a/Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift b/Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift
index 1b5777bcb80..286e6307dbc 100644
--- a/Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift
+++ b/Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift
@@ -42,8 +42,11 @@ package final class SwiftTargetBuildDescription {
     /// a target is built.
     package let toolsVersion: ToolsVersion
 
-    /// The build parameters.
-    let buildParameters: BuildParameters
+    /// The build parameters for this target.
+    let defaultBuildParameters: BuildParameters
+
+    /// The build parameters for build tools.
+    let toolsBuildParameters: BuildParameters
 
     /// Path to the temporary directory for this target.
     let tempsPath: AbsolutePath
@@ -62,7 +65,7 @@ package final class SwiftTargetBuildDescription {
     /// Path to the bundle generated for this module (if any).
     var bundlePath: AbsolutePath? {
         if let bundleName = target.underlying.potentialBundleName, needsResourceBundle {
-            return self.buildParameters.bundlePath(named: bundleName)
+            return self.defaultBuildParameters.bundlePath(named: bundleName)
         } else {
             return .none
         }
@@ -97,7 +100,7 @@ package final class SwiftTargetBuildDescription {
             let relativeSources = self.target.sources.relativePaths
                 + self.derivedSources.relativePaths
                 + self.pluginDerivedSources.relativePaths
-            let ltoEnabled = self.buildParameters.linkingParameters.linkTimeOptimizationMode != nil
+            let ltoEnabled = self.defaultBuildParameters.linkingParameters.linkTimeOptimizationMode != nil
             let objectFileExtension = ltoEnabled ? "bc" : "o"
             return try relativeSources.map {
                 try AbsolutePath(
@@ -108,16 +111,17 @@ package final class SwiftTargetBuildDescription {
     }
 
     var modulesPath: AbsolutePath {
-        return self.buildParameters.buildPath.appending(component: "Modules")
+        let suffix = self.defaultBuildParameters.suffix(triple: self.target.buildTriple)
+        return self.defaultBuildParameters.buildPath.appending(component: "Modules\(suffix)")
     }
 
     /// The path to the swiftmodule file after compilation.
     public var moduleOutputPath: AbsolutePath { // note: needs to be `public` because of sourcekit-lsp
         // If we're an executable and we're not allowing test targets to link against us, we hide the module.
-        let triple = buildParameters.triple
+        let triple = defaultBuildParameters.triple
         let allowLinkingAgainstExecutables = (triple.isDarwin() || triple.isLinux() || triple.isWindows()) && self.toolsVersion >= .v5_5
         let dirPath = (target.type == .executable && !allowLinkingAgainstExecutables) ? self.tempsPath : self.modulesPath
-        return dirPath.appending(component: self.target.c99name + ".swiftmodule")
+        return dirPath.appending(component: "\(self.target.c99name).swiftmodule")
     }
 
     /// The path to the wrapped swift module which is created using the modulewrap tool. This is required
@@ -127,7 +131,7 @@ package final class SwiftTargetBuildDescription {
         self.tempsPath.appending(component: self.target.c99name + ".swiftmodule.o")
     }
 
-    /// The path to the swifinterface file after compilation.
+    /// The path to the swiftinterface file after compilation.
     var parseableModuleInterfaceOutputPath: AbsolutePath {
         self.modulesPath.appending(component: self.target.c99name + ".swiftinterface")
     }
@@ -243,7 +247,7 @@ package final class SwiftTargetBuildDescription {
     private let shouldGenerateTestObservation: Bool
 
     /// Whether to disable sandboxing (e.g. for macros).
-    private let disableSandbox: Bool
+    private let shouldDisableSandbox: Bool
 
     /// Create a new target description with target and build parameters.
     init(
@@ -251,13 +255,14 @@ package final class SwiftTargetBuildDescription {
         target: ResolvedModule,
         toolsVersion: ToolsVersion,
         additionalFileRules: [FileRuleDescription] = [],
-        buildParameters: BuildParameters,
+        destinationBuildParameters: BuildParameters,
+        toolsBuildParameters: BuildParameters,
         buildToolPluginInvocationResults: [BuildToolPluginInvocationResult] = [],
         prebuildCommandResults: [PrebuildCommandResult] = [],
         requiredMacroProducts: [ResolvedProduct] = [],
         testTargetRole: TestTargetRole? = nil,
         shouldGenerateTestObservation: Bool = false,
-        disableSandbox: Bool,
+        shouldDisableSandbox: Bool,
         fileSystem: FileSystem,
         observabilityScope: ObservabilityScope
     ) throws {
@@ -269,7 +274,9 @@ package final class SwiftTargetBuildDescription {
         self.package = package
         self.target = target
         self.toolsVersion = toolsVersion
-        self.buildParameters = buildParameters
+        self.defaultBuildParameters = destinationBuildParameters
+        self.toolsBuildParameters = toolsBuildParameters
+
         // Unless mentioned explicitly, use the target type to determine if this is a test target.
         if let testTargetRole {
             self.testTargetRole = testTargetRole
@@ -279,13 +286,13 @@ package final class SwiftTargetBuildDescription {
             self.testTargetRole = nil
         }
 
-        self.tempsPath = buildParameters.buildPath.appending(component: target.c99name + ".build")
+        self.tempsPath = target.tempsPath(destinationBuildParameters)
         self.derivedSources = Sources(paths: [], root: self.tempsPath.appending("DerivedSources"))
         self.buildToolPluginInvocationResults = buildToolPluginInvocationResults
         self.prebuildCommandResults = prebuildCommandResults
         self.requiredMacroProducts = requiredMacroProducts
         self.shouldGenerateTestObservation = shouldGenerateTestObservation
-        self.disableSandbox = disableSandbox
+        self.shouldDisableSandbox = shouldDisableSandbox
         self.fileSystem = fileSystem
         self.observabilityScope = observabilityScope
 
@@ -293,7 +300,7 @@ package final class SwiftTargetBuildDescription {
             target: target,
             toolsVersion: toolsVersion,
             additionalFileRules: additionalFileRules,
-            buildParameters: buildParameters,
+            buildParameters: destinationBuildParameters,
             buildToolPluginInvocationResults: buildToolPluginInvocationResults,
             prebuildCommandResults: prebuildCommandResults,
             observabilityScope: observabilityScope
@@ -330,18 +337,22 @@ package final class SwiftTargetBuildDescription {
             return
         }
 
-        guard self.buildParameters.triple.isDarwin(), self.buildParameters.testingParameters.experimentalTestOutput else {
+        guard 
+            self.defaultBuildParameters.triple.isDarwin() &&
+            self.defaultBuildParameters.testingParameters.experimentalTestOutput
+        else {
             return
         }
 
-        let content = generateTestObservationCode(buildParameters: self.buildParameters)
+        let content = generateTestObservationCode(buildParameters: self.defaultBuildParameters)
 
         // FIXME: We should generate this file during the actual build.
         self.derivedSources.relativePaths.append(subpath)
         try self.fileSystem.writeIfChanged(path: path, string: content)
     }
 
-    // FIXME: This will not work well for large files, as we will store the entire contents, plus its byte array representation in memory and also `writeIfChanged()` will read the entire generated file again.
+    // FIXME: This will not work well for large files, as we will store the entire contents, plus its byte array
+    // representation in memory and also `writeIfChanged()` will read the entire generated file again.
     private func generateResourceEmbeddingCode() throws {
         guard needsResourceEmbedding else { return }
 
@@ -374,7 +385,7 @@ package final class SwiftTargetBuildDescription {
         guard let bundlePath else { return }
 
         let mainPathSubstitution: String
-        if self.buildParameters.triple.isWASI() {
+        if self.defaultBuildParameters.triple.isWASI() {
             // We prefer compile-time evaluation of the bundle path here for WASI. There's no benefit in evaluating this
             // at runtime, especially as `Bundle` support in WASI Foundation is partial. We expect all resource paths to
             // evaluate to `/\(resourceBundleName)/\(resourcePath)`, which allows us to pass this path to JS APIs like
@@ -426,12 +437,12 @@ package final class SwiftTargetBuildDescription {
 
         #if BUILD_MACROS_AS_DYLIBS
         self.requiredMacroProducts.forEach { macro in
-            args += ["-Xfrontend", "-load-plugin-library", "-Xfrontend", self.buildParameters.binaryPath(for: macro).pathString]
+            args += ["-Xfrontend", "-load-plugin-library", "-Xfrontend", self.toolsBuildParameters.binaryPath(for: macro).pathString]
         }
         #else
         try self.requiredMacroProducts.forEach { macro in
             if let macroTarget = macro.targets.first {
-                let executablePath = try self.buildParameters.binaryPath(for: macro).pathString
+                let executablePath = try self.toolsBuildParameters.binaryPath(for: macro).pathString
                 args += ["-Xfrontend", "-load-plugin-executable", "-Xfrontend", "\(executablePath)#\(macroTarget.c99name)"]
             } else {
                 throw InternalError("macro product \(macro.name) has no targets") // earlier validation should normally catch this
@@ -440,13 +451,13 @@ package final class SwiftTargetBuildDescription {
         #endif
 
         // If we're using an OSS toolchain, add the required arguments bringing in the plugin server from the default toolchain if available.
-        if self.buildParameters.toolchain.isSwiftDevelopmentToolchain, 
+        if self.defaultBuildParameters.toolchain.isSwiftDevelopmentToolchain, 
             DriverSupport.checkSupportedFrontendFlags(
                 flags: ["-external-plugin-path"],
-                toolchain: self.buildParameters.toolchain,
+                toolchain: self.defaultBuildParameters.toolchain,
                 fileSystem: self.fileSystem
             ), 
-            let pluginServer = try self.buildParameters.toolchain.swiftPluginServerPath
+            let pluginServer = try self.defaultBuildParameters.toolchain.swiftPluginServerPath
         {
             let toolchainUsrPath = pluginServer.parentDirectory.parentDirectory
             let pluginPathComponents = ["lib", "swift", "host", "plugins"]
@@ -458,8 +469,12 @@ package final class SwiftTargetBuildDescription {
             args += ["-Xfrontend", "-external-plugin-path", "-Xfrontend", "\(localPluginPath)#\(pluginServer.pathString)"]
         }
 
-        if self.disableSandbox {
-            let toolchainSupportsDisablingSandbox = DriverSupport.checkSupportedFrontendFlags(flags: ["-disable-sandbox"], toolchain: self.buildParameters.toolchain, fileSystem: fileSystem)
+        if self.shouldDisableSandbox {
+            let toolchainSupportsDisablingSandbox = DriverSupport.checkSupportedFrontendFlags(
+                flags: ["-disable-sandbox"],
+                toolchain: self.defaultBuildParameters.toolchain,
+                fileSystem: fileSystem
+            )
             if toolchainSupportsDisablingSandbox {
                 args += ["-disable-sandbox"]
             } else {
@@ -476,10 +491,10 @@ package final class SwiftTargetBuildDescription {
     /// The arguments needed to compile this target.
     package func compileArguments() throws -> [String] {
         var args = [String]()
-        args += try self.buildParameters.targetTripleArgs(for: self.target)
+        args += try self.defaultBuildParameters.tripleArgs(for: self.target)
 
         // pass `-v` during verbose builds.
-        if self.buildParameters.outputParameters.isVerbose {
+        if self.defaultBuildParameters.outputParameters.isVerbose {
             args += ["-v"]
         }
 
@@ -487,22 +502,22 @@ package final class SwiftTargetBuildDescription {
         //
         // Technically, it should be enabled whenever WMO is off but we
         // don't currently make that distinction in SwiftPM
-        switch self.buildParameters.configuration {
+        switch self.defaultBuildParameters.configuration {
         case .debug:
             args += ["-enable-batch-mode"]
         case .release: break
         }
 
-        args += self.buildParameters.indexStoreArguments(for: self.target)
+        args += self.defaultBuildParameters.indexStoreArguments(for: self.target)
         args += self.optimizationArguments
         args += self.testingArguments
 
-        args += ["-j\(self.buildParameters.workers)"]
+        args += ["-j\(self.defaultBuildParameters.workers)"]
         args += self.activeCompilationConditions
         args += self.additionalFlags
         args += try self.moduleCacheArgs
         args += self.stdlibArguments
-        args += self.buildParameters.sanitizers.compileSwiftFlags()
+        args += self.defaultBuildParameters.sanitizers.compileSwiftFlags()
         args += ["-parseable-output"]
 
         // If we're compiling the main module of an executable other than the one that
@@ -522,8 +537,8 @@ package final class SwiftTargetBuildDescription {
             // we can rename the symbol unconditionally.
             // No `-` for these flags because the set of Strings in driver.supportedFrontendFlags do
             // not have a leading `-`
-            if self.buildParameters.driverParameters.canRenameEntrypointFunctionName,
-               self.buildParameters.linkerFlagsForRenamingMainFunction(of: self.target) != nil
+            if self.defaultBuildParameters.driverParameters.canRenameEntrypointFunctionName,
+               self.defaultBuildParameters.linkerFlagsForRenamingMainFunction(of: self.target) != nil
             {
                 args += ["-Xfrontend", "-entry-point-function-name", "-Xfrontend", "\(self.target.c99name)_main"]
             }
@@ -536,7 +551,7 @@ package final class SwiftTargetBuildDescription {
 
         // Only add the build path to the framework search path if there are binary frameworks to link against.
         if !self.libraryBinaryPaths.isEmpty {
-            args += ["-F", self.buildParameters.buildPath.pathString]
+            args += ["-F", self.defaultBuildParameters.buildPath.pathString]
         }
 
         // Emit the ObjC compatibility header if enabled.
@@ -545,12 +560,12 @@ package final class SwiftTargetBuildDescription {
         }
 
         // Add arguments needed for code coverage if it is enabled.
-        if self.buildParameters.testingParameters.enableCodeCoverage {
+        if self.defaultBuildParameters.testingParameters.enableCodeCoverage {
             args += ["-profile-coverage-mapping", "-profile-generate"]
         }
 
         // Add arguments to colorize output if stdout is tty
-        if self.buildParameters.outputParameters.isColorized {
+        if self.defaultBuildParameters.outputParameters.isColorized {
             args += ["-color-diagnostics"]
         }
 
@@ -560,7 +575,7 @@ package final class SwiftTargetBuildDescription {
         switch testTargetRole {
         case .discovery, .entryPoint:
             for dependency in try self.target.recursiveTargetDependencies() {
-                let dependencyScope = self.buildParameters.createScope(for: dependency)
+                let dependencyScope = self.defaultBuildParameters.createScope(for: dependency)
                 let dependencySwiftFlags = dependencyScope.evaluate(.OTHER_SWIFT_FLAGS)
                 if let interopModeFlag = dependencySwiftFlags.first(where: { $0.hasPrefix("-cxx-interoperability-mode=") }) {
                     args += [interopModeFlag]
@@ -585,17 +600,17 @@ package final class SwiftTargetBuildDescription {
 
         // Add the output for the `.swiftinterface`, if requested or if library evolution has been enabled some other
         // way.
-        if self.buildParameters.driverParameters.enableParseableModuleInterfaces || args.contains("-enable-library-evolution") {
+        if self.defaultBuildParameters.driverParameters.enableParseableModuleInterfaces || args.contains("-enable-library-evolution") {
             args += ["-emit-module-interface-path", self.parseableModuleInterfaceOutputPath.pathString]
         }
 
-        args += self.buildParameters.toolchain.extraFlags.swiftCompilerFlags
+        args += self.defaultBuildParameters.toolchain.extraFlags.swiftCompilerFlags
         // User arguments (from -Xswiftc) should follow generated arguments to allow user overrides
-        args += self.buildParameters.flags.swiftCompilerFlags
+        args += self.defaultBuildParameters.flags.swiftCompilerFlags
 
-        args += self.buildParameters.toolchain.extraFlags.cCompilerFlags.asSwiftcCCompilerFlags()
+        args += self.defaultBuildParameters.toolchain.extraFlags.cCompilerFlags.asSwiftcCCompilerFlags()
         // User arguments (from -Xcc) should follow generated arguments to allow user overrides
-        args += self.buildParameters.flags.cCompilerFlags.asSwiftcCCompilerFlags()
+        args += self.defaultBuildParameters.flags.cCompilerFlags.asSwiftcCCompilerFlags()
 
         // TODO: Pass -Xcxx flags to swiftc (#6491)
         // Uncomment when downstream support arrives.
@@ -604,7 +619,7 @@ package final class SwiftTargetBuildDescription {
         // args += self.buildParameters.flags.cxxCompilerFlags.asSwiftcCXXCompilerFlags()
 
         // Enable the correct LTO mode if requested.
-        switch self.buildParameters.linkingParameters.linkTimeOptimizationMode {
+        switch self.defaultBuildParameters.linkingParameters.linkTimeOptimizationMode {
         case nil:
             break
         case .full:
@@ -614,7 +629,7 @@ package final class SwiftTargetBuildDescription {
         }
 
         // Pass default include paths from the toolchain.
-        for includeSearchPath in self.buildParameters.toolchain.includeSearchPaths {
+        for includeSearchPath in self.defaultBuildParameters.toolchain.includeSearchPaths {
             args += ["-I", includeSearchPath.pathString]
         }
 
@@ -634,14 +649,14 @@ package final class SwiftTargetBuildDescription {
 
         args += self.package.packageNameArgument(
             target: self.target,
-            isPackageNameSupported: self.buildParameters.driverParameters.isPackageAccessModifierSupported
+            isPackageNameSupported: self.defaultBuildParameters.driverParameters.isPackageAccessModifierSupported
         )
         args += try self.macroArguments()
         
         // rdar://117578677
         // Pass -fno-omit-frame-pointer to support backtraces
         // this can be removed once the backtracer uses DWARF instead of frame pointers
-        if let omitFramePointers = self.buildParameters.debuggingParameters.omitFramePointers {
+        if let omitFramePointers = self.defaultBuildParameters.debuggingParameters.omitFramePointers {
             if omitFramePointers {
                 args += ["-Xcc", "-fomit-frame-pointer"]
             } else {
@@ -656,14 +671,14 @@ package final class SwiftTargetBuildDescription {
     /// such as emitting a module or supplementary outputs.
     package func emitCommandLine(scanInvocation: Bool = false) throws -> [String] {
         var result: [String] = []
-        result.append(self.buildParameters.toolchain.swiftCompilerPath.pathString)
+        result.append(self.defaultBuildParameters.toolchain.swiftCompilerPath.pathString)
 
         result.append("-module-name")
         result.append(self.target.c99name)
         result.append(
             contentsOf: self.package.packageNameArgument(
                 target: self.target,
-                isPackageNameSupported: self.buildParameters.driverParameters.isPackageAccessModifierSupported
+                isPackageNameSupported: self.defaultBuildParameters.driverParameters.isPackageAccessModifierSupported
             )
         )
         if !scanInvocation {
@@ -679,7 +694,7 @@ package final class SwiftTargetBuildDescription {
             result.append(try self.writeOutputFileMap().pathString)
         }
 
-        if self.buildParameters.useWholeModuleOptimization {
+        if self.defaultBuildParameters.useWholeModuleOptimization {
             result.append("-whole-module-optimization")
             result.append("-num-threads")
             result.append(String(ProcessInfo.processInfo.activeProcessorCount))
@@ -699,7 +714,7 @@ package final class SwiftTargetBuildDescription {
 
     /// Returns true if ObjC compatibility header should be emitted.
     private var shouldEmitObjCCompatibilityHeader: Bool {
-        self.buildParameters.triple.isDarwin() && self.target.type == .library
+        self.defaultBuildParameters.triple.isDarwin() && self.target.type == .library
     }
 
     func writeOutputFileMap() throws -> AbsolutePath {
@@ -713,7 +728,7 @@ package final class SwiftTargetBuildDescription {
 
             """#
 
-        if self.buildParameters.useWholeModuleOptimization {
+        if self.defaultBuildParameters.useWholeModuleOptimization {
             let moduleName = self.target.c99name
             content +=
                 #"""
@@ -744,7 +759,7 @@ package final class SwiftTargetBuildDescription {
         // Write out the entries for each source file.
         let sources = self.sources
         let objects = try self.objects
-        let ltoEnabled = self.buildParameters.linkingParameters.linkTimeOptimizationMode != nil
+        let ltoEnabled = self.defaultBuildParameters.linkingParameters.linkTimeOptimizationMode != nil
         let objectKey = ltoEnabled ? "llvm-bc" : "object"
 
         for idx in 0..<sources.count {
@@ -761,7 +776,7 @@ package final class SwiftTargetBuildDescription {
 
                 """#
 
-            if !self.buildParameters.useWholeModuleOptimization {
+            if !self.defaultBuildParameters.useWholeModuleOptimization {
                 let depsPath = self.tempsPath.appending(component: sourceFileName + ".d")
                 content +=
                     #"""
@@ -820,7 +835,7 @@ package final class SwiftTargetBuildDescription {
 
     /// Returns the build flags from the declared build settings.
     private func buildSettingsFlags() throws -> [String] {
-        let scope = self.buildParameters.createScope(for: self.target)
+        let scope = self.defaultBuildParameters.createScope(for: self.target)
         var flags: [String] = []
 
         // Swift defines.
@@ -848,7 +863,7 @@ package final class SwiftTargetBuildDescription {
         // Include path for the toolchain's copy of SwiftSyntax.
         #if BUILD_MACROS_AS_DYLIBS
         if target.type == .macro {
-            flags += try ["-I", self.buildParameters.toolchain.hostLibDir.pathString]
+            flags += try ["-I", self.defaultBuildParameters.toolchain.hostLibDir.pathString]
         }
         #endif
 
@@ -859,7 +874,7 @@ package final class SwiftTargetBuildDescription {
     private var activeCompilationConditions: [String] {
         var compilationConditions = ["-DSWIFT_PACKAGE"]
 
-        switch self.buildParameters.configuration {
+        switch self.defaultBuildParameters.configuration {
         case .debug:
             compilationConditions += ["-DDEBUG"]
         case .release:
@@ -871,7 +886,7 @@ package final class SwiftTargetBuildDescription {
 
     /// Optimization arguments according to the build configuration.
     private var optimizationArguments: [String] {
-        switch self.buildParameters.configuration {
+        switch self.defaultBuildParameters.configuration {
         case .debug:
             return ["-Onone"]
         case .release:
@@ -885,7 +900,7 @@ package final class SwiftTargetBuildDescription {
             // test targets must be built with -enable-testing
             // since its required for test discovery (the non objective-c reflection kind)
             return ["-enable-testing"]
-        } else if self.buildParameters.testingParameters.enableTestability {
+        } else if self.defaultBuildParameters.testingParameters.enableTestability {
             return ["-enable-testing"]
         } else {
             return []
@@ -895,20 +910,20 @@ package final class SwiftTargetBuildDescription {
     /// Module cache arguments.
     private var moduleCacheArgs: [String] {
         get throws {
-            ["-module-cache-path", try self.buildParameters.moduleCache.pathString]
+            ["-module-cache-path", try self.defaultBuildParameters.moduleCache.pathString]
         }
     }
 
     private var stdlibArguments: [String] {
         var arguments: [String] = []
 
-        let isLinkingStaticStdlib = self.buildParameters.linkingParameters.shouldLinkStaticSwiftStdlib
-            && self.buildParameters.triple.isSupportingStaticStdlib
+        let isLinkingStaticStdlib = self.defaultBuildParameters.linkingParameters.shouldLinkStaticSwiftStdlib
+            && self.defaultBuildParameters.triple.isSupportingStaticStdlib
         if isLinkingStaticStdlib {
             arguments += ["-static-stdlib"]
         }
 
-        if let resourcesPath = self.buildParameters.toolchain.swiftResourcesPath(isStatic: isLinkingStaticStdlib) {
+        if let resourcesPath = self.defaultBuildParameters.toolchain.swiftResourcesPath(isStatic: isLinkingStaticStdlib) {
             arguments += ["-resource-dir", "\(resourcesPath)"]
         }
 
diff --git a/Sources/Build/BuildDescription/TargetBuildDescription.swift b/Sources/Build/BuildDescription/TargetBuildDescription.swift
index c5e14b9ac9e..b4d578947f2 100644
--- a/Sources/Build/BuildDescription/TargetBuildDescription.swift
+++ b/Sources/Build/BuildDescription/TargetBuildDescription.swift
@@ -101,7 +101,7 @@ package enum TargetBuildDescription {
     var buildParameters: BuildParameters {
         switch self {
         case .swift(let swiftTargetBuildDescription):
-            return swiftTargetBuildDescription.buildParameters
+            return swiftTargetBuildDescription.defaultBuildParameters
         case .clang(let clangTargetBuildDescription):
             return clangTargetBuildDescription.buildParameters
         }
diff --git a/Sources/Build/BuildManifest/LLBuildManifestBuilder+Clang.swift b/Sources/Build/BuildManifest/LLBuildManifestBuilder+Clang.swift
index 70ae4ee508a..e6ddfc1a4fb 100644
--- a/Sources/Build/BuildManifest/LLBuildManifestBuilder+Clang.swift
+++ b/Sources/Build/BuildManifest/LLBuildManifestBuilder+Clang.swift
@@ -93,7 +93,7 @@ extension LLBuildManifestBuilder {
         let additionalInputs = try addBuildToolPlugins(.clang(target))
 
         // Create a phony node to represent the entire target.
-        let targetName = target.target.getLLBuildTargetName(config: target.buildParameters.buildConfig)
+        let targetName = target.target.getLLBuildTargetName(buildParameters: target.buildParameters)
         let output: Node = .virtual(targetName)
 
         self.manifest.addNode(output, toTarget: targetName)
diff --git a/Sources/Build/BuildManifest/LLBuildManifestBuilder+Product.swift b/Sources/Build/BuildManifest/LLBuildManifestBuilder+Product.swift
index 3061b25ee7b..cf8a797ed9c 100644
--- a/Sources/Build/BuildManifest/LLBuildManifestBuilder+Product.swift
+++ b/Sources/Build/BuildManifest/LLBuildManifestBuilder+Product.swift
@@ -15,7 +15,7 @@ import struct LLBuildManifest.Node
 
 extension LLBuildManifestBuilder {
     func createProductCommand(_ buildProduct: ProductBuildDescription) throws {
-        let cmdName = try buildProduct.product.getCommandName(config: buildProduct.buildParameters.buildConfig)
+        let cmdName = try buildProduct.product.getCommandName(buildParameters: buildProduct.buildParameters)
 
         // Add dependency on Info.plist generation on Darwin platforms.
         let testInputs: [AbsolutePath]
@@ -34,7 +34,7 @@ extension LLBuildManifestBuilder {
         }
 
         // Create a phony node to represent the entire target.
-        let targetName = try buildProduct.product.getLLBuildTargetName(config: buildProduct.buildParameters.buildConfig)
+        let targetName = try buildProduct.product.getLLBuildTargetName(buildParameters: buildProduct.buildParameters)
         let output: Node = .virtual(targetName)
 
         let finalProductNode: Node
@@ -85,7 +85,7 @@ extension LLBuildManifestBuilder {
                     outputPath: plistPath
                 )
 
-                let cmdName = try buildProduct.product.getCommandName(config: buildProduct.buildParameters.buildConfig)
+                let cmdName = try buildProduct.product.getCommandName(buildParameters: buildProduct.buildParameters)
                 let codeSigningOutput = Node.virtual(targetName + "-CodeSigning")
                 try self.manifest.addShellCmd(
                     name: "\(cmdName)-entitlements",
diff --git a/Sources/Build/BuildManifest/LLBuildManifestBuilder+Swift.swift b/Sources/Build/BuildManifest/LLBuildManifestBuilder+Swift.swift
index d499d231ebb..10fa290f50d 100644
--- a/Sources/Build/BuildManifest/LLBuildManifestBuilder+Swift.swift
+++ b/Sources/Build/BuildManifest/LLBuildManifestBuilder+Swift.swift
@@ -45,7 +45,7 @@ extension LLBuildManifestBuilder {
         let moduleNode = Node.file(target.moduleOutputPath)
         let cmdOutputs = objectNodes + [moduleNode]
 
-        if target.buildParameters.driverParameters.useIntegratedSwiftDriver {
+        if target.defaultBuildParameters.driverParameters.useIntegratedSwiftDriver {
             try self.addSwiftCmdsViaIntegratedDriver(
                 target,
                 inputs: inputs,
@@ -68,7 +68,7 @@ extension LLBuildManifestBuilder {
         // jobs needed to build this Swift target.
         var commandLine = try target.emitCommandLine()
         commandLine.append("-driver-use-frontend-path")
-        commandLine.append(target.buildParameters.toolchain.swiftCompilerPath.pathString)
+        commandLine.append(target.defaultBuildParameters.toolchain.swiftCompilerPath.pathString)
         // FIXME: At some point SwiftPM should provide its own executor for
         // running jobs/launching processes during planning
         let resolver = try ArgsResolver(fileSystem: target.fileSystem)
@@ -132,7 +132,7 @@ extension LLBuildManifestBuilder {
             // common intermediate dependency modules, such dependencies can lead
             // to cycles in the resulting manifest.
             var manifestNodeInputs: [Node] = []
-            if targetDescription.buildParameters.driverParameters.useExplicitModuleBuild && !isMainModule(job) {
+            if targetDescription.defaultBuildParameters.driverParameters.useExplicitModuleBuild && !isMainModule(job) {
                 manifestNodeInputs = jobInputs
             } else {
                 manifestNodeInputs = (inputs + jobInputs).uniqued()
@@ -192,7 +192,9 @@ extension LLBuildManifestBuilder {
         // Sort the product targets in topological order in order to collect and "bubble up"
         // their respective dependency graphs to the depending targets.
         let nodes: [ResolvedModule.Dependency] = try self.plan.targetMap.keys.compactMap {
-            guard let target = self.plan.graph.allTargets[$0] else { throw InternalError("unknown target \($0)") }
+            guard let target = self.plan.graph.allTargets[$0] else {
+                throw InternalError("unknown target \($0)")
+            }
             return ResolvedModule.Dependency.target(target, conditions: [])
         }
         let allPackageDependencies = try topologicalSort(nodes, successors: { $0.dependencies })
@@ -285,7 +287,7 @@ extension LLBuildManifestBuilder {
         // jobs needed to build this Swift target.
         var commandLine = try targetDescription.emitCommandLine()
         commandLine.append("-driver-use-frontend-path")
-        commandLine.append(targetDescription.buildParameters.toolchain.swiftCompilerPath.pathString)
+        commandLine.append(targetDescription.defaultBuildParameters.toolchain.swiftCompilerPath.pathString)
         commandLine.append("-experimental-explicit-module-build")
         let resolver = try ArgsResolver(fileSystem: self.fileSystem)
         let executor = SPMSwiftDriverExecutor(
@@ -376,14 +378,14 @@ extension LLBuildManifestBuilder {
         cmdOutputs: [Node]
     ) throws {
         let isLibrary = target.target.type == .library || target.target.type == .test
-        let cmdName = target.target.getCommandName(config: target.buildParameters.buildConfig)
+        let cmdName = target.target.getCommandName(buildParameters: target.defaultBuildParameters)
 
         self.manifest.addWriteSourcesFileListCommand(sources: target.sources, sourcesFileListPath: target.sourcesFileListPath)
         self.manifest.addSwiftCmd(
             name: cmdName,
             inputs: inputs + [Node.file(target.sourcesFileListPath)],
             outputs: cmdOutputs,
-            executable: target.buildParameters.toolchain.swiftCompilerPath,
+            executable: target.defaultBuildParameters.toolchain.swiftCompilerPath,
             moduleName: target.target.c99name,
             moduleAliases: target.target.moduleAliases,
             moduleOutputPath: target.moduleOutputPath,
@@ -394,7 +396,7 @@ extension LLBuildManifestBuilder {
             sources: target.sources,
             fileList: target.sourcesFileListPath,
             isLibrary: isLibrary,
-            wholeModuleOptimization: target.buildParameters.configuration == .release,
+            wholeModuleOptimization: target.defaultBuildParameters.configuration == .release,
             outputFileMapPath: try target.writeOutputFileMap() // FIXME: Eliminate side effect.
         )
     }
@@ -404,7 +406,7 @@ extension LLBuildManifestBuilder {
     ) throws -> [Node] {
         var inputs = target.sources.map(Node.file)
 
-        let swiftVersionFilePath = addSwiftGetVersionCommand(buildParameters: target.buildParameters)
+        let swiftVersionFilePath = addSwiftGetVersionCommand(buildParameters: target.defaultBuildParameters)
         inputs.append(.file(swiftVersionFilePath))
 
         // Add resources node as the input to the target. This isn't great because we
@@ -450,7 +452,7 @@ extension LLBuildManifestBuilder {
             }
         }
 
-        for dependency in target.target.dependencies(satisfying: target.buildParameters.buildEnvironment) {
+        for dependency in target.target.dependencies(satisfying: target.defaultBuildParameters.buildEnvironment) {
             switch dependency {
             case .target(let target, _):
                 try addStaticTargetInputs(target)
@@ -477,7 +479,7 @@ extension LLBuildManifestBuilder {
         }
 
         for binaryPath in target.libraryBinaryPaths {
-            let path = target.buildParameters.destinationPath(forBinaryAt: binaryPath)
+            let path = target.defaultBuildParameters.destinationPath(forBinaryAt: binaryPath)
             if self.fileSystem.isDirectory(binaryPath) {
                 inputs.append(directory: path)
             } else {
@@ -489,7 +491,7 @@ extension LLBuildManifestBuilder {
 
         // Depend on any required macro product's output.
         try target.requiredMacroProducts.forEach { macro in
-            try inputs.append(.virtual(macro.getLLBuildTargetName(config: target.buildParameters.buildConfig)))
+            try inputs.append(.virtual(macro.getLLBuildTargetName(buildParameters: target.defaultBuildParameters)))
         }
 
         return inputs + additionalInputs
@@ -498,7 +500,7 @@ extension LLBuildManifestBuilder {
     /// Adds a top-level phony command that builds the entire target.
     private func addTargetCmd(_ target: SwiftTargetBuildDescription, cmdOutputs: [Node]) {
         // Create a phony node to represent the entire target.
-        let targetName = target.target.getLLBuildTargetName(config: target.buildParameters.buildConfig)
+        let targetName = target.target.getLLBuildTargetName(buildParameters: target.defaultBuildParameters)
         let targetOutput: Node = .virtual(targetName)
 
         self.manifest.addNode(targetOutput, toTarget: targetName)
@@ -507,7 +509,7 @@ extension LLBuildManifestBuilder {
             inputs: cmdOutputs,
             outputs: [targetOutput]
         )
-        if self.plan.graph.isInRootPackages(target.target, satisfying: target.buildParameters.buildEnvironment) {
+        if self.plan.graph.isInRootPackages(target.target, satisfying: target.defaultBuildParameters.buildEnvironment) {
             if !target.isTestTarget {
                 self.addNode(targetOutput, toTarget: .main)
             }
@@ -517,13 +519,13 @@ extension LLBuildManifestBuilder {
 
     private func addModuleWrapCmd(_ target: SwiftTargetBuildDescription) throws {
         // Add commands to perform the module wrapping Swift modules when debugging strategy is `modulewrap`.
-        guard target.buildParameters.debuggingStrategy == .modulewrap else { return }
+        guard target.defaultBuildParameters.debuggingStrategy == .modulewrap else { return }
         var moduleWrapArgs = [
-            target.buildParameters.toolchain.swiftCompilerPath.pathString,
+            target.defaultBuildParameters.toolchain.swiftCompilerPath.pathString,
             "-modulewrap", target.moduleOutputPath.pathString,
             "-o", target.wrappedModuleOutputPath.pathString,
         ]
-        moduleWrapArgs += try target.buildParameters.targetTripleArgs(for: target.target)
+        moduleWrapArgs += try target.defaultBuildParameters.tripleArgs(for: target.target)
         self.manifest.addShellCmd(
             name: target.wrappedModuleOutputPath.pathString,
             description: "Wrapping AST for \(target.target.name) for debugging",
diff --git a/Sources/Build/BuildManifest/LLBuildManifestBuilder.swift b/Sources/Build/BuildManifest/LLBuildManifestBuilder.swift
index b1d781b7eb2..e9c1070b21c 100644
--- a/Sources/Build/BuildManifest/LLBuildManifestBuilder.swift
+++ b/Sources/Build/BuildManifest/LLBuildManifestBuilder.swift
@@ -317,31 +317,33 @@ extension TargetBuildDescription {
 }
 
 extension ResolvedModule {
-    package func getCommandName(config: String) -> String {
-        "C." + self.getLLBuildTargetName(config: config)
+    package func getCommandName(buildParameters: BuildParameters) -> String {
+        "C." + self.getLLBuildTargetName(buildParameters: buildParameters)
     }
 
-    package func getLLBuildTargetName(config: String) -> String {
-        "\(name)-\(config).module"
+    package func getLLBuildTargetName(buildParameters: BuildParameters) -> String {
+        "\(self.name)-\(buildParameters.buildConfig)\(buildParameters.suffix(triple: self.buildTriple)).module"
     }
 
     package func getLLBuildResourcesCmdName(config: String) -> String {
-        "\(name)-\(config).module-resources"
+        "\(self.name)-\(config).module-resources"
     }
 }
 
 extension ResolvedProduct {
-    package func getLLBuildTargetName(config: String) throws -> String {
-        let potentialExecutableTargetName = "\(name)-\(config).exe"
-        let potentialLibraryTargetName = "\(name)-\(config).dylib"
+    package func getLLBuildTargetName(buildParameters: BuildParameters) throws -> String {
+        let config = buildParameters.buildConfig
+        let suffix = buildParameters.suffix(triple: self.buildTriple)
+        let potentialExecutableTargetName = "\(name)-\(config)\(suffix).exe"
+        let potentialLibraryTargetName = "\(name)-\(config)\(suffix).dylib"
 
         switch type {
         case .library(.dynamic):
             return potentialLibraryTargetName
         case .test:
-            return "\(name)-\(config).test"
+            return "\(name)-\(config)\(suffix).test"
         case .library(.static):
-            return "\(name)-\(config).a"
+            return "\(name)-\(config)\(suffix).a"
         case .library(.automatic):
             throw InternalError("automatic library not supported")
         case .executable, .snippet:
@@ -357,8 +359,8 @@ extension ResolvedProduct {
         }
     }
 
-    package func getCommandName(config: String) throws -> String {
-        try "C." + self.getLLBuildTargetName(config: config)
+    public func getCommandName(buildParameters: BuildParameters) throws -> String {
+        try "C.\(self.getLLBuildTargetName(buildParameters: buildParameters))\(buildParameters.suffix(triple: self.buildTriple))"
     }
 }
 
diff --git a/Sources/Build/BuildOperation.swift b/Sources/Build/BuildOperation.swift
index e4f4128d46c..9255948a749 100644
--- a/Sources/Build/BuildOperation.swift
+++ b/Sources/Build/BuildOperation.swift
@@ -11,14 +11,11 @@
 //===----------------------------------------------------------------------===//
 
 import Basics
-
 import LLBuildManifest
 import PackageGraph
 import PackageLoading
 import PackageModel
-
 import SPMBuildCore
-
 import SPMLLBuild
 import Foundation
 
@@ -271,7 +268,7 @@ package final class BuildOperation: PackageStructureDelegate, SPMBuildCore.Build
     }
 
     // TODO: Currently this function will only match frameworks.
-    internal func detectUnexpressedDependencies(
+    func detectUnexpressedDependencies(
         availableLibraries: [LibraryMetadata],
         targetDependencyMap: [String: [String]]?
     ) {
@@ -297,7 +294,9 @@ package final class BuildOperation: PackageStructureDelegate, SPMBuildCore.Build
             }
 
             let usedSDKDependencies: [String] = Set(possibleTempsPaths).flatMap { possibleTempsPath in
-                guard let contents = try? self.fileSystem.readFileContents(possibleTempsPath.appending(component: "\(c99name).d")) else {
+                guard let contents = try? self.fileSystem.readFileContents(
+                    possibleTempsPath.appending(component: "\(c99name).d")
+                ) else {
                     return [String]()
                 }
 
@@ -522,7 +521,7 @@ package final class BuildOperation: PackageStructureDelegate, SPMBuildCore.Build
             let graph = try getPackageGraph()
             if let result = subset.llbuildTargetName(
                 for: graph,
-                config: self.productsBuildParameters.configuration.dirname,
+                buildParameters: self.productsBuildParameters,
                 observabilityScope: self.observabilityScope
             ) {
                 return result
@@ -540,17 +539,20 @@ package final class BuildOperation: PackageStructureDelegate, SPMBuildCore.Build
         // Invoke any build tool plugins in the graph to generate prebuild commands and build commands.
         if let pluginConfiguration, !self.productsBuildParameters.shouldSkipBuilding {
             // Hacky workaround for rdar://120560817, but it replicates precisely enough the original behavior before
-            // products/tools build parameters were split. Ideally we want to have specify the correct path at the time
+            // products/tools build parameters were split. Ideally we want to specify the correct path at the time
             // when `toolsBuildParameters` is initialized, but we have too many places in the codebase where that's
             // done, which makes it hard to realign them all at once.
             var pluginsBuildParameters = self.toolsBuildParameters
             pluginsBuildParameters.dataPath = pluginsBuildParameters.dataPath.parentDirectory.appending(components: ["plugins", "tools"])
+            var buildToolsGraph = graph
+            try buildToolsGraph.updateBuildTripleRecursively(.tools)
+
             let buildOperationForPluginDependencies = BuildOperation(
                 // FIXME: this doesn't maintain the products/tools split cleanly
                 productsBuildParameters: pluginsBuildParameters,
                 toolsBuildParameters: pluginsBuildParameters,
                 cacheBuildManifest: false,
-                packageGraphLoader: { return graph },
+                packageGraphLoader: { buildToolsGraph },
                 additionalFileRules: self.additionalFileRules,
                 pkgConfigDirectories: self.pkgConfigDirectories,
                 dependenciesByRootPackageIdentity: [:],
@@ -560,7 +562,7 @@ package final class BuildOperation: PackageStructureDelegate, SPMBuildCore.Build
                 fileSystem: self.fileSystem,
                 observabilityScope: self.observabilityScope
             )
-            buildToolPluginInvocationResults = try graph.invokeBuildToolPlugins(
+            buildToolPluginInvocationResults = try buildToolsGraph.invokeBuildToolPlugins(
                 outputDir: pluginConfiguration.workDirectory.appending("outputs"),
                 buildParameters: pluginsBuildParameters,
                 additionalFileRules: self.additionalFileRules,
@@ -578,7 +580,6 @@ package final class BuildOperation: PackageStructureDelegate, SPMBuildCore.Build
                 }
             }
 
-
             // Surface any diagnostics from build tool plugins.
             var succeeded = true
             for (_, (target, results)) in buildToolPluginInvocationResults {
@@ -617,7 +618,7 @@ package final class BuildOperation: PackageStructureDelegate, SPMBuildCore.Build
 
         // Emit warnings about any unhandled files in authored packages. We do this after applying build tool plugins, once we know what files they handled.
         // rdar://113256834 This fix works for the plugins that do not have PreBuildCommands.
-        let targetsToConsider: [ResolvedTarget]
+        let targetsToConsider: [ResolvedModule]
         if let subset = subset, let recursiveDependencies = try 
             subset.recursiveDependencies(for: graph, observabilityScope: observabilityScope) {
             targetsToConsider = recursiveDependencies
@@ -658,7 +659,7 @@ package final class BuildOperation: PackageStructureDelegate, SPMBuildCore.Build
 
         // Create the build plan based, on the graph and any information from plugins.
         let plan = try BuildPlan(
-            productsBuildParameters: self.productsBuildParameters,
+            destinationBuildParameters: self.productsBuildParameters,
             toolsBuildParameters: self.toolsBuildParameters,
             graph: graph,
             additionalFileRules: additionalFileRules,
@@ -901,9 +902,11 @@ extension BuildSubset {
     }
 
     /// Returns the name of the llbuild target that corresponds to the build subset.
-    func llbuildTargetName(for graph: ModulesGraph, config: String, observabilityScope: ObservabilityScope)
-        -> String?
-    {
+    func llbuildTargetName(
+        for graph: ModulesGraph,
+        buildParameters: BuildParameters,
+        observabilityScope: ObservabilityScope
+    ) -> String? {
         switch self {
         case .allExcludingTests:
             return LLBuildManifestBuilder.TargetKind.main.targetName
@@ -924,14 +927,14 @@ extension BuildSubset {
                 return LLBuildManifestBuilder.TargetKind.main.targetName
             }
             return observabilityScope.trap {
-                try product.getLLBuildTargetName(config: config)
+                try product.getLLBuildTargetName(buildParameters: buildParameters)
             }
         case .target(let targetName):
             guard let target = graph.allTargets.first(where: { $0.name == targetName }) else {
                 observabilityScope.emit(error: "no target named '\(targetName)'")
                 return nil
             }
-            return target.getLLBuildTargetName(config: config)
+            return target.getLLBuildTargetName(buildParameters: buildParameters)
         }
     }
 }
diff --git a/Sources/Build/BuildPlan/BuildPlan+Product.swift b/Sources/Build/BuildPlan/BuildPlan+Product.swift
index 6031c30775b..c3932f0d626 100644
--- a/Sources/Build/BuildPlan/BuildPlan+Product.swift
+++ b/Sources/Build/BuildPlan/BuildPlan+Product.swift
@@ -80,7 +80,7 @@ extension BuildPlan {
             switch target.underlying {
             case is SwiftTarget:
                 // Swift targets are guaranteed to have a corresponding Swift description.
-                guard case .swift(let description) = targetMap[target.id] else {
+                guard case .swift(let description) = self.targetMap[target.id] else {
                     throw InternalError("unknown target \(target)")
                 }
 
@@ -102,13 +102,13 @@ extension BuildPlan {
 
         buildProduct.staticTargets = dependencies.staticTargets
         buildProduct.dylibs = try dependencies.dylibs.map {
-            guard let product = productMap[$0.id] else {
+            guard let product = self.productMap[$0.id] else {
                 throw InternalError("unknown product \($0)")
             }
             return product
         }
         buildProduct.objects += try dependencies.staticTargets.flatMap { targetName -> [AbsolutePath] in
-            guard let target = targetMap[targetName.id] else {
+            guard let target = self.targetMap[targetName.id] else {
                 throw InternalError("unknown target \(targetName)")
             }
             return try target.objects
@@ -230,9 +230,11 @@ extension BuildPlan {
                     if product.targets.contains(id: target.id) {
                         staticTargets.append(target)
                     }
-                // Library targets should always be included.
+                // Library targets should always be included for the same build triple.
                 case .library:
-                    staticTargets.append(target)
+                    if target.buildTriple == product.buildTriple {
+                        staticTargets.append(target)
+                    }
                 // Add system target to system targets array.
                 case .systemModule:
                     systemModules.append(target)
diff --git a/Sources/Build/BuildPlan/BuildPlan+Swift.swift b/Sources/Build/BuildPlan/BuildPlan+Swift.swift
index 36b1cacde0c..058631598f2 100644
--- a/Sources/Build/BuildPlan/BuildPlan+Swift.swift
+++ b/Sources/Build/BuildPlan/BuildPlan+Swift.swift
@@ -19,7 +19,7 @@ extension BuildPlan {
     func plan(swiftTarget: SwiftTargetBuildDescription) throws {
         // We need to iterate recursive dependencies because Swift compiler needs to see all the targets a target
         // depends on.
-        let environment = swiftTarget.buildParameters.buildEnvironment
+        let environment = swiftTarget.defaultBuildParameters.buildEnvironment
         for case .target(let dependency, _) in try swiftTarget.target.recursiveDependencies(satisfying: environment) {
             switch dependency.underlying {
             case let underlyingTarget as ClangTarget where underlyingTarget.type == .library:
@@ -40,7 +40,7 @@ extension BuildPlan {
                 swiftTarget.additionalFlags += try pkgConfig(for: target).cFlags
             case let target as BinaryTarget:
                 if case .xcframework = target.kind {
-                    let libraries = try self.parseXCFramework(for: target, triple: swiftTarget.buildParameters.triple)
+                    let libraries = try self.parseXCFramework(for: target, triple: swiftTarget.defaultBuildParameters.triple)
                     for library in libraries {
                         library.headersPaths.forEach {
                             swiftTarget.additionalFlags += ["-I", $0.pathString, "-Xcc", "-I", "-Xcc", $0.pathString]
diff --git a/Sources/Build/BuildPlan/BuildPlan+Test.swift b/Sources/Build/BuildPlan/BuildPlan+Test.swift
index bf1838af200..23c03da9363 100644
--- a/Sources/Build/BuildPlan/BuildPlan+Test.swift
+++ b/Sources/Build/BuildPlan/BuildPlan+Test.swift
@@ -26,15 +26,16 @@ import protocol TSCBasic.FileSystem
 
 extension BuildPlan {
     static func makeDerivedTestTargets(
-        _ buildParameters: BuildParameters,
+        destinationBuildParameters: BuildParameters,
+        toolsBuildParameters: BuildParameters,
         _ graph: ModulesGraph,
-        _ disableSandbox: Bool,
+        shouldDisableSandbox: Bool,
         _ fileSystem: FileSystem,
         _ observabilityScope: ObservabilityScope
     ) throws -> [(product: ResolvedProduct, discoveryTargetBuildDescription: SwiftTargetBuildDescription?, entryPointTargetBuildDescription: SwiftTargetBuildDescription)] {
-        guard buildParameters.testingParameters.testProductStyle.requiresAdditionalDerivedTestTargets,
-              case .entryPointExecutable(let explicitlyEnabledDiscovery, let explicitlySpecifiedPath) = 
-                buildParameters.testingParameters.testProductStyle
+        guard destinationBuildParameters.testingParameters.testProductStyle.requiresAdditionalDerivedTestTargets,
+              case .entryPointExecutable(let explicitlyEnabledDiscovery, let explicitlySpecifiedPath) =
+                destinationBuildParameters.testingParameters.testProductStyle
         else {
             throw InternalError("makeTestManifestTargets should not be used for build plan which does not require additional derived test targets")
         }
@@ -68,7 +69,7 @@ extension BuildPlan {
             /// Generates test discovery targets, which contain derived sources listing the discovered tests.
             func generateDiscoveryTargets() throws -> (target: SwiftTarget, resolved: ResolvedModule, buildDescription: SwiftTargetBuildDescription) {
                 let discoveryTargetName = "\(package.manifest.displayName)PackageDiscoveredTests"
-                let discoveryDerivedDir = buildParameters.buildPath.appending(components: "\(discoveryTargetName).derived")
+                let discoveryDerivedDir = destinationBuildParameters.buildPath.appending(components: "\(discoveryTargetName).derived")
                 let discoveryMainFile = discoveryDerivedDir.appending(component: TestDiscoveryTool.mainFileName)
 
                 var discoveryPaths: [AbsolutePath] = []
@@ -84,7 +85,7 @@ extension BuildPlan {
                     packageAccess: true, // test target is allowed access to package decls by default
                     testDiscoverySrc: Sources(paths: discoveryPaths, root: discoveryDerivedDir)
                 )
-                let discoveryResolvedTarget = ResolvedModule(
+                var discoveryResolvedTarget = ResolvedModule(
                     packageIdentity: testProduct.packageIdentity,
                     underlying: discoveryTarget,
                     dependencies: testProduct.targets.map { .target($0, conditions: []) },
@@ -92,13 +93,23 @@ extension BuildPlan {
                     supportedPlatforms: testProduct.supportedPlatforms,
                     platformVersionProvider: testProduct.platformVersionProvider
                 )
+
+                discoveryResolvedTarget.buildTriple = testProduct.buildTriple
+                let discoveryTargetBuildParameters: BuildParameters
+                switch discoveryResolvedTarget.buildTriple {
+                case .tools:
+                    discoveryTargetBuildParameters = toolsBuildParameters
+                case .destination:
+                    discoveryTargetBuildParameters = destinationBuildParameters
+                }
                 let discoveryTargetBuildDescription = try SwiftTargetBuildDescription(
                     package: package,
                     target: discoveryResolvedTarget,
                     toolsVersion: toolsVersion,
-                    buildParameters: buildParameters,
+                    destinationBuildParameters: discoveryTargetBuildParameters,
+                    toolsBuildParameters: toolsBuildParameters,
                     testTargetRole: .discovery,
-                    disableSandbox: disableSandbox,
+                    shouldDisableSandbox: shouldDisableSandbox,
                     fileSystem: fileSystem,
                     observabilityScope: observabilityScope
                 )
@@ -112,8 +123,8 @@ extension BuildPlan {
                 swiftTargetDependencies: [Target.Dependency],
                 resolvedTargetDependencies: [ResolvedModule.Dependency]
             ) throws -> SwiftTargetBuildDescription {
-                let entryPointDerivedDir = buildParameters.buildPath.appending(components: "\(testProduct.name).derived")
-                let entryPointMainFileName = TestEntryPointTool.mainFileName(for: buildParameters.testingParameters.library)
+                let entryPointDerivedDir = destinationBuildParameters.buildPath.appending(components: "\(testProduct.name).derived")
+                let entryPointMainFileName = TestEntryPointTool.mainFileName(for: destinationBuildParameters.testingParameters.library)
                 let entryPointMainFile = entryPointDerivedDir.appending(component: entryPointMainFileName)
                 let entryPointSources = Sources(paths: [entryPointMainFile], root: entryPointDerivedDir)
 
@@ -124,7 +135,7 @@ extension BuildPlan {
                     packageAccess: true, // test target is allowed access to package decls
                     testEntryPointSources: entryPointSources
                 )
-                let entryPointResolvedTarget = ResolvedModule(
+                var entryPointResolvedTarget = ResolvedModule(
                     packageIdentity: testProduct.packageIdentity,
                     underlying: entryPointTarget,
                     dependencies: testProduct.targets.map { .target($0, conditions: []) } + resolvedTargetDependencies,
@@ -132,13 +143,23 @@ extension BuildPlan {
                     supportedPlatforms: testProduct.supportedPlatforms,
                     platformVersionProvider: testProduct.platformVersionProvider
                 )
+                entryPointResolvedTarget.buildTriple = testProduct.buildTriple
+                let entryPointBuildParameters: BuildParameters
+                switch entryPointResolvedTarget.buildTriple {
+                case .tools:
+                    entryPointBuildParameters = toolsBuildParameters
+                case .destination:
+                    entryPointBuildParameters = destinationBuildParameters
+                }
+
                 return try SwiftTargetBuildDescription(
                     package: package,
                     target: entryPointResolvedTarget,
                     toolsVersion: toolsVersion,
-                    buildParameters: buildParameters,
+                    destinationBuildParameters: entryPointBuildParameters,
+                    toolsBuildParameters: toolsBuildParameters,
                     testTargetRole: .entryPoint(isSynthesized: true),
-                    disableSandbox: disableSandbox,
+                    shouldDisableSandbox: shouldDisableSandbox,
                     fileSystem: fileSystem,
                     observabilityScope: observabilityScope
                 )
@@ -148,7 +169,7 @@ extension BuildPlan {
             let swiftTargetDependencies: [Target.Dependency]
             let resolvedTargetDependencies: [ResolvedModule.Dependency]
 
-            switch buildParameters.testingParameters.library {
+            switch destinationBuildParameters.testingParameters.library {
             case .xctest:
                 discoveryTargets = try generateDiscoveryTargets()
                 swiftTargetDependencies = [.target(discoveryTargets!.target, conditions: [])]
@@ -181,9 +202,10 @@ extension BuildPlan {
                             package: package,
                             target: entryPointResolvedTarget,
                             toolsVersion: toolsVersion,
-                            buildParameters: buildParameters,
+                            destinationBuildParameters: destinationBuildParameters,
+                            toolsBuildParameters: toolsBuildParameters,
                             testTargetRole: .entryPoint(isSynthesized: false),
-                            disableSandbox: disableSandbox,
+                            shouldDisableSandbox: shouldDisableSandbox,
                             fileSystem: fileSystem,
                             observabilityScope: observabilityScope
                         )
@@ -203,9 +225,10 @@ extension BuildPlan {
                         package: package,
                         target: entryPointResolvedTarget,
                         toolsVersion: toolsVersion,
-                        buildParameters: buildParameters,
+                        destinationBuildParameters: destinationBuildParameters,
+                        toolsBuildParameters: toolsBuildParameters,
                         testTargetRole: .entryPoint(isSynthesized: false),
-                        disableSandbox: disableSandbox,
+                        shouldDisableSandbox: shouldDisableSandbox,
                         fileSystem: fileSystem,
                         observabilityScope: observabilityScope
                     )
diff --git a/Sources/Build/BuildPlan/BuildPlan.swift b/Sources/Build/BuildPlan/BuildPlan.swift
index 0c13a3daed9..0f4a9e06e8d 100644
--- a/Sources/Build/BuildPlan/BuildPlan.swift
+++ b/Sources/Build/BuildPlan/BuildPlan.swift
@@ -128,12 +128,13 @@ extension BuildParameters {
     }
 
     /// Computes the target triple arguments for a given resolved target.
-    package func targetTripleArgs(for target: ResolvedModule) throws -> [String] {
+    package func tripleArgs(for target: ResolvedModule) throws -> [String] {
+        // confusingly enough this is the triple argument, not the target argument
         var args = ["-target"]
 
         // Compute the triple string for Darwin platform using the platform version.
         if self.triple.isDarwin() {
-            let platform = buildEnvironment.platform
+            let platform = self.buildEnvironment.platform
             let supportedPlatform = target.getSupportedPlatform(for: platform, usingXCTest: target.type == .test)
             args += [self.triple.tripleString(forPlatformVersion: supportedPlatform.version.versionString)]
         } else {
@@ -185,16 +186,6 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
     /// Build parameters used for tools.
     public let toolsBuildParameters: BuildParameters
 
-    /// Triple for which this target is compiled.
-    private func buildTriple(for target: ResolvedModule) -> Basics.Triple {
-        self.buildParameters(for: target).triple
-    }
-
-    /// Triple for which this product is compiled.
-    private func buildTriple(for product: ResolvedProduct) -> Basics.Triple {
-        self.buildParameters(for: product).triple
-    }
-
     /// The package graph.
     package let graph: ModulesGraph
 
@@ -230,14 +221,14 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
     /// Cache for pkgConfig flags.
     private var pkgConfigCache = [SystemLibraryTarget: (cFlags: [String], libs: [String])]()
 
-    /// Cache for  library information.
+    /// Cache for library information.
     private var externalLibrariesCache = [BinaryTarget: [LibraryInfo]]()
 
-    /// Cache for  tools information.
+    /// Cache for tools information.
     var externalExecutablesCache = [BinaryTarget: [ExecutableInfo]]()
 
     /// Whether to disable sandboxing (e.g. for macros).
-    private let disableSandbox: Bool
+    private let shouldDisableSandbox: Bool
 
     /// The filesystem to operate on.
     let fileSystem: any FileSystem
@@ -245,18 +236,18 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
     /// ObservabilityScope with which to emit diagnostics
     let observabilityScope: ObservabilityScope
 
-    @available(*, deprecated, renamed: "init(productsBuildParameters:toolsBuildParameters:graph:)")
+    @available(*, deprecated, renamed: "init(destinationBuildParameters:toolsBuildParameters:graph:)")
     public convenience init(
         buildParameters: BuildParameters,
         graph: ModulesGraph,
         additionalFileRules: [FileRuleDescription] = [],
-        buildToolPluginInvocationResults: [ResolvedTarget.ID: [BuildToolPluginInvocationResult]] = [:],
-        prebuildCommandResults: [ResolvedTarget.ID: [PrebuildCommandResult]] = [:],
+        buildToolPluginInvocationResults: [ResolvedModule.ID: [BuildToolPluginInvocationResult]] = [:],
+        prebuildCommandResults: [ResolvedModule.ID: [PrebuildCommandResult]] = [:],
         fileSystem: any FileSystem,
         observabilityScope: ObservabilityScope
     ) throws {
         try self.init(
-            productsBuildParameters: buildParameters,
+            destinationBuildParameters: buildParameters,
             toolsBuildParameters: buildParameters,
             graph: graph,
             additionalFileRules: additionalFileRules,
@@ -267,11 +258,29 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         )
     }
 
-    /// Create a build plan with a package graph and explicitly distinct build parameters for products and tools.
-    public init(
+    @available(*, deprecated, renamed: "init(destinationBuildParameters:toolsBuildParameters:graph:fileSystem:observabilityScope:)")
+    public convenience init(
         productsBuildParameters: BuildParameters,
         toolsBuildParameters: BuildParameters,
         graph: ModulesGraph,
+        fileSystem: any FileSystem,
+        observabilityScope: ObservabilityScope
+    ) throws {
+        try self.init(
+            destinationBuildParameters: productsBuildParameters,
+            toolsBuildParameters: toolsBuildParameters,
+            graph: graph,
+            fileSystem: fileSystem,
+            observabilityScope: observabilityScope
+        )
+    }
+
+    /// Create a build plan with a package graph and explicitly distinct build parameters for destination platform and
+    /// tools platform.
+    public init(
+        destinationBuildParameters: BuildParameters,
+        toolsBuildParameters: BuildParameters,
+        graph: ModulesGraph,
         additionalFileRules: [FileRuleDescription] = [],
         buildToolPluginInvocationResults: [ResolvedModule.ID: [BuildToolPluginInvocationResult]] = [:],
         prebuildCommandResults: [ResolvedModule.ID: [PrebuildCommandResult]] = [:],
@@ -279,16 +288,17 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         fileSystem: any FileSystem,
         observabilityScope: ObservabilityScope
     ) throws {
-        self.destinationBuildParameters = productsBuildParameters
+        self.destinationBuildParameters = destinationBuildParameters
         self.toolsBuildParameters = toolsBuildParameters
         self.graph = graph
         self.buildToolPluginInvocationResults = buildToolPluginInvocationResults
         self.prebuildCommandResults = prebuildCommandResults
-        self.disableSandbox = disableSandbox
+        self.shouldDisableSandbox = disableSandbox
         self.fileSystem = fileSystem
         self.observabilityScope = observabilityScope.makeChildScope(description: "Build Plan")
 
-        var productMap: [ResolvedProduct.ID: (product: ResolvedProduct, buildDescription: ProductBuildDescription)] = [:]
+        var productMap: [ResolvedProduct.ID: (product: ResolvedProduct, buildDescription: ProductBuildDescription)] =
+            [:]
         // Create product description for each product we have in the package graph that is eligible.
         for product in graph.allProducts where product.shouldCreateProductDescription {
             let buildParameters: BuildParameters
@@ -296,7 +306,7 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
             case .tools:
                 buildParameters = toolsBuildParameters
             case .destination:
-                buildParameters = productsBuildParameters
+                buildParameters = destinationBuildParameters
             }
 
             guard let package = graph.package(for: product) else {
@@ -334,7 +344,7 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
             case .tools:
                 buildParameters = toolsBuildParameters
             case .destination:
-                buildParameters = productsBuildParameters
+                buildParameters = destinationBuildParameters
             }
 
             // Validate the product dependencies of this target.
@@ -383,12 +393,13 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
                         target: target,
                         toolsVersion: toolsVersion,
                         additionalFileRules: additionalFileRules,
-                        buildParameters: buildParameters,
+                        destinationBuildParameters: buildParameters,
+                        toolsBuildParameters: toolsBuildParameters,
                         buildToolPluginInvocationResults: buildToolPluginInvocationResults[target.id] ?? [],
                         prebuildCommandResults: prebuildCommandResults[target.id] ?? [],
                         requiredMacroProducts: requiredMacroProducts,
                         shouldGenerateTestObservation: generateTestObservation,
-                        disableSandbox: self.disableSandbox,
+                        shouldDisableSandbox: self.shouldDisableSandbox,
                         fileSystem: fileSystem,
                         observabilityScope: observabilityScope
                     )
@@ -440,19 +451,21 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         }
 
         // Plan the derived test targets, if necessary.
-        if productsBuildParameters.testingParameters.testProductStyle.requiresAdditionalDerivedTestTargets {
+        if destinationBuildParameters.testingParameters.testProductStyle.requiresAdditionalDerivedTestTargets {
             let derivedTestTargets = try Self.makeDerivedTestTargets(
-                productsBuildParameters,
+                destinationBuildParameters: destinationBuildParameters,
+                toolsBuildParameters: toolsBuildParameters,
                 graph,
-                self.disableSandbox,
+                shouldDisableSandbox: self.shouldDisableSandbox,
                 self.fileSystem,
                 self.observabilityScope
             )
             for item in derivedTestTargets {
                 var derivedTestTargets = [item.entryPointTargetBuildDescription.target]
 
-                targetMap[item.entryPointTargetBuildDescription.target.id] = 
-                    .swift(item.entryPointTargetBuildDescription)
+                targetMap[item.entryPointTargetBuildDescription.target.id] = .swift(
+                    item.entryPointTargetBuildDescription
+                )
 
                 if let discoveryTargetBuildDescription = item.discoveryTargetBuildDescription {
                     targetMap[discoveryTargetBuildDescription.target.id] = .swift(discoveryTargetBuildDescription)
diff --git a/Sources/Build/CMakeLists.txt b/Sources/Build/CMakeLists.txt
index fcc51aed76d..9412aa38590 100644
--- a/Sources/Build/CMakeLists.txt
+++ b/Sources/Build/CMakeLists.txt
@@ -10,6 +10,7 @@ add_library(Build
   BuildDescription/ClangTargetBuildDescription.swift
   BuildDescription/PluginDescription.swift
   BuildDescription/ProductBuildDescription.swift
+  BuildDescription/ResolvedModule+BuildDescription.swift
   BuildDescription/SwiftTargetBuildDescription.swift
   BuildDescription/TargetBuildDescription.swift
   BuildManifest/LLBuildManifestBuilder.swift
diff --git a/Sources/Commands/PackageCommands/PluginCommand.swift b/Sources/Commands/PackageCommands/PluginCommand.swift
index b7620cdec77..3255e1d854b 100644
--- a/Sources/Commands/PackageCommands/PluginCommand.swift
+++ b/Sources/Commands/PackageCommands/PluginCommand.swift
@@ -18,7 +18,9 @@ import CoreCommands
 import SPMBuildCore
 
 import Dispatch
+
 import PackageGraph
+
 import PackageModel
 
 import enum TSCBasic.ProcessEnv
@@ -319,6 +321,9 @@ struct PluginCommand: SwiftCommand {
         let toolSearchDirs = [try swiftCommandState.getTargetToolchain().swiftCompilerPath.parentDirectory]
             + getEnvSearchPaths(pathString: ProcessEnv.path, currentWorkingDirectory: .none)
 
+        var buildToolsGraph = packageGraph
+        try buildToolsGraph.updateBuildTripleRecursively(.tools)
+
         let buildParameters = try swiftCommandState.toolsBuildParameters
         // Build or bring up-to-date any executable host-side tools on which this plugin depends. Add them and any binary dependencies to the tool-names-to-path map.
         let buildSystem = try swiftCommandState.createBuildSystem(
@@ -327,10 +332,12 @@ struct PluginCommand: SwiftCommand {
             // Force all dependencies to be built for the host, to work around the fact that BuildOperation.plan
             // knows to compile build tool plugin dependencies for the host but does not do the same for command
             // plugins.
-            productsBuildParameters: buildParameters
+            productsBuildParameters: buildParameters,
+            packageGraphLoader: { buildToolsGraph }
         )
+
         let accessibleTools = try plugin.processAccessibleTools(
-            packageGraph: packageGraph,
+            packageGraph: buildToolsGraph,
             fileSystem: swiftCommandState.fileSystem,
             environment: buildParameters.buildEnvironment,
             for: try pluginScriptRunner.hostTriple
diff --git a/Sources/Commands/SwiftTestCommand.swift b/Sources/Commands/SwiftTestCommand.swift
index bd2ebf02208..1650c2eb663 100644
--- a/Sources/Commands/SwiftTestCommand.swift
+++ b/Sources/Commands/SwiftTestCommand.swift
@@ -401,7 +401,7 @@ package struct SwiftTestCommand: AsyncSwiftCommand {
         let toolchain = try swiftCommandState.getTargetToolchain()
         let testEnv = try TestingSupport.constructTestEnvironment(
             toolchain: toolchain,
-            buildParameters: buildParameters,
+            destinationBuildParameters: buildParameters,
             sanitizers: globalOptions.build.sanitizers
         )
 
@@ -676,7 +676,7 @@ extension SwiftTestCommand {
             let toolchain = try swiftCommandState.getTargetToolchain()
             let testEnv = try TestingSupport.constructTestEnvironment(
                 toolchain: toolchain,
-                buildParameters: buildParameters,
+                destinationBuildParameters: buildParameters,
                 sanitizers: globalOptions.build.sanitizers
             )
 
@@ -985,7 +985,7 @@ final class ParallelTestRunner {
 
         let testEnv = try TestingSupport.constructTestEnvironment(
             toolchain: self.toolchain,
-            buildParameters: self.buildParameters,
+            destinationBuildParameters: self.buildParameters,
             sanitizers: self.buildOptions.sanitizers
         )
 
diff --git a/Sources/Commands/Utilities/PluginDelegate.swift b/Sources/Commands/Utilities/PluginDelegate.swift
index 30d50f87dae..82960b6e0c8 100644
--- a/Sources/Commands/Utilities/PluginDelegate.swift
+++ b/Sources/Commands/Utilities/PluginDelegate.swift
@@ -238,7 +238,7 @@ final class PluginDelegate: PluginInvocationDelegate {
         // Construct the environment we'll pass down to the tests.
         let testEnvironment = try TestingSupport.constructTestEnvironment(
             toolchain: toolchain,
-            buildParameters: toolsBuildParameters,
+            destinationBuildParameters: toolsBuildParameters,
             sanitizers: swiftCommandState.options.build.sanitizers
         )
 
diff --git a/Sources/Commands/Utilities/SymbolGraphExtract.swift b/Sources/Commands/Utilities/SymbolGraphExtract.swift
index e30fb813f1a..03c3afde7bd 100644
--- a/Sources/Commands/Utilities/SymbolGraphExtract.swift
+++ b/Sources/Commands/Utilities/SymbolGraphExtract.swift
@@ -66,7 +66,7 @@ package struct SymbolGraphExtract {
         // Construct arguments for extracting symbols for a single target.
         var commandLine = [self.tool.pathString]
         commandLine += ["-module-name", module.c99name]
-        commandLine += try buildParameters.targetTripleArgs(for: module)
+        commandLine += try buildParameters.tripleArgs(for: module)
         commandLine += try buildPlan.createAPIToolCommonArgs(includeLibrarySearchPaths: true)
         commandLine += ["-module-cache-path", try buildParameters.moduleCache.pathString]
         if verboseOutput {
diff --git a/Sources/Commands/Utilities/TestingSupport.swift b/Sources/Commands/Utilities/TestingSupport.swift
index d7643d330e7..d582223fc08 100644
--- a/Sources/Commands/Utilities/TestingSupport.swift
+++ b/Sources/Commands/Utilities/TestingSupport.swift
@@ -38,7 +38,9 @@ enum TestingSupport {
 
         func findXCTestHelper(swiftBuildPath: AbsolutePath) -> AbsolutePath? {
             // XCTestHelper tool is installed in libexec.
-            let maybePath = swiftBuildPath.parentDirectory.parentDirectory.appending(components: "libexec", "swift", "pm", "swiftpm-xctest-helper")
+            let maybePath = swiftBuildPath.parentDirectory.parentDirectory.appending(
+                components: "libexec", "swift", "pm", "swiftpm-xctest-helper"
+            )
             if swiftCommandState.fileSystem.isFile(maybePath) {
                 return maybePath
             } else {
@@ -56,7 +58,10 @@ enum TestingSupport {
 
         // This will be true during swiftpm development or when using swift.org toolchains.
         let xcodePath = try TSCBasic.Process.checkNonZeroExit(args: "/usr/bin/xcode-select", "--print-path").spm_chomp()
-        let installedSwiftBuildPath = try TSCBasic.Process.checkNonZeroExit(args: "/usr/bin/xcrun", "--find", "swift-build", environment: ["DEVELOPER_DIR": xcodePath]).spm_chomp()
+        let installedSwiftBuildPath = try TSCBasic.Process.checkNonZeroExit(
+            args: "/usr/bin/xcrun", "--find", "swift-build",
+            environment: ["DEVELOPER_DIR": xcodePath]
+        ).spm_chomp()
         if let xctestHelperPath = findXCTestHelper(swiftBuildPath: try AbsolutePath(validating: installedSwiftBuildPath)) {
             return xctestHelperPath
         }
@@ -112,7 +117,7 @@ enum TestingSupport {
             args = [try Self.xctestHelperPath(swiftCommandState: swiftCommandState).pathString, path.pathString, tempFile.path.pathString]
             let env = try Self.constructTestEnvironment(
                 toolchain: try swiftCommandState.getTargetToolchain(),
-                buildParameters: swiftCommandState.buildParametersForTest(
+                destinationBuildParameters: swiftCommandState.buildParametersForTest(
                     enableCodeCoverage: enableCodeCoverage,
                     shouldSkipBuilding: shouldSkipBuilding,
                     experimentalTestOutput: experimentalTestOutput,
@@ -128,7 +133,7 @@ enum TestingSupport {
         #else
         let env = try Self.constructTestEnvironment(
             toolchain: try swiftCommandState.getTargetToolchain(),
-            buildParameters: swiftCommandState.buildParametersForTest(
+            destinationBuildParameters: swiftCommandState.buildParametersForTest(
                 enableCodeCoverage: enableCodeCoverage,
                 shouldSkipBuilding: shouldSkipBuilding,
                 library: .xctest
@@ -145,7 +150,7 @@ enum TestingSupport {
     /// Creates the environment needed to test related tools.
     static func constructTestEnvironment(
         toolchain: UserToolchain,
-        buildParameters: BuildParameters,
+        destinationBuildParameters buildParameters: BuildParameters,
         sanitizers: [Sanitizer]
     ) throws -> EnvironmentVariables {
         var env = EnvironmentVariables.process()
diff --git a/Sources/Commands/Utilities/XCTEvents.swift b/Sources/Commands/Utilities/XCTEvents.swift
index a264b205e3a..0ceedfce77f 100644
--- a/Sources/Commands/Utilities/XCTEvents.swift
+++ b/Sources/Commands/Utilities/XCTEvents.swift
@@ -237,12 +237,12 @@ extension TestErrorInfo {
 extension TestIssue {
     init(_ issue: XCTIssue) {
         self.init(
-            type: .init(destinationBuildParameters: issue.type),
+            type: .init(defaultBuildParameters: issue.type),
             compactDescription: issue.compactDescription,
             detailedDescription: issue.detailedDescription,
-            associatedError: issue.associatedError.map { .init(destinationBuildParameters: $0) },
-            sourceCodeContext: .init(destinationBuildParameters: issue.sourceCodeContext),
-            attachments: issue.attachments.map { .init(destinationBuildParameters: $0) }
+            associatedError: issue.associatedError.map { .init(defaultBuildParameters: $0) },
+            sourceCodeContext: .init(defaultBuildParameters: issue.sourceCodeContext),
+            attachments: issue.attachments.map { .init(defaultBuildParameters: $0) }
         )
     }
 }
@@ -275,8 +275,8 @@ extension TestLocation {
 extension TestSourceCodeContext {
     init(_ context: XCTSourceCodeContext) {
         self.init(
-            callStack: context.callStack.map { .init(destinationBuildParameters: $0) },
-            location: context.location.map { .init(destinationBuildParameters: $0) }
+            callStack: context.callStack.map { .init(defaultBuildParameters: $0) },
+            location: context.location.map { .init(defaultBuildParameters: $0) }
         )
     }
 }
@@ -285,8 +285,8 @@ extension TestSourceCodeFrame {
     init(_ frame: XCTSourceCodeFrame) {
         self.init(
             address: frame.address,
-            symbolInfo: (try? frame.symbolInfo()).map { .init(destinationBuildParameters: $0) },
-            symbolicationError: frame.symbolicationError.map { .init(destinationBuildParameters: $0) }
+            symbolInfo: (try? frame.symbolInfo()).map { .init(defaultBuildParameters: $0) },
+            symbolicationError: frame.symbolicationError.map { .init(defaultBuildParameters: $0) }
         )
     }
 }
@@ -296,7 +296,7 @@ extension TestSourceCodeSymbolInfo {
         self.init(
             imageName: symbolInfo.imageName,
             symbolName: symbolInfo.symbolName,
-            location: symbolInfo.location.map { .init(destinationBuildParameters: $0) }
+            location: symbolInfo.location.map { .init(defaultBuildParameters: $0) }
         )
     }
 }
diff --git a/Sources/PackageGraph/BuildTriple.swift b/Sources/PackageGraph/BuildTriple.swift
index 4e121a2c7bb..87d2daf21f1 100644
--- a/Sources/PackageGraph/BuildTriple.swift
+++ b/Sources/PackageGraph/BuildTriple.swift
@@ -10,6 +10,9 @@
 //
 //===----------------------------------------------------------------------===//
 
+import class PackageModel.Target
+import class PackageModel.Product
+
 /// Triple for which code should be compiled for.
 /// > Note: We're not using "host" and "target" triple terminology in this enum, as that clashes with build
 /// > system "targets" and can lead to confusion in this context.
@@ -20,3 +23,23 @@ public enum BuildTriple {
     /// Triple of the destination platform for which end products are compiled (the target triple).
     case destination
 }
+
+extension Target {
+    var buildTriple: BuildTriple {
+        if self.type == .macro || self.type == .plugin {
+            .tools
+        } else {
+            .destination
+        }
+    }
+}
+
+extension Product {
+    var buildTriple: BuildTriple {
+        if self.type == .macro || self.type == .plugin {
+            .tools
+        } else {
+            .destination
+        }
+    }
+}
diff --git a/Sources/PackageGraph/CMakeLists.txt b/Sources/PackageGraph/CMakeLists.txt
index 6a1695a0a4d..b95b1eb9feb 100644
--- a/Sources/PackageGraph/CMakeLists.txt
+++ b/Sources/PackageGraph/CMakeLists.txt
@@ -35,7 +35,7 @@ add_library(PackageGraph
   Resolution/PlatformVersionProvider.swift
   Resolution/ResolvedPackage.swift
   Resolution/ResolvedProduct.swift
-  Resolution/ResolvedTarget.swift
+  Resolution/ResolvedModule.swift
   Version+Extensions.swift
   VersionSetSpecifier.swift)
 target_link_libraries(PackageGraph PUBLIC
diff --git a/Sources/PackageGraph/ModulesGraph+Loading.swift b/Sources/PackageGraph/ModulesGraph+Loading.swift
index 716ff676695..1079ad868b0 100644
--- a/Sources/PackageGraph/ModulesGraph+Loading.swift
+++ b/Sources/PackageGraph/ModulesGraph+Loading.swift
@@ -165,12 +165,12 @@ extension ModulesGraph {
             observabilityScope: observabilityScope
         )
 
-        let rootPackages = resolvedPackages.filter{ root.manifests.values.contains($0.manifest) }
+        let rootPackages = resolvedPackages.filter { root.manifests.values.contains($0.manifest) }
         checkAllDependenciesAreUsed(rootPackages, observabilityScope: observabilityScope)
 
         return try ModulesGraph(
             rootPackages: rootPackages,
-            rootDependencies: resolvedPackages.filter{ rootDependencies.contains($0.manifest) },
+            rootDependencies: resolvedPackages.filter { rootDependencies.contains($0.manifest) },
             dependencies: requiredDependencies,
             binaryArtifacts: binaryArtifacts
         )
@@ -180,16 +180,16 @@ extension ModulesGraph {
 private func checkAllDependenciesAreUsed(_ rootPackages: [ResolvedPackage], observabilityScope: ObservabilityScope) {
     for package in rootPackages {
         // List all dependency products dependent on by the package targets.
-        let productDependencies = IdentifiableSet(package.targets.flatMap({ target in
-            return target.dependencies.compactMap({ targetDependency in
+        let productDependencies = IdentifiableSet(package.targets.flatMap { target in
+            return target.dependencies.compactMap { targetDependency in
                 switch targetDependency {
                 case .product(let product, _):
                     return product
                 case .target:
                     return nil
                 }
-            })
-        }))
+            }
+        })
 
         for dependency in package.dependencies {
             // We continue if the dependency contains executable products to make sure we don't
@@ -217,7 +217,12 @@ private func checkAllDependenciesAreUsed(_ rootPackages: [ResolvedPackage], obse
             )
 
             // Otherwise emit a warning if none of the dependency package's products are used.
-            let dependencyIsUsed = dependency.products.contains(where: { productDependencies.contains(id: $0.id) })
+            let dependencyIsUsed = dependency.products.contains { product in
+                // Don't compare by product ID, but by product name to make sure both build triples as properties of
+                // `ResolvedProduct.ID` are allowed.
+                productDependencies.contains { $0.name == product.name }
+            }
+
             if !dependencyIsUsed && !observabilityScope.errorsReportedInAnyScope {
                 packageDiagnosticsScope.emit(.unusedDependency(dependency.identity.description))
             }
@@ -275,7 +280,10 @@ private func createResolvedPackages(
 
     // Resolve module aliases, if specified, for targets and their dependencies
     // across packages. Aliasing will result in target renaming.
-    let moduleAliasingUsed = try resolveModuleAliases(packageBuilders: packageBuilders, observabilityScope: observabilityScope)
+    let moduleAliasingUsed = try resolveModuleAliases(
+        packageBuilders: packageBuilders,
+        observabilityScope: observabilityScope
+    )
 
     // Scan and validate the dependencies
     for packageBuilder in packageBuilders {
@@ -640,12 +648,12 @@ private func createResolvedPackages(
             observabilityScope.emit(
                 ModuleError.duplicateModule(
                     targetName: entry.key,
-                    packages: entry.value.map{ $0.identity })
+                    packages: entry.value.map { $0.identity })
             )
         }
     }
 
-    return try packageBuilders.map{ try $0.construct() }
+    return try packageBuilders.map { try $0.construct() }
 }
 
 private func emitDuplicateProductDiagnostic(
@@ -956,7 +964,7 @@ private final class ResolvedTargetBuilder: ResolvedBuilder<ResolvedModule> {
             }
         }
 
-        return ResolvedTarget(
+        return ResolvedModule(
             packageIdentity: self.packageIdentity,
             underlying: self.target,
             dependencies: dependencies,
diff --git a/Sources/PackageGraph/ModulesGraph.swift b/Sources/PackageGraph/ModulesGraph.swift
index fdf206d84e5..1e5b0bb9690 100644
--- a/Sources/PackageGraph/ModulesGraph.swift
+++ b/Sources/PackageGraph/ModulesGraph.swift
@@ -92,17 +92,16 @@ public struct ModulesGraph {
     public let packages: [ResolvedPackage]
 
     /// The list of all targets reachable from root targets.
-    public let reachableTargets: IdentifiableSet<ResolvedModule>
+    public private(set) var reachableTargets: IdentifiableSet<ResolvedModule>
 
     /// The list of all products reachable from root targets.
-    public let reachableProducts: IdentifiableSet<ResolvedProduct>
+    public private(set) var reachableProducts: IdentifiableSet<ResolvedProduct>
 
     /// Returns all the targets in the graph, regardless if they are reachable from the root targets or not.
-    public let allTargets: IdentifiableSet<ResolvedModule>
+    public private(set) var allTargets: IdentifiableSet<ResolvedModule>
 
     /// Returns all the products in the graph, regardless if they are reachable from the root targets or not.
-
-    public let allProducts: IdentifiableSet<ResolvedProduct>
+    public private(set) var allProducts: IdentifiableSet<ResolvedProduct>
 
     /// Package dependencies required for a fully resolved graph.
     ///
@@ -113,10 +112,14 @@ public struct ModulesGraph {
     /// Returns true if a given target is present in root packages and is not excluded for the given build environment.
     public func isInRootPackages(_ target: ResolvedModule, satisfying buildEnvironment: BuildEnvironment) -> Bool {
         // FIXME: This can be easily cached.
-        return rootPackages.reduce(into: IdentifiableSet<ResolvedModule>()) { (accumulator: inout IdentifiableSet<ResolvedModule>, package: ResolvedPackage) in
+        return rootPackages.reduce(
+            into: IdentifiableSet<ResolvedModule>()
+        ) { (accumulator: inout IdentifiableSet<ResolvedModule>, package: ResolvedPackage) in
             let allDependencies = package.targets.flatMap { $0.dependencies }
             let unsatisfiedDependencies = allDependencies.filter { !$0.satisfies(buildEnvironment) }
-            let unsatisfiedDependencyTargets = unsatisfiedDependencies.compactMap { (dep: ResolvedModule.Dependency) -> ResolvedModule? in
+            let unsatisfiedDependencyTargets = unsatisfiedDependencies.compactMap { (
+                dep: ResolvedModule.Dependency
+            ) -> ResolvedModule? in
                 switch dep {
                 case .target(let target, _):
                     return target
@@ -134,14 +137,14 @@ public struct ModulesGraph {
         return self.rootPackages.contains(id: package.id)
     }
 
-    private let modulesToPackages: [ResolvedModule.ID: ResolvedPackage]
+    private var modulesToPackages: [ResolvedModule.ID: ResolvedPackage]
     /// Returns the package that contains the module, or nil if the module isn't in the graph.
     public func package(for module: ResolvedModule) -> ResolvedPackage? {
         return self.modulesToPackages[module.id]
     }
 
 
-    private let productsToPackages: [ResolvedProduct.ID: ResolvedPackage]
+    private var productsToPackages: [ResolvedProduct.ID: ResolvedPackage]
     /// Returns the package that contains the product, or nil if the product isn't in the graph.
     public func package(for product: ResolvedProduct) -> ResolvedPackage? {
         return self.productsToPackages[product.id]
@@ -165,44 +168,68 @@ public struct ModulesGraph {
         self.inputPackages = rootPackages + rootDependencies
         self.binaryArtifacts = binaryArtifacts
         self.packages = try topologicalSort(inputPackages, successors: { $0.dependencies })
+        let identitiesToPackages = self.packages.spm_createDictionary { ($0.identity, $0) }
 
         // Create a mapping from targets to the packages that define them.  Here
         // we include all targets, including tests in non-root packages, since
         // this is intended for lookup and not traversal.
-        self.modulesToPackages = packages.reduce(into: [:], { partial, package in
-            package.targets.forEach{ partial[$0.id] = package }
+        var modulesToPackages = self.packages.reduce(into: [:], { partial, package in
+            package.targets.forEach { partial[$0.id] = package }
+        })
+
+        // Create a mapping from products to the packages that define them.  Here
+        // we include all products, including tests in non-root packages, since
+        // this is intended for lookup and not traversal.
+        var productsToPackages = packages.reduce(into: [:], { partial, package in
+            package.products.forEach { partial[$0.id] = package }
         })
 
-        let allTargets = IdentifiableSet(packages.flatMap({ package -> [ResolvedModule] in
+        var allTargets = IdentifiableSet<ResolvedModule>()
+        var allProducts = IdentifiableSet<ResolvedProduct>()
+        for package in self.packages {
+            let targetsToInclude: [ResolvedModule]
             if rootPackages.contains(id: package.id) {
-                return package.targets
+                targetsToInclude = Array(package.targets)
             } else {
                 // Don't include tests targets from non-root packages so swift-test doesn't
                 // try to run them.
-                return package.targets.filter({ $0.type != .test })
+                targetsToInclude = package.targets.filter { $0.type != .test }
             }
-        }))
 
-        // Create a mapping from products to the packages that define them.  Here
-        // we include all products, including tests in non-root packages, since
-        // this is intended for lookup and not traversal.
-        self.productsToPackages = packages.reduce(into: [:], { partial, package in
-            package.products.forEach { partial[$0.id] = package }
-        })
+            for target in targetsToInclude {
+                allTargets.insert(target)
+
+                // Explicitly include dependencies of host tools in the maps of all targets or all products
+                if target.buildTriple == .tools {
+                    for dependency in try target.recursiveDependencies() {
+                        switch dependency {
+                        case .target(let targetDependency, _):
+                            allTargets.insert(targetDependency)
+                            modulesToPackages[targetDependency.id] = package
+                        case .product(let productDependency, _):
+                            allProducts.insert(productDependency)
+                            productsToPackages[productDependency.id] =
+                                identitiesToPackages[productDependency.packageIdentity]
+                        }
+                    }
+                }
+            }
 
-        let allProducts = IdentifiableSet(packages.flatMap({ package -> [ResolvedProduct] in
             if rootPackages.contains(id: package.id) {
-                return package.products
+                allProducts.formUnion(package.products)
             } else {
-                // Don't include tests products from non-root packages so swift-test doesn't
+                // Don't include test products from non-root packages so swift-test doesn't
                 // try to run them.
-                return package.products.filter({ $0.type != .test })
+                allProducts.formUnion(package.products.filter { $0.type != .test })
             }
-        }))
+        }
+
+        self.modulesToPackages = modulesToPackages
+        self.productsToPackages = productsToPackages
 
         // Compute the reachable targets and products.
-        let inputTargets = inputPackages.flatMap { $0.targets }
-        let inputProducts = inputPackages.flatMap { $0.products }
+        let inputTargets = self.inputPackages.flatMap { $0.targets }
+        let inputProducts = self.inputPackages.flatMap { $0.products }
         let recursiveDependencies = try inputTargets.lazy.flatMap { try $0.recursiveDependencies() }
 
         self.reachableTargets = IdentifiableSet(inputTargets).union(recursiveDependencies.compactMap { $0.target })
@@ -212,6 +239,41 @@ public struct ModulesGraph {
         self.allProducts = allProducts
     }
 
+    package mutating func updateBuildTripleRecursively(_ buildTriple: BuildTriple) throws {
+        self.reachableTargets = IdentifiableSet(self.reachableTargets.map {
+            var target = $0
+            target.buildTriple = buildTriple
+            return target
+        })
+        self.reachableProducts = IdentifiableSet(self.reachableProducts.map {
+            var product = $0
+            product.buildTriple = buildTriple
+            return product
+        })
+
+        self.allTargets = IdentifiableSet(self.allTargets.map {
+            var target = $0
+            target.buildTriple = buildTriple
+            return target
+        })
+        self.allProducts = IdentifiableSet(self.allProducts.map {
+            var product = $0
+            product.buildTriple = buildTriple
+            return product
+        })
+
+        self.modulesToPackages = .init(self.modulesToPackages.map {
+            var target = $0
+            target.buildTriple = buildTriple
+            return (target, $1)
+        }, uniquingKeysWith: { $1 })
+        self.productsToPackages = .init(self.productsToPackages.map {
+            var product = $0
+            product.buildTriple = buildTriple
+            return (product, $1)
+        }, uniquingKeysWith: { $1 })
+    }
+
     /// Computes a map from each executable target in any of the root packages to the corresponding test targets.
     @_spi(SwiftPMInternal)
     public func computeTestTargetsForExecutableTargets() throws -> [ResolvedModule.ID: [ResolvedModule]] {
diff --git a/Sources/PackageGraph/Resolution/ResolvedTarget.swift b/Sources/PackageGraph/Resolution/ResolvedModule.swift
similarity index 78%
rename from Sources/PackageGraph/Resolution/ResolvedTarget.swift
rename to Sources/PackageGraph/Resolution/ResolvedModule.swift
index b8854a8ba3b..f218a35886d 100644
--- a/Sources/PackageGraph/Resolution/ResolvedTarget.swift
+++ b/Sources/PackageGraph/Resolution/ResolvedModule.swift
@@ -136,7 +136,7 @@ public struct ResolvedModule {
     public let underlying: Target
 
     /// The dependencies of this target.
-    public let dependencies: [Dependency]
+    public internal(set) var dependencies: [Dependency]
 
     /// The default localization for resources.
     public let defaultLocalization: String?
@@ -147,7 +147,11 @@ public struct ResolvedModule {
     private let platformVersionProvider: PlatformVersionProvider
 
     /// Triple for which this resolved target should be compiled for.
-    public let buildTriple: BuildTriple
+    public package(set) var buildTriple: BuildTriple {
+        didSet {
+            self.updateBuildTriplesOfDependencies()
+        }
+    }
 
     /// Create a resolved target instance.
     public init(
@@ -164,7 +168,50 @@ public struct ResolvedModule {
         self.defaultLocalization = defaultLocalization
         self.supportedPlatforms = supportedPlatforms
         self.platformVersionProvider = platformVersionProvider
-        self.buildTriple = .destination
+
+        if underlying.type == .test {
+            // Make sure that test products are built for the tools triple if it has tools as direct dependencies.
+            // Without this workaround, `assertMacroExpansion` in tests can't be built, as it requires macros
+            // and SwiftSyntax to be built for the same triple as the tests.
+            // See https://github.com/apple/swift-package-manager/pull/7349 for more context.
+            var inferredBuildTriple = BuildTriple.destination
+            loop: for dependency in dependencies {
+                switch dependency {
+                case .target(let targetDependency, _):
+                    if targetDependency.type == .macro {
+                        inferredBuildTriple = .tools
+                        break loop
+                    }
+                case .product(let productDependency, _):
+                    if productDependency.type == .macro {
+                        inferredBuildTriple = .tools
+                        break loop      
+                    }
+                }
+            }
+            self.buildTriple = inferredBuildTriple
+        } else {
+            self.buildTriple = underlying.buildTriple
+        }
+        self.updateBuildTriplesOfDependencies()
+    }
+
+    mutating func updateBuildTriplesOfDependencies() {
+        if self.buildTriple == .tools {
+            for (i, dependency) in dependencies.enumerated() {
+                let updatedDependency: Dependency
+                switch dependency {
+                case .target(var target, let conditions):
+                    target.buildTriple = self.buildTriple
+                    updatedDependency = .target(target, conditions: conditions)
+                case .product(var product, let conditions):
+                    product.buildTriple = self.buildTriple
+                    updatedDependency = .product(product, conditions: conditions)
+                }
+
+                dependencies[i] = updatedDependency
+            }
+        }
     }
 
     public func getSupportedPlatform(for platform: Platform, usingXCTest: Bool) -> SupportedPlatform {
@@ -178,13 +225,13 @@ public struct ResolvedModule {
 
 extension ResolvedModule: CustomStringConvertible {
     public var description: String {
-        return "<ResolvedTarget: \(name)>"
+        return "<ResolvedModule: \(self.name), \(self.type), \(self.buildTriple)>"
     }
 }
 
 extension ResolvedModule.Dependency: CustomStringConvertible {
     public var description: String {
-        var str = "<ResolvedTarget.Dependency: "
+        var str = "<ResolvedModule.Dependency: "
         switch self {
         case .product(let p, _):
             str += p.description
@@ -250,7 +297,7 @@ extension ResolvedModule: Identifiable {
     public struct ID: Hashable {
         public let targetName: String
         let packageIdentity: PackageIdentity
-        public let buildTriple: BuildTriple
+        public var buildTriple: BuildTriple
     }
 
     public var id: ID {
diff --git a/Sources/PackageGraph/Resolution/ResolvedPackage.swift b/Sources/PackageGraph/Resolution/ResolvedPackage.swift
index f1e8f93fe26..5506bcc15b1 100644
--- a/Sources/PackageGraph/Resolution/ResolvedPackage.swift
+++ b/Sources/PackageGraph/Resolution/ResolvedPackage.swift
@@ -64,8 +64,8 @@ public struct ResolvedPackage {
         platformVersionProvider: PlatformVersionProvider
     ) {
         self.underlying = underlying
-        self.targets = targets
         self.products = products
+        self.targets = targets
         self.dependencies = dependencies
         self.defaultLocalization = defaultLocalization
         self.supportedPlatforms = supportedPlatforms
diff --git a/Sources/PackageGraph/Resolution/ResolvedProduct.swift b/Sources/PackageGraph/Resolution/ResolvedProduct.swift
index c03e20fffa2..3217ef8d9ea 100644
--- a/Sources/PackageGraph/Resolution/ResolvedProduct.swift
+++ b/Sources/PackageGraph/Resolution/ResolvedProduct.swift
@@ -30,7 +30,7 @@ public struct ResolvedProduct {
     public let underlying: Product
 
     /// The top level targets contained in this product.
-    public let targets: IdentifiableSet<ResolvedModule>
+    public internal(set) var targets: IdentifiableSet<ResolvedModule>
 
     /// Executable target for test entry point file.
     public let testEntryPointTarget: ResolvedModule?
@@ -44,7 +44,11 @@ public struct ResolvedProduct {
     public let platformVersionProvider: PlatformVersionProvider
 
     /// Triple for which this resolved product should be compiled for.
-    public let buildTriple: BuildTriple
+    public internal(set) var buildTriple: BuildTriple {
+        didSet {
+            self.updateBuildTriplesOfDependencies()
+        }
+    }
 
     /// The main executable target of product.
     ///
@@ -63,7 +67,11 @@ public struct ResolvedProduct {
         }
     }
 
-    public init(packageIdentity: PackageIdentity, product: Product, targets: IdentifiableSet<ResolvedModule>) {
+    public init(
+        packageIdentity: PackageIdentity,
+        product: Product,
+        targets: IdentifiableSet<ResolvedModule>
+    ) {
         assert(product.targets.count == targets.count && product.targets.map(\.name).sorted() == targets.map(\.name).sorted())
         self.packageIdentity = packageIdentity
         self.underlying = product
@@ -97,7 +105,41 @@ public struct ResolvedProduct {
             )
         }
         
-        self.buildTriple = .destination
+        if product.type == .test {
+            // Make sure that test products are built for the tools triple if it has tools as direct dependencies.
+            // Without this workaround, `assertMacroExpansion` in tests can't be built, as it requires macros
+            // and SwiftSyntax to be built for the same triple as the tests.
+            // See https://github.com/apple/swift-package-manager/pull/7349 for more context.
+            var inferredBuildTriple = BuildTriple.destination
+            targetsLoop: for target in targets {
+                for dependency in target.dependencies {
+                    switch dependency {
+                    case .target(let targetDependency, _):
+                        if targetDependency.type == .macro {
+                            inferredBuildTriple = .tools
+                            break targetsLoop
+                        }
+                    case .product(let productDependency, _):
+                        if productDependency.type == .macro {
+                            inferredBuildTriple = .tools
+                            break targetsLoop
+                        }
+                    }
+                }
+            }
+            self.buildTriple = inferredBuildTriple
+        } else {
+            self.buildTriple = product.buildTriple
+        }
+        self.updateBuildTriplesOfDependencies()
+    }
+
+    mutating func updateBuildTriplesOfDependencies() {
+        self.targets = IdentifiableSet(self.targets.map {
+            var target = $0
+            target.buildTriple = self.buildTriple
+            return target
+        })
     }
 
     /// True if this product contains Swift targets.
@@ -151,7 +193,7 @@ public struct ResolvedProduct {
 
 extension ResolvedProduct: CustomStringConvertible {
     public var description: String {
-        "<ResolvedProduct: \(self.name)>"
+        "<ResolvedProduct: \(self.name), \(self.type), \(self.buildTriple)>"
     }
 }
 
@@ -166,13 +208,13 @@ extension ResolvedProduct {
 extension ResolvedProduct: Identifiable {
     /// Resolved target identity that uniquely identifies it in a resolution graph.
     public struct ID: Hashable {
-        public let targetName: String
+        public let productName: String
         let packageIdentity: PackageIdentity
-        public let buildTriple: BuildTriple
+        public var buildTriple: BuildTriple
     }
 
     public var id: ID {
-        ID(targetName: self.name, packageIdentity: self.packageIdentity, buildTriple: self.buildTriple)
+        ID(productName: self.name, packageIdentity: self.packageIdentity, buildTriple: self.buildTriple)
     }
 }
 
diff --git a/Sources/PackageModel/Target/Target.swift b/Sources/PackageModel/Target/Target.swift
index 6ab22ca7b26..40bb1a575e9 100644
--- a/Sources/PackageModel/Target/Target.swift
+++ b/Sources/PackageModel/Target/Target.swift
@@ -131,7 +131,7 @@ public class Target: PolymorphicCodableProtocol {
     /// The name of the target.
     ///
     /// NOTE: This name is not the language-level target (i.e., the importable
-    /// name) name in many cases, instead use c99name if you need uniqueness.
+    /// name) name in many cases, instead use ``Target/c99name`` if you need uniqueness.
     public private(set) var name: String
 
     /// Module aliases needed to build this target. The key is an original name of a
diff --git a/Sources/SPMBuildCore/BuildParameters/BuildParameters.swift b/Sources/SPMBuildCore/BuildParameters/BuildParameters.swift
index e81e99e242f..02902339324 100644
--- a/Sources/SPMBuildCore/BuildParameters/BuildParameters.swift
+++ b/Sources/SPMBuildCore/BuildParameters/BuildParameters.swift
@@ -248,7 +248,7 @@ public struct BuildParameters: Encodable {
 
     /// Returns the path to the binary of a product for the current build parameters, relative to the build directory.
     public func binaryRelativePath(for product: ResolvedProduct) throws -> RelativePath {
-        let potentialExecutablePath = try RelativePath(validating: "\(product.name)\(self.triple.executableExtension)")
+        let potentialExecutablePath = try RelativePath(validating: "\(product.name)\(self.suffix(triple: product.buildTriple))\(self.triple.executableExtension)")
 
         switch product.type {
         case .executable, .snippet:
@@ -329,3 +329,11 @@ extension Triple {
         return !self.isWindows()
     }
 }
+
+extension BuildParameters {
+    /// Suffix appended to build manifest nodes to distinguish nodes created for tools from nodes created for
+    /// end products, i.e. nodes for host vs target triples.
+    package func suffix(triple: BuildTriple) -> String {
+        if triple == .tools { "-tool" } else { "" }
+    }
+}
diff --git a/Sources/SPMBuildCore/BuildSystem/BuildSystem.swift b/Sources/SPMBuildCore/BuildSystem/BuildSystem.swift
index f8281b25146..fc52987ce01 100644
--- a/Sources/SPMBuildCore/BuildSystem/BuildSystem.swift
+++ b/Sources/SPMBuildCore/BuildSystem/BuildSystem.swift
@@ -74,7 +74,7 @@ extension ProductBuildDescription {
     /// The path to the product binary produced.
     public var binaryPath: AbsolutePath {
         get throws {
-            return try self.buildParameters.binaryPath(for: product)
+            try self.buildParameters.binaryPath(for: product)
         }
     }
 }
diff --git a/Sources/SPMBuildCore/Plugins/PluginContextSerializer.swift b/Sources/SPMBuildCore/Plugins/PluginContextSerializer.swift
index 4352b35ffac..9edfb0a7bb4 100644
--- a/Sources/SPMBuildCore/Plugins/PluginContextSerializer.swift
+++ b/Sources/SPMBuildCore/Plugins/PluginContextSerializer.swift
@@ -55,7 +55,7 @@ internal struct PluginContextSerializer {
     // Adds a target to the serialized structure, if it isn't already there and
     // if it is of a kind that should be passed to the plugin. If so, this func-
     // tion returns the target's wire ID. If not, it returns nil.
-    mutating func serialize(target: ResolvedTarget) throws -> WireInput.Target.Id? {
+    mutating func serialize(target: ResolvedModule) throws -> WireInput.Target.Id? {
         // If we've already seen the target, just return the wire ID we already assigned to it.
         if let id = targetsToWireIDs[target.id] { return id }
 
diff --git a/Sources/SPMBuildCore/Plugins/PluginInvocation.swift b/Sources/SPMBuildCore/Plugins/PluginInvocation.swift
index 9fb03674540..fc832b07dc4 100644
--- a/Sources/SPMBuildCore/Plugins/PluginInvocation.swift
+++ b/Sources/SPMBuildCore/Plugins/PluginInvocation.swift
@@ -398,8 +398,8 @@ extension ModulesGraph {
         observabilityScope: ObservabilityScope,
         fileSystem: FileSystem,
         builtToolHandler: (_ name: String, _ path: RelativePath) throws -> AbsolutePath? = { _, _ in return nil }
-    ) throws -> [ResolvedTarget.ID: (target: ResolvedTarget, results: [BuildToolPluginInvocationResult])] {
-        var pluginResultsByTarget: [ResolvedTarget.ID: (target: ResolvedTarget, results: [BuildToolPluginInvocationResult])] = [:]
+    ) throws -> [ResolvedModule.ID: (target: ResolvedModule, results: [BuildToolPluginInvocationResult])] {
+        var pluginResultsByTarget: [ResolvedModule.ID: (target: ResolvedModule, results: [BuildToolPluginInvocationResult])] = [:]
         for target in self.allTargets.sorted(by: { $0.name < $1.name }) {
             // Infer plugins from the declared dependencies, and collect them as well as any regular dependencies. Although usage of build tool plugins is declared separately from dependencies in the manifest, in the internal model we currently consider both to be dependencies.
             var pluginTargets: [PluginTarget] = []
@@ -592,13 +592,15 @@ extension ModulesGraph {
             }
 
             // Associate the list of results with the target. The list will have one entry for each plugin used by the target.
-            pluginResultsByTarget[target.id] = (target, buildToolPluginResults)
+            var targetID = target.id
+            targetID.buildTriple = .destination
+            pluginResultsByTarget[targetID] = (target, buildToolPluginResults)
         }
         return pluginResultsByTarget
     }
 
     public static func computePluginGeneratedFiles(
-        target: ResolvedTarget,
+        target: ResolvedModule,
         toolsVersion: ToolsVersion,
         additionalFileRules: [FileRuleDescription],
         buildParameters: BuildParameters,
@@ -744,7 +746,7 @@ public struct BuildToolPluginInvocationResult {
     public var package: ResolvedPackage
 
     /// The target in that package to which the plugin was applied.
-    public var target: ResolvedTarget
+    public var target: ResolvedModule
 
     /// If the plugin finished successfully.
     public var succeeded: Bool
diff --git a/Sources/SPMTestSupport/MockArchiver.swift b/Sources/SPMTestSupport/MockArchiver.swift
index 209bf9bab00..cfc57d3f2d7 100644
--- a/Sources/SPMTestSupport/MockArchiver.swift
+++ b/Sources/SPMTestSupport/MockArchiver.swift
@@ -12,7 +12,7 @@
 
 import Basics
 
-package class MockArchiver: Archiver {
+package final class MockArchiver: Archiver {
     package typealias ExtractionHandler = (
         MockArchiver,
         AbsolutePath,
diff --git a/Sources/SPMTestSupport/MockBuildTestHelper.swift b/Sources/SPMTestSupport/MockBuildTestHelper.swift
index bce133aacdb..1b8824b928c 100644
--- a/Sources/SPMTestSupport/MockBuildTestHelper.swift
+++ b/Sources/SPMTestSupport/MockBuildTestHelper.swift
@@ -14,6 +14,8 @@ import Basics
 
 import Build
 
+import struct PackageGraph.ResolvedModule
+import struct PackageGraph.ResolvedProduct
 import PackageModel
 import SPMBuildCore
 import TSCUtility
@@ -74,14 +76,14 @@ package let defaultTargetTriple: String = hostTriple.tripleString
 #endif
 
 package func mockBuildParameters(
-    buildPath: AbsolutePath = "/path/to/build",
+    buildPath: AbsolutePath? = nil,
     config: BuildConfiguration = .debug,
     toolchain: PackageModel.Toolchain = MockToolchain(),
     flags: PackageModel.BuildFlags = PackageModel.BuildFlags(),
     shouldLinkStaticSwiftStdlib: Bool = false,
     shouldDisableLocalRpath: Bool = false,
     canRenameEntrypointFunctionName: Bool = false,
-    targetTriple: Basics.Triple = hostTriple,
+    triple: Basics.Triple = hostTriple,
     indexStoreMode: BuildParameters.IndexStoreMode = .off,
     useExplicitModuleBuild: Bool = false,
     linkerDeadStrip: Bool = true,
@@ -89,16 +91,16 @@ package func mockBuildParameters(
     omitFramePointers: Bool? = nil
 ) -> BuildParameters {
     try! BuildParameters(
-        dataPath: buildPath,
+        dataPath: buildPath ?? AbsolutePath("/path/to/build").appending(triple.tripleString),
         configuration: config,
         toolchain: toolchain,
-        triple: targetTriple,
+        triple: triple,
         flags: flags,
         pkgConfigDirectories: [],
         workers: 3,
         indexStoreMode: indexStoreMode,
         debuggingParameters: .init(
-            triple: targetTriple,
+            triple: triple,
             shouldEnableDebuggingEntitlement: config == .debug,
             omitFramePointers: omitFramePointers
         ),
@@ -130,7 +132,7 @@ package func mockBuildParameters(environment: BuildEnvironment) -> BuildParamete
         fatalError("unsupported platform in tests")
     }
 
-    return mockBuildParameters(config: environment.configuration ?? .debug, targetTriple: triple)
+    return mockBuildParameters(config: environment.configuration ?? .debug, triple: triple)
 }
 
 enum BuildError: Swift.Error {
@@ -139,15 +141,15 @@ enum BuildError: Swift.Error {
 
 package struct BuildPlanResult {
     package let plan: Build.BuildPlan
-    package let targetMap: [String: TargetBuildDescription]
-    package let productMap: [String: Build.ProductBuildDescription]
+    package let targetMap: [ResolvedModule.ID: TargetBuildDescription]
+    package let productMap: [ResolvedProduct.ID: Build.ProductBuildDescription]
 
     package init(plan: Build.BuildPlan) throws {
         self.plan = plan
         self.productMap = try Dictionary(
             throwingUniqueKeysWithValues: plan.buildProducts
                 .compactMap { $0 as? Build.ProductBuildDescription }
-                .map { ($0.product.name, $0) }
+                .map { ($0.product.id, $0) }
         )
         self.targetMap = try Dictionary(
             throwingUniqueKeysWithValues: plan.targetMap.compactMap {
@@ -157,7 +159,7 @@ package struct BuildPlanResult {
                 else {
                     throw BuildError.error("Target \($0) not found.")
                 }
-                return (target.name, $1)
+                return (target.id, $1)
             }
         )
     }
@@ -171,16 +173,26 @@ package struct BuildPlanResult {
     }
 
     package func target(for name: String) throws -> TargetBuildDescription {
-        guard let target = targetMap[name] else {
-            throw BuildError.error("Target \(name) not found.")
+        let matchingIDs = targetMap.keys.filter({ $0.targetName == name })
+        guard matchingIDs.count == 1, let target = targetMap[matchingIDs[0]] else {
+            if matchingIDs.isEmpty {
+                throw BuildError.error("Target \(name) not found.")
+            } else {
+                throw BuildError.error("More than one target \(name) found.")
+            }
         }
         return target
     }
 
     package func buildProduct(for name: String) throws -> Build.ProductBuildDescription {
-        guard let product = productMap[name] else {
-            // <rdar://problem/30162871> Display the thrown error on macOS
-            throw BuildError.error("Product \(name) not found.")
+        let matchingIDs = productMap.keys.filter({ $0.productName == name })
+        guard matchingIDs.count == 1, let product = productMap[matchingIDs[0]] else {
+            if matchingIDs.isEmpty {
+                // <rdar://problem/30162871> Display the thrown error on macOS
+                throw BuildError.error("Product \(name) not found.")
+            } else {
+                throw BuildError.error("More than one target \(name) found.")
+            }
         }
         return product
     }
diff --git a/Sources/SPMTestSupport/MockPackageGraphs.swift b/Sources/SPMTestSupport/MockPackageGraphs.swift
index 3f7b77ec353..1f3f956e23a 100644
--- a/Sources/SPMTestSupport/MockPackageGraphs.swift
+++ b/Sources/SPMTestSupport/MockPackageGraphs.swift
@@ -39,7 +39,7 @@ package func macrosPackageGraph() throws -> MockPackageGraph {
     )
 
     let observability = ObservabilitySystem.makeForTesting()
-    let graph = try loadPackageGraph(
+    let graph = try loadModulesGraph(
         fileSystem: fs,
         manifests: [
             Manifest.createRootManifest(
@@ -124,6 +124,135 @@ package func macrosPackageGraph() throws -> MockPackageGraph {
     return (graph, fs, observability.topScope)
 }
 
+package func macrosTestsPackageGraph() throws -> MockPackageGraph {
+    let fs = InMemoryFileSystem(emptyFiles:
+        "/swift-mmio/Sources/MMIO/source.swift",
+        "/swift-mmio/Sources/MMIOMacros/source.swift",
+        "/swift-mmio/Sources/MMIOMacrosTests/source.swift",
+        "/swift-syntax/Sources/SwiftSyntax/source.swift",
+        "/swift-syntax/Sources/SwiftSyntaxMacrosTestSupport/source.swift",
+        "/swift-syntax/Sources/SwiftSyntaxMacros/source.swift",
+        "/swift-syntax/Sources/SwiftCompilerPlugin/source.swift",
+        "/swift-syntax/Sources/SwiftCompilerPluginMessageHandling/source.swift",
+        "/swift-syntax/Tests/SwiftSyntaxTests/source.swift"
+    )
+
+    let observability = ObservabilitySystem.makeForTesting()
+    let graph = try loadModulesGraph(
+        fileSystem: fs,
+        manifests: [
+            Manifest.createRootManifest(
+                displayName: "swift-mmio",
+                path: "/swift-mmio",
+                dependencies: [
+                    .localSourceControl(
+                        path: "/swift-syntax",
+                        requirement: .upToNextMajor(from: "1.0.0")
+                    )
+                ],
+                products: [
+                    ProductDescription(
+                        name: "MMIO",
+                        type: .library(.automatic),
+                        targets: ["MMIO"]
+                    )
+                ],
+                targets: [
+                    TargetDescription(
+                        name: "MMIO",
+                        dependencies: [.target(name: "MMIOMacros")]
+                    ),
+                    TargetDescription(
+                        name: "MMIOMacros",
+                        dependencies: [
+                            .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+                            .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
+                        ],
+                        type: .macro
+                    ),
+                    TargetDescription(
+                        name: "MMIOMacrosTests",
+                        dependencies: [
+                            .target(name: "MMIOMacros"),
+                            .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax")
+                        ],
+                        type: .test
+                    )
+                ]
+            ),
+            Manifest.createFileSystemManifest(
+                displayName: "swift-syntax",
+                path: "/swift-syntax",
+                products: [
+                    ProductDescription(
+                        name: "SwiftSyntaxMacros",
+                        type: .library(.automatic),
+                        targets: ["SwiftSyntax"]
+                    ),
+                    ProductDescription(
+                        name: "SwiftSyntax",
+                        type: .library(.automatic),
+                        targets: ["SwiftSyntax"]
+                    ),
+                    ProductDescription(
+                        name: "SwiftSyntaxMacrosTestSupport",
+                        type: .library(.automatic),
+                        targets: ["SwiftSyntaxMacrosTestSupport"]
+                    ),
+                    ProductDescription(
+                        name: "SwiftCompilerPlugin",
+                        type: .library(.automatic),
+                        targets: ["SwiftCompilerPlugin"]
+                    ),
+                    ProductDescription(
+                        name: "SwiftCompilerPluginMessageHandling",
+                        type: .library(.automatic),
+                        targets: ["SwiftCompilerPluginMessageHandling"]
+                    ),
+                ],
+                targets: [
+                    TargetDescription(
+                        name: "SwiftSyntax",
+                        dependencies: []
+                    ),
+                    TargetDescription(
+                        name: "SwiftSyntaxMacros",
+                        dependencies: [.target(name: "SwiftSyntax")]
+                    ),
+                    TargetDescription(
+                        name: "SwiftCompilerPlugin",
+                        dependencies: [
+                            .target(name: "SwiftCompilerPluginMessageHandling"),
+                            .target(name: "SwiftSyntaxMacros"),
+                        ]
+                    ),
+                    TargetDescription(
+                        name: "SwiftCompilerPluginMessageHandling",
+                        dependencies: [
+                            .target(name: "SwiftSyntax"),
+                            .target(name: "SwiftSyntaxMacros"),
+                        ]
+                    ),
+                    TargetDescription(
+                        name: "SwiftSyntaxMacrosTestSupport",
+                        dependencies: [.target(name: "SwiftSyntax")]
+                    ),
+                    TargetDescription(
+                        name: "SwiftSyntaxTests",
+                        dependencies: ["SwiftSyntax"],
+                        type: .test
+                    ),
+                ]
+            ),
+        ],
+        observabilityScope: observability.topScope
+    )
+
+    XCTAssertNoDiagnostics(observability.diagnostics)
+
+    return (graph, fs, observability.topScope)
+}
+
 package func trivialPackageGraph(pkgRootPath: AbsolutePath) throws -> MockPackageGraph {
     let fs = InMemoryFileSystem(
         emptyFiles:
@@ -134,7 +263,7 @@ package func trivialPackageGraph(pkgRootPath: AbsolutePath) throws -> MockPackag
     )
 
     let observability = ObservabilitySystem.makeForTesting()
-    let graph = try loadPackageGraph(
+    let graph = try loadModulesGraph(
         fileSystem: fs,
         manifests: [
             Manifest.createRootManifest(
@@ -164,7 +293,7 @@ package func embeddedCxxInteropPackageGraph(pkgRootPath: AbsolutePath) throws ->
     )
 
     let observability = ObservabilitySystem.makeForTesting()
-    let graph = try loadPackageGraph(
+    let graph = try loadModulesGraph(
         fileSystem: fs,
         manifests: [
             Manifest.createRootManifest(
diff --git a/Sources/SPMTestSupport/PackageGraphTester.swift b/Sources/SPMTestSupport/PackageGraphTester.swift
index 7a40c5a6d3f..a45ee9d57ad 100644
--- a/Sources/SPMTestSupport/PackageGraphTester.swift
+++ b/Sources/SPMTestSupport/PackageGraphTester.swift
@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift open source project
 //
-// Copyright (c) 2014-2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014-2024 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See http://swift.org/LICENSE.txt for license information
@@ -17,8 +17,8 @@ import struct Basics.IdentifiableSet
 import PackageModel
 import PackageGraph
 
-package func PackageGraphTester(_ graph: ModulesGraph, _ result: (PackageGraphResult) -> Void) {
-    result(PackageGraphResult(graph))
+package func PackageGraphTester(_ graph: ModulesGraph, _ result: (PackageGraphResult) throws -> Void) rethrows {
+    try result(PackageGraphResult(graph))
 }
 
 package final class PackageGraphResult {
@@ -49,8 +49,8 @@ package final class PackageGraphResult {
     package func check(targets: String..., file: StaticString = #file, line: UInt = #line) {
         XCTAssertEqual(
             graph.allTargets
-                .filter{ $0.type != .test }
-                .map{ $0.name }
+                .filter { $0.type != .test }
+                .map { $0.name }
                 .sorted(), targets.sorted(), file: file, line: line)
     }
 
@@ -92,10 +92,24 @@ package final class PackageGraphResult {
         line: UInt = #line,
         body: (ResolvedTargetResult) -> Void
     ) {
-        guard let target = find(target: name) else {
+        let targets = find(target: name)
+
+        guard targets.count > 0 else {
             return XCTFail("Target \(name) not found", file: file, line: line)
         }
-        body(ResolvedTargetResult(target))
+        guard targets.count == 1 else {
+            return XCTFail("More than a single target with name \(name) found", file: file, line: line)
+        }
+        body(ResolvedTargetResult(targets[0]))
+    }
+
+    package func checkTargets(
+        _ name: String,
+        file: StaticString = #file,
+        line: UInt = #line,
+        body: ([ResolvedTargetResult]) throws -> Void
+    ) rethrows {
+        try body(graph.allTargets.filter { $0.name == name }.map(ResolvedTargetResult.init))
     }
 
     package func checkProduct(
@@ -104,10 +118,16 @@ package final class PackageGraphResult {
         line: UInt = #line,
         body: (ResolvedProductResult) -> Void
     ) {
-        guard let target = find(product: name) else {
+        let products = find(product: name)
+
+        guard products.count > 0 else {
             return XCTFail("Product \(name) not found", file: file, line: line)
         }
-        body(ResolvedProductResult(target))
+
+        guard products.count == 1 else {
+            return XCTFail("More than a single product with name \(name) found", file: file, line: line)
+        }
+        body(ResolvedProductResult(products[0]))
     }
 
     package func check(testModules: String..., file: StaticString = #file, line: UInt = #line) {
@@ -118,19 +138,19 @@ package final class PackageGraphResult {
                 .sorted(), testModules.sorted(), file: file, line: line)
     }
 
-    package func find(target: String) -> ResolvedTarget? {
-        return graph.allTargets.first(where: { $0.name == target })
+    package func find(target: String) -> [ResolvedModule] {
+        return graph.allTargets.filter { $0.name == target }
     }
 
-    package func find(product: String) -> ResolvedProduct? {
-        return graph.allProducts.first(where: { $0.name == product })
+    package func find(product: String) -> [ResolvedProduct] {
+        return graph.allProducts.filter { $0.name == product }
     }
 
     package func find(package: PackageIdentity) -> ResolvedPackage? {
         return graph.packages.first(where: { $0.identity == package })
     }
 
-    private func reachableBuildTargets(in environment: BuildEnvironment) throws -> IdentifiableSet<ResolvedTarget> {
+    private func reachableBuildTargets(in environment: BuildEnvironment) throws -> IdentifiableSet<ResolvedModule> {
         let inputTargets = graph.inputPackages.lazy.flatMap { $0.targets }
         let recursiveBuildTargetDependencies = try inputTargets
             .flatMap { try $0.recursiveDependencies(satisfying: environment) }
@@ -149,9 +169,9 @@ package final class PackageGraphResult {
 }
 
 package final class ResolvedTargetResult {
-    private let target: ResolvedTarget
+    let target: ResolvedModule
 
-    init(_ target: ResolvedTarget) {
+    init(_ target: ResolvedModule) {
         self.target = target
     }
 
@@ -159,6 +179,10 @@ package final class ResolvedTargetResult {
         XCTAssertEqual(Set(dependencies), Set(target.dependencies.map({ $0.name })), file: file, line: line)
     }
 
+    package func check(dependencies: [String], file: StaticString = #file, line: UInt = #line) {
+        XCTAssertEqual(Set(dependencies), Set(target.dependencies.map({ $0.name })), file: file, line: line)
+    }
+
     package func checkDependency(
         _ name: String,
         file: StaticString = #file,
@@ -176,7 +200,9 @@ package final class ResolvedTargetResult {
     }
 
     package func checkDeclaredPlatforms(_ platforms: [String: String], file: StaticString = #file, line: UInt = #line) {
-        let targetPlatforms = Dictionary(uniqueKeysWithValues: target.supportedPlatforms.map({ ($0.platform.name, $0.version.versionString) }))
+        let targetPlatforms = Dictionary(
+            uniqueKeysWithValues: target.supportedPlatforms.map { ($0.platform.name, $0.version.versionString) }
+        )
         XCTAssertEqual(platforms, targetPlatforms, file: file, line: line)
     }
 
@@ -187,22 +213,30 @@ package final class ResolvedTargetResult {
             return self.target.getSupportedPlatform(for: platform, usingXCTest: self.target.type == .test)
         }
         let targetPlatforms = Dictionary(
-            uniqueKeysWithValues: derived
-                .map { ($0.platform.name, $0.version.versionString) }
+            uniqueKeysWithValues: derived.map { ($0.platform.name, $0.version.versionString) }
         )
         XCTAssertEqual(platforms, targetPlatforms, file: file, line: line)
     }
 
-    package func checkDerivedPlatformOptions(_ platform: PackageModel.Platform, options: [String], file: StaticString = #file, line: UInt = #line) {
-        let platform = target.getSupportedPlatform(for: platform, usingXCTest: target.type == .test)
+    package func checkDerivedPlatformOptions(
+        _ platform: PackageModel.Platform,
+        options: [String],
+        file: StaticString = #file,
+        line: UInt = #line
+    ) {
+        let platform = self.target.getSupportedPlatform(for: platform, usingXCTest: target.type == .test)
         XCTAssertEqual(platform.options, options, file: file, line: line)
     }
+
+    public func check(buildTriple: BuildTriple, file: StaticString = #file, line: UInt = #line) {
+        XCTAssertEqual(self.target.buildTriple, buildTriple, file: file, line: line)
+    }
 }
 
 package final class ResolvedTargetDependencyResult {
-    private let dependency: ResolvedTarget.Dependency
+    private let dependency: ResolvedModule.Dependency
 
-    init(_ dependency: ResolvedTarget.Dependency) {
+    init(_ dependency: ResolvedModule.Dependency) {
         self.dependency = dependency
     }
 
@@ -217,6 +251,28 @@ package final class ResolvedTargetDependencyResult {
     ) {
         XCTAssert(!dependency.conditions.allSatisfy({ $0.satisfies(environment) }), file: file, line: line)
     }
+
+    public func checkTarget(
+        file: StaticString = #file,
+        line: UInt = #line,
+        body: (ResolvedTargetResult) -> Void
+    ) {
+        guard case let .target(target, _) = self.dependency else {
+            return XCTFail("Dependency \(dependency) is not a target", file: file, line: line)
+        }
+        body(ResolvedTargetResult(target))
+    }
+
+    public func checkProduct(
+        file: StaticString = #file,
+        line: UInt = #line,
+        body: (ResolvedProductResult) -> Void
+    ) {
+        guard case let .product(product, _) = self.dependency else {
+            return XCTFail("Dependency \(dependency) is not a product", file: file, line: line)
+        }
+        body(ResolvedProductResult(product))
+    }
 }
 
 package final class ResolvedProductResult {
@@ -252,9 +308,25 @@ package final class ResolvedProductResult {
         let platform = product.getSupportedPlatform(for: platform, usingXCTest: product.isLinkingXCTest)
         XCTAssertEqual(platform.options, options, file: file, line: line)
     }
+
+    public func check(buildTriple: BuildTriple, file: StaticString = #file, line: UInt = #line) {
+        XCTAssertEqual(self.product.buildTriple, buildTriple, file: file, line: line)
+    }
+
+    public func checkTarget(
+        _ name: String,
+        file: StaticString = #file,
+        line: UInt = #line,
+        body: (ResolvedTargetResult) -> Void
+    ) {
+        guard let target = product.targets.first(where: { $0.name == name }) else {
+            return XCTFail("Target \(name) not found", file: file, line: line)
+        }
+        body(ResolvedTargetResult(target))
+    }
 }
 
-extension ResolvedTarget.Dependency {
+extension ResolvedModule.Dependency {
     package var name: String {
         switch self {
         case .target(let target, _):
diff --git a/Sources/SPMTestSupport/ResolvedTarget+Mock.swift b/Sources/SPMTestSupport/ResolvedTarget+Mock.swift
index 6f109474acf..2a28903dd88 100644
--- a/Sources/SPMTestSupport/ResolvedTarget+Mock.swift
+++ b/Sources/SPMTestSupport/ResolvedTarget+Mock.swift
@@ -13,14 +13,14 @@
 import PackageGraph
 import PackageModel
 
-extension ResolvedTarget {
+extension ResolvedModule {
     package static func mock(
         packageIdentity: PackageIdentity,
         name: String,
-        deps: ResolvedTarget...,
+        deps: ResolvedModule...,
         conditions: [PackageCondition] = []
-    ) -> ResolvedTarget {
-        ResolvedTarget(
+    ) -> ResolvedModule {
+        ResolvedModule(
             packageIdentity: packageIdentity,
             underlying: SwiftTarget(
                 name: name,
diff --git a/Tests/BuildTests/BuildOperationTests.swift b/Tests/BuildTests/BuildOperationTests.swift
index 8574f12f198..21c40cafb5d 100644
--- a/Tests/BuildTests/BuildOperationTests.swift
+++ b/Tests/BuildTests/BuildOperationTests.swift
@@ -28,14 +28,16 @@ import class TSCBasic.InMemoryFileSystem
 
 final class BuildOperationTests: XCTestCase {
     func testDetectUnexpressedDependencies() throws {
+        let buildParameters = mockBuildParameters(shouldDisableLocalRpath: false)
+
         let fs = InMemoryFileSystem(files: [
-            "/path/to/build/debug/Lunch.build/Lunch.d" : "/Best.framework"
+            "\(buildParameters.dataPath)/debug/Lunch.build/Lunch.d" : "/Best.framework"
         ])
 
         let observability = ObservabilitySystem.makeForTesting()
         let buildOp = BuildOperation(
-            productsBuildParameters: mockBuildParameters(shouldDisableLocalRpath: false),
-            toolsBuildParameters: mockBuildParameters(shouldDisableLocalRpath: false),
+            productsBuildParameters: buildParameters,
+            toolsBuildParameters: buildParameters,
             cacheBuildManifest: false,
             packageGraphLoader: { fatalError() },
             additionalFileRules: [],
diff --git a/Tests/BuildTests/BuildPlanTests.swift b/Tests/BuildTests/BuildPlanTests.swift
index 0fbbab8b6c9..002e005b430 100644
--- a/Tests/BuildTests/BuildPlanTests.swift
+++ b/Tests/BuildTests/BuildPlanTests.swift
@@ -44,13 +44,13 @@ extension Build.BuildPlan {
         buildParameters: BuildParameters,
         graph: ModulesGraph,
         additionalFileRules: [FileRuleDescription] = [],
-        buildToolPluginInvocationResults: [ResolvedTarget.ID: [BuildToolPluginInvocationResult]] = [:],
-        prebuildCommandResults: [ResolvedTarget.ID: [PrebuildCommandResult]] = [:],
+        buildToolPluginInvocationResults: [ResolvedModule.ID: [BuildToolPluginInvocationResult]] = [:],
+        prebuildCommandResults: [ResolvedModule.ID: [PrebuildCommandResult]] = [:],
         fileSystem: any FileSystem,
         observabilityScope: ObservabilityScope
     ) throws {
         try self.init(
-            productsBuildParameters: buildParameters,
+            destinationBuildParameters: buildParameters,
             toolsBuildParameters: buildParameters,
             graph: graph,
             additionalFileRules: additionalFileRules,
@@ -923,7 +923,7 @@ final class BuildPlanTests: XCTestCase {
                         buildPath: buildDirPath,
                         config: .release,
                         toolchain: UserToolchain.default,
-                        targetTriple: UserToolchain.default.targetTriple,
+                        triple: UserToolchain.default.targetTriple,
                         useExplicitModuleBuild: true
                     ),
                     graph: graph,
@@ -1153,11 +1153,11 @@ final class BuildPlanTests: XCTestCase {
             observabilityScope: observability.topScope
         ))
 
-        XCTAssertEqual(Set(result.productMap.keys), ["APackageTests"])
+        XCTAssertEqual(Set(result.productMap.keys.map(\.productName)), ["APackageTests"])
         #if os(macOS)
-        XCTAssertEqual(Set(result.targetMap.keys), ["ATarget", "BTarget", "ATargetTests"])
+        XCTAssertEqual(Set(result.targetMap.keys.map(\.targetName)), ["ATarget", "BTarget", "ATargetTests"])
         #else
-        XCTAssertEqual(Set(result.targetMap.keys), [
+        XCTAssertEqual(Set(result.targetMap.keys.map(\.targetName)), [
             "APackageTests",
             "APackageDiscoveredTests",
             "ATarget",
@@ -1507,7 +1507,13 @@ final class BuildPlanTests: XCTestCase {
         ])
         #endif
 
-        let buildProduct = try XCTUnwrap(result.productMap["exe"])
+        let buildProduct = try XCTUnwrap(
+            result.productMap[.init(
+                productName: "exe",
+                packageIdentity: "Pkg",
+                buildTriple: .destination
+            )]
+        )
         XCTAssertEqual(Array(buildProduct.objects), [
             buildPath.appending(components: "exe.build", "main.c.o"),
             buildPath.appending(components: "extlib.build", "extlib.c.o"),
@@ -1751,8 +1757,9 @@ final class BuildPlanTests: XCTestCase {
         )
         XCTAssertNoDiagnostics(observability.diagnostics)
 
+        let buildParameters = mockBuildParameters()
         let plan = try BuildPlan(
-            buildParameters: mockBuildParameters(),
+            buildParameters: buildParameters,
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -1824,7 +1831,7 @@ final class BuildPlanTests: XCTestCase {
             "@\(buildPath.appending(components: "exe.product", "Objects.LinkFileList"))",
             "-Xlinker", "-rpath", "-Xlinker", "/fake/path/lib/swift-5.5/macosx",
             "-target", defaultTargetTriple,
-            "-Xlinker", "-add_ast_path", "-Xlinker", "/path/to/build/debug/exe.build/exe.swiftmodule",
+            "-Xlinker", "-add_ast_path", "-Xlinker", "/path/to/build/\(buildParameters.triple)/debug/exe.build/exe.swiftmodule",
             "-g",
         ])
         #elseif os(Windows)
@@ -1880,8 +1887,9 @@ final class BuildPlanTests: XCTestCase {
         )
         XCTAssertNoDiagnostics(observability.diagnostics)
 
+        let buildParameters = mockBuildParameters()
         let result = try BuildPlanResult(plan: BuildPlan(
-            buildParameters: mockBuildParameters(),
+            buildParameters: buildParameters,
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -1891,8 +1899,8 @@ final class BuildPlanTests: XCTestCase {
 
         let lib = try result.target(for: "lib").clangTarget()
         XCTAssertEqual(try lib.objects, [
-            AbsolutePath("/path/to/build/debug/lib.build/lib.S.o"),
-            AbsolutePath("/path/to/build/debug/lib.build/lib.c.o"),
+            AbsolutePath("/path/to/build/\(buildParameters.triple)/debug/lib.build/lib.S.o"),
+            AbsolutePath("/path/to/build/\(buildParameters.triple)/debug/lib.build/lib.c.o"),
         ])
     }
 
@@ -2610,7 +2618,7 @@ final class BuildPlanTests: XCTestCase {
 
         // Verify that `-lstdc++` is passed instead of `-lc++` when cross-compiling to Linux.
         result = try BuildPlanResult(plan: BuildPlan(
-            buildParameters: mockBuildParameters(targetTriple: .arm64Linux),
+            buildParameters: mockBuildParameters(triple: .arm64Linux),
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -3421,7 +3429,7 @@ final class BuildPlanTests: XCTestCase {
         XCTAssertNoDiagnostics(observability.diagnostics)
 
         let result = try BuildPlanResult(plan: BuildPlan(
-            buildParameters: mockBuildParameters(targetTriple: .windows),
+            buildParameters: mockBuildParameters(triple: .windows),
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -3505,7 +3513,7 @@ final class BuildPlanTests: XCTestCase {
             try BuildPlanResult(plan: BuildPlan(
                 buildParameters: mockBuildParameters(
                     canRenameEntrypointFunctionName: true,
-                    targetTriple: triple
+                    triple: triple
                 ),
                 graph: graph,
                 fileSystem: fs,
@@ -3702,7 +3710,7 @@ final class BuildPlanTests: XCTestCase {
         XCTAssertNoDiagnostics(observability.diagnostics)
 
         let result = try BuildPlanResult(plan: BuildPlan(
-            buildParameters: mockBuildParameters(targetTriple: .init("arm64-apple-ios")),
+            buildParameters: mockBuildParameters(triple: .init("arm64-apple-ios")),
             graph: graph,
             fileSystem: fileSystem,
             observabilityScope: observability.topScope
@@ -3779,7 +3787,7 @@ final class BuildPlanTests: XCTestCase {
         // constraints above are valid.
         XCTAssertNoThrow(
             _ = try BuildPlan(
-                buildParameters: mockBuildParameters(targetTriple: .arm64iOS),
+                buildParameters: mockBuildParameters(triple: .arm64iOS),
                 graph: graph,
                 fileSystem: fileSystem,
                 observabilityScope: observability.topScope
@@ -3789,7 +3797,7 @@ final class BuildPlanTests: XCTestCase {
         // For completeness, the invalid target should still throw an error.
         XCTAssertThrows(Diagnostics.fatalError) {
             _ = try BuildPlan(
-                buildParameters: mockBuildParameters(targetTriple: .x86_64MacOS),
+                buildParameters: mockBuildParameters(triple: .x86_64MacOS),
                 graph: graph,
                 fileSystem: fileSystem,
                 observabilityScope: observability.topScope
@@ -3852,7 +3860,7 @@ final class BuildPlanTests: XCTestCase {
 
         XCTAssertThrows(Diagnostics.fatalError) {
             _ = try BuildPlan(
-                buildParameters: mockBuildParameters(targetTriple: .x86_64MacOS),
+                buildParameters: mockBuildParameters(triple: .x86_64MacOS),
                 graph: graph,
                 fileSystem: fileSystem,
                 observabilityScope: observability.topScope
@@ -4018,7 +4026,7 @@ final class BuildPlanTests: XCTestCase {
 
         func createResult(for dest: Basics.Triple) throws -> BuildPlanResult {
             try BuildPlanResult(plan: BuildPlan(
-                buildParameters: mockBuildParameters(targetTriple: dest),
+                buildParameters: mockBuildParameters(triple: dest),
                 graph: graph,
                 fileSystem: fs,
                 observabilityScope: observability.topScope
@@ -4086,7 +4094,7 @@ final class BuildPlanTests: XCTestCase {
         do {
             let result = try BuildPlanResult(plan: BuildPlan(
                 buildParameters: mockBuildParameters(
-                    targetTriple: .x86_64Linux,
+                    triple: .x86_64Linux,
                     omitFramePointers: true
                 ),
                 graph: graph,
@@ -4143,7 +4151,7 @@ final class BuildPlanTests: XCTestCase {
         do {
             let result = try BuildPlanResult(plan: BuildPlan(
                 buildParameters: mockBuildParameters(
-                    targetTriple: .x86_64Linux,
+                    triple: .x86_64Linux,
                     omitFramePointers: false
                 ),
                 graph: graph,
@@ -4507,7 +4515,7 @@ final class BuildPlanTests: XCTestCase {
                 swiftCompilerFlags: [cliFlag(tool: .swiftCompiler)],
                 linkerFlags: [cliFlag(tool: .linker)]
             ),
-            targetTriple: targetTriple
+            triple: targetTriple
         )
         let result = try BuildPlanResult(plan: BuildPlan(
             buildParameters: buildParameters,
@@ -4792,8 +4800,9 @@ final class BuildPlanTests: XCTestCase {
         )
         XCTAssertNoDiagnostics(observability.diagnostics)
 
+        let buildParameters = mockBuildParameters()
         let plan = try BuildPlan(
-            buildParameters: mockBuildParameters(),
+            buildParameters: buildParameters,
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -4809,7 +4818,7 @@ final class BuildPlanTests: XCTestCase {
             [
                 .anySequence,
                 "-emit-objc-header",
-                "-emit-objc-header-path", "/path/to/build/debug/Foo.build/Foo-Swift.h",
+                "-emit-objc-header-path", "/path/to/build/\(buildParameters.triple)/debug/Foo.build/Foo-Swift.h",
                 .anySequence,
             ]
         )
@@ -4819,7 +4828,7 @@ final class BuildPlanTests: XCTestCase {
             [
                 .anySequence,
                 "-emit-objc-header",
-                "-emit-objc-header-path", "/path/to/build/debug/Foo.build/Foo-Swift.h",
+                "-emit-objc-header-path", "/path/to/build/\(buildParameters.triple)/Foo.build/Foo-Swift.h",
                 .anySequence,
             ]
         )
@@ -4829,12 +4838,12 @@ final class BuildPlanTests: XCTestCase {
         #if os(macOS)
         XCTAssertMatch(
             barTarget,
-            [.anySequence, "-fmodule-map-file=/path/to/build/debug/Foo.build/module.modulemap", .anySequence]
+            [.anySequence, "-fmodule-map-file=/path/to/build/\(buildParameters.triple)/debug/Foo.build/module.modulemap", .anySequence]
         )
         #else
         XCTAssertNoMatch(
             barTarget,
-            [.anySequence, "-fmodule-map-file=/path/to/build/debug/Foo.build/module.modulemap", .anySequence]
+            [.anySequence, "-fmodule-map-file=/path/to/build/\(buildParameters.triple)/debug/Foo.build/module.modulemap", .anySequence]
         )
         #endif
 
@@ -4892,8 +4901,9 @@ final class BuildPlanTests: XCTestCase {
         )
         XCTAssertNoDiagnostics(observability.diagnostics)
 
+        let buildParameters = mockBuildParameters()
         let plan = try BuildPlan(
-            buildParameters: mockBuildParameters(),
+            buildParameters: buildParameters,
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -4910,7 +4920,7 @@ final class BuildPlanTests: XCTestCase {
                 .anySequence,
                 "-emit-objc-header",
                 "-emit-objc-header-path",
-                "/path/to/build/debug/Foo.build/Foo-Swift.h",
+                "/path/to/build/\(buildParameters.triple)/debug/Foo.build/Foo-Swift.h",
                 .anySequence,
             ]
         )
@@ -4921,7 +4931,7 @@ final class BuildPlanTests: XCTestCase {
                 .anySequence,
                 "-emit-objc-header",
                 "-emit-objc-header-path",
-                "/path/to/build/debug/Foo.build/Foo-Swift.h",
+                "/path/to/build/\(buildParameters.triple)/debug/Foo.build/Foo-Swift.h",
                 .anySequence,
             ]
         )
@@ -4933,7 +4943,7 @@ final class BuildPlanTests: XCTestCase {
             barTarget,
             [
                 .anySequence,
-                "-fmodule-map-file=/path/to/build/debug/Foo.build/module.modulemap",
+                "-fmodule-map-file=/path/to/build/\(buildParameters.triple)/debug/Foo.build/module.modulemap",
                 .anySequence,
             ]
         )
@@ -4942,7 +4952,7 @@ final class BuildPlanTests: XCTestCase {
             barTarget,
             [
                 .anySequence,
-                "-fmodule-map-file=/path/to/build/debug/Foo.build/module.modulemap",
+                "-fmodule-map-file=/path/to/build/\(buildParameters.triple)/debug/Foo.build/module.modulemap",
                 .anySequence,
             ]
         )
@@ -5002,8 +5012,9 @@ final class BuildPlanTests: XCTestCase {
         )
         XCTAssertNoDiagnostics(observability.diagnostics)
 
+        let buildParameters = mockBuildParameters()
         let plan = try BuildPlan(
-            buildParameters: mockBuildParameters(),
+            buildParameters: buildParameters,
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -5024,7 +5035,7 @@ final class BuildPlanTests: XCTestCase {
                 .anySequence,
                 "-emit-objc-header",
                 "-emit-objc-header-path",
-                "/path/to/build/debug/Foo.build/Foo-Swift.h",
+                "/path/to/build/\(buildParameters.triple)/debug/Foo.build/Foo-Swift.h",
                 .anySequence,
             ]
         )
@@ -5035,7 +5046,7 @@ final class BuildPlanTests: XCTestCase {
                 .anySequence,
                 "-emit-objc-header",
                 "-emit-objc-header-path",
-                "/path/to/build/debug/Foo.build/Foo-Swift.h",
+                "/path/to/build/\(buildParameters.triple)/debug/Foo.build/Foo-Swift.h",
                 .anySequence,
             ]
         )
@@ -5047,7 +5058,7 @@ final class BuildPlanTests: XCTestCase {
             barTarget,
             [
                 .anySequence,
-                "-fmodule-map-file=/path/to/build/debug/Foo.build/module.modulemap",
+                "-fmodule-map-file=/path/to/build/\(buildParameters.triple)/debug/Foo.build/module.modulemap",
                 .anySequence,
             ]
         )
@@ -5056,7 +5067,7 @@ final class BuildPlanTests: XCTestCase {
             barTarget,
             [
                 .anySequence,
-                "-fmodule-map-file=/path/to/build/debug/Foo.build/module.modulemap",
+                "-fmodule-map-file=/path/to/build/\(buildParameters.triple)/debug/Foo.build/module.modulemap",
                 .anySequence,
             ]
         )
@@ -5106,7 +5117,7 @@ final class BuildPlanTests: XCTestCase {
         XCTAssertNoDiagnostics(observability.diagnostics)
 
         let result = try BuildPlanResult(plan: BuildPlan(
-            buildParameters: mockBuildParameters(targetTriple: .x86_64Linux),
+            buildParameters: mockBuildParameters(triple: .x86_64Linux),
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -5410,7 +5421,7 @@ final class BuildPlanTests: XCTestCase {
         XCTAssertNoDiagnostics(observability.diagnostics)
 
         let plan = try BuildPlan(
-            buildParameters: mockBuildParameters(targetTriple: .wasi),
+            buildParameters: mockBuildParameters(triple: .wasi),
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -5543,7 +5554,7 @@ final class BuildPlanTests: XCTestCase {
         let supportingTriples: [Basics.Triple] = [.x86_64Linux, .arm64Linux, .wasi]
         for triple in supportingTriples {
             let result = try BuildPlanResult(plan: BuildPlan(
-                buildParameters: mockBuildParameters(shouldLinkStaticSwiftStdlib: true, targetTriple: triple),
+                buildParameters: mockBuildParameters(shouldLinkStaticSwiftStdlib: true, triple: triple),
                 graph: graph,
                 fileSystem: fs,
                 observabilityScope: observability.topScope
@@ -5668,7 +5679,7 @@ final class BuildPlanTests: XCTestCase {
         XCTAssertNoDiagnostics(observability.diagnostics)
 
         let result = try BuildPlanResult(plan: BuildPlan(
-            buildParameters: mockBuildParameters(targetTriple: targetTriple),
+            buildParameters: mockBuildParameters(triple: targetTriple),
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -5797,7 +5808,7 @@ final class BuildPlanTests: XCTestCase {
 
         XCTAssertNoDiagnostics(observability.diagnostics)
         let result = try BuildPlanResult(plan: BuildPlan(
-            buildParameters: mockBuildParameters(targetTriple: targetTriple),
+            buildParameters: mockBuildParameters(triple: targetTriple),
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -6070,7 +6081,13 @@ final class BuildPlanTests: XCTestCase {
             observabilityScope: observability.topScope
         ))
 
-        switch try XCTUnwrap(result.targetMap["ExtLib"]) {
+        switch try XCTUnwrap(
+            result.targetMap[.init(
+                targetName: "ExtLib",
+                packageIdentity: "ExtPkg",
+                buildTriple: .destination
+            )]
+        ) {
         case .swift(let swiftTarget):
             if #available(macOS 13, *) { // `.contains` is only available in macOS 13 or newer
                 XCTAssertTrue(try swiftTarget.compileArguments().contains(["-user-module-version", "1.0.0"]))
@@ -6228,7 +6245,13 @@ final class BuildPlanTests: XCTestCase {
         result.checkTargetsCount(3)
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "FooLogging" })
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "BarLogging" })
-        let buildProduct = try XCTUnwrap(result.productMap["exe"])
+        let buildProduct = try XCTUnwrap(
+            result.productMap[.init(
+                productName: "exe",
+                packageIdentity: "thisPkg",
+                buildTriple: .destination
+            )]
+        )
         let dylibs = Array(buildProduct.dylibs.map({$0.product.name})).sorted()
         XCTAssertEqual(dylibs, ["BarLogging", "FooLogging"])
     }
diff --git a/Tests/BuildTests/ClangTargetBuildDescriptionTests.swift b/Tests/BuildTests/ClangTargetBuildDescriptionTests.swift
index 6a80831300c..f8361e473df 100644
--- a/Tests/BuildTests/ClangTargetBuildDescriptionTests.swift
+++ b/Tests/BuildTests/ClangTargetBuildDescriptionTests.swift
@@ -28,9 +28,9 @@ final class ClangTargetBuildDescriptionTests: XCTestCase {
     func testSwiftCorelibsFoundationIncludeWorkaround() throws {
         let toolchain = MockToolchain(swiftResourcesPath: AbsolutePath("/fake/path/lib/swift"))
 
-        let macosParameters = mockBuildParameters(toolchain: toolchain, targetTriple: .macOS)
-        let linuxParameters = mockBuildParameters(toolchain: toolchain, targetTriple: .arm64Linux)
-        let androidParameters = mockBuildParameters(toolchain: toolchain, targetTriple: .arm64Android)
+        let macosParameters = mockBuildParameters(toolchain: toolchain, triple: .macOS)
+        let linuxParameters = mockBuildParameters(toolchain: toolchain, triple: .arm64Linux)
+        let androidParameters = mockBuildParameters(toolchain: toolchain, triple: .arm64Android)
 
         let macDescription = try makeTargetBuildDescription("swift-corelibs-foundation",
                                                             buildParameters: macosParameters)
@@ -65,8 +65,8 @@ final class ClangTargetBuildDescriptionTests: XCTestCase {
         )
     }
 
-    private func makeResolvedTarget() throws -> ResolvedTarget {
-        ResolvedTarget(
+    private func makeResolvedTarget() throws -> ResolvedModule {
+        ResolvedModule(
             packageIdentity: .plain("dummy"),
             underlying: try makeClangTarget(),
             dependencies: [],
diff --git a/Tests/BuildTests/CrossCompilationBuildPlanTests.swift b/Tests/BuildTests/CrossCompilationBuildPlanTests.swift
index 65ac52d9076..4ac13002143 100644
--- a/Tests/BuildTests/CrossCompilationBuildPlanTests.swift
+++ b/Tests/BuildTests/CrossCompilationBuildPlanTests.swift
@@ -14,18 +14,18 @@ import struct Basics.AbsolutePath
 import class Basics.ObservabilitySystem
 import class Build.BuildPlan
 import class Build.ProductBuildDescription
+import enum Build.TargetBuildDescription
 import class Build.SwiftTargetBuildDescription
 import struct Basics.Triple
+import enum PackageGraph.BuildTriple
 import class PackageModel.Manifest
 import struct PackageModel.TargetDescription
 import func SPMTestSupport.loadPackageGraph
 
 import func SPMTestSupport.embeddedCxxInteropPackageGraph
-
 import func SPMTestSupport.macrosPackageGraph
-
+import func SPMTestSupport.macrosTestsPackageGraph
 import func SPMTestSupport.mockBuildParameters
-
 import func SPMTestSupport.trivialPackageGraph
 
 import struct SPMTestSupport.BuildPlanResult
@@ -40,7 +40,7 @@ final class CrossCompilationBuildPlanTests: XCTestCase {
         var (graph, fs, observabilityScope) = try trivialPackageGraph(pkgRootPath: "/Pkg")
 
         let triple = try Triple("wasm32-unknown-none-wasm")
-        var parameters = mockBuildParameters(targetTriple: triple)
+        var parameters = mockBuildParameters(triple: triple)
         parameters.linkingParameters.shouldLinkStaticSwiftStdlib = true
         var result = try BuildPlanResult(plan: BuildPlan(
             buildParameters: parameters,
@@ -103,7 +103,7 @@ final class CrossCompilationBuildPlanTests: XCTestCase {
         let (graph, fs, observabilityScope) = try trivialPackageGraph(pkgRootPath: pkgPath)
 
         var parameters = mockBuildParameters(
-            config: .release, targetTriple: .wasi, linkerDeadStrip: true
+            config: .release, triple: .wasi, linkerDeadStrip: true
         )
         parameters.linkingParameters.shouldLinkStaticSwiftStdlib = true
         let result = try BuildPlanResult(plan: BuildPlan(
@@ -135,7 +135,7 @@ final class CrossCompilationBuildPlanTests: XCTestCase {
 
         let (graph, fs, observabilityScope) = try trivialPackageGraph(pkgRootPath: pkgPath)
 
-        var parameters = mockBuildParameters(targetTriple: .wasi)
+        var parameters = mockBuildParameters(triple: .wasi)
         parameters.linkingParameters.shouldLinkStaticSwiftStdlib = true
         let result = try BuildPlanResult(plan: BuildPlan(
             buildParameters: parameters,
@@ -150,7 +150,12 @@ final class CrossCompilationBuildPlanTests: XCTestCase {
 
         let buildPath = result.plan.productsBuildPath
 
-        let lib = try result.target(for: "lib").clangTarget()
+        let lib = try XCTUnwrap(
+            result.allTargets(named: "lib")
+                .map { try $0.clangTarget() }
+                .first { $0.target.buildTriple == .destination }
+        )
+
         XCTAssertEqual(try lib.basicArguments(isCXX: false), [
             "-target", "wasm32-unknown-wasi",
             "-O0", "-DSWIFT_PACKAGE=1", "-DDEBUG=1",
@@ -209,4 +214,130 @@ final class CrossCompilationBuildPlanTests: XCTestCase {
         let testPathExtension = try testBuildDescription.binaryPath.extension
         XCTAssertEqual(testPathExtension, "wasm")
     }
+
+    func testMacros() throws {
+        let (graph, fs, scope) = try macrosPackageGraph()
+
+        let destinationTriple = Triple.arm64Linux
+        let toolsTriple = Triple.x86_64MacOS
+        let plan = try BuildPlan(
+            destinationBuildParameters: mockBuildParameters(shouldLinkStaticSwiftStdlib: true, triple: destinationTriple),
+            toolsBuildParameters: mockBuildParameters(triple: toolsTriple),
+            graph: graph,
+            fileSystem: fs,
+            observabilityScope: scope
+        )
+        let result = try BuildPlanResult(plan: plan)
+        result.checkProductsCount(3)
+        result.checkTargetsCount(10)
+
+        XCTAssertTrue(try result.allTargets(named: "SwiftSyntax")
+            .map { try $0.swiftTarget() }
+            .contains { $0.target.buildTriple == .tools })
+        try result.check(buildTriple: .tools, triple: toolsTriple, for: "MMIOMacros")
+        try result.check(buildTriple: .destination, triple: destinationTriple, for: "MMIO")
+        try result.check(buildTriple: .destination, triple: destinationTriple, for: "Core")
+        try result.check(buildTriple: .destination, triple: destinationTriple, for: "HAL")
+
+        let macroProducts = result.allProducts(named: "MMIOMacros")
+        XCTAssertEqual(macroProducts.count, 1)
+        let macroProduct = try XCTUnwrap(macroProducts.first)
+        XCTAssertEqual(macroProduct.buildParameters.triple, toolsTriple)
+
+        let mmioTargets = try result.allTargets(named: "MMIO").map { try $0.swiftTarget() }
+        XCTAssertEqual(mmioTargets.count, 1)
+        let mmioTarget = try XCTUnwrap(mmioTargets.first)
+        let compileArguments = try mmioTarget.emitCommandLine()
+        XCTAssertMatch(
+            compileArguments,
+            [
+                "-I", .equal(mmioTarget.moduleOutputPath.parentDirectory.pathString),
+                .anySequence,
+                "-Xfrontend", "-load-plugin-executable",
+                // Verify that macros are located in the tools triple directory.
+                "-Xfrontend", .contains(toolsTriple.tripleString)
+            ]
+        )
+    }
+
+    func testMacrosTests() throws {
+        let (graph, fs, scope) = try macrosTestsPackageGraph()
+
+        let destinationTriple = Triple.arm64Linux
+        let toolsTriple = Triple.x86_64MacOS
+        let plan = try BuildPlan(
+            destinationBuildParameters: mockBuildParameters(shouldLinkStaticSwiftStdlib: true, triple: destinationTriple),
+            toolsBuildParameters: mockBuildParameters(triple: toolsTriple),
+            graph: graph,
+            fileSystem: fs,
+            observabilityScope: scope
+        )
+        let result = try BuildPlanResult(plan: plan)
+        result.checkProductsCount(2)
+        result.checkTargetsCount(15)
+
+        XCTAssertTrue(try result.allTargets(named: "SwiftSyntax")
+            .map { try $0.swiftTarget() }
+            .contains { $0.target.buildTriple == .tools })
+
+        try result.check(buildTriple: .tools, triple: toolsTriple, for: "swift-mmioPackageTests")
+        try result.check(buildTriple: .tools, triple: toolsTriple, for: "swift-mmioPackageDiscoveredTests")
+        try result.check(buildTriple: .tools, triple: toolsTriple, for: "MMIOMacros")
+        try result.check(buildTriple: .destination, triple: destinationTriple, for: "MMIO")
+        try result.check(buildTriple: .tools, triple: toolsTriple, for: "MMIOMacrosTests")
+
+        let macroProducts = result.allProducts(named: "MMIOMacros")
+        XCTAssertEqual(macroProducts.count, 1)
+        let macroProduct = try XCTUnwrap(macroProducts.first)
+        XCTAssertEqual(macroProduct.buildParameters.triple, toolsTriple)
+
+        let mmioTargets = try result.allTargets(named: "MMIO").map { try $0.swiftTarget() }
+        XCTAssertEqual(mmioTargets.count, 1)
+        let mmioTarget = try XCTUnwrap(mmioTargets.first)
+        let compileArguments = try mmioTarget.emitCommandLine()
+        XCTAssertMatch(
+            compileArguments,
+            [
+                "-I", .equal(mmioTarget.moduleOutputPath.parentDirectory.pathString),
+                .anySequence,
+                "-Xfrontend", "-load-plugin-executable",
+                // Verify that macros are located in the tools triple directory.
+                "-Xfrontend", .contains(toolsTriple.tripleString)
+            ]
+        )
+    }
+}
+
+extension BuildPlanResult {
+    func allTargets(named name: String) throws -> some Collection<TargetBuildDescription> {
+        self.targetMap
+            .filter { $0.0.targetName == name }
+            .values
+    }
+
+    func allProducts(named name: String) -> some Collection<ProductBuildDescription> {
+        self.productMap
+            .filter { $0.0.productName == name }
+            .values
+    }
+
+    func check(
+        buildTriple: BuildTriple,
+        triple: Triple,
+        for target: String,
+        file: StaticString = #file,
+        line: UInt = #line
+    ) throws {
+        let targets = self.targetMap.filter {
+            $0.key.targetName == target && $0.key.buildTriple == buildTriple
+        }
+        XCTAssertEqual(targets.count, 1, file: file, line: line)
+
+        let target = try XCTUnwrap(
+            targets.first?.value,
+            file: file,
+            line: line
+        ).swiftTarget()
+        XCTAssertMatch(try target.emitCommandLine(), [.contains(triple.tripleString)], file: file, line: line)
+    }
 }
diff --git a/Tests/BuildTests/LLBuildManifestBuilderTests.swift b/Tests/BuildTests/LLBuildManifestBuilderTests.swift
index c9119b0a919..69fd9b181ee 100644
--- a/Tests/BuildTests/LLBuildManifestBuilderTests.swift
+++ b/Tests/BuildTests/LLBuildManifestBuilderTests.swift
@@ -52,7 +52,7 @@ final class LLBuildManifestBuilderTests: XCTestCase {
             configuration: .release
         ))
         var plan = try BuildPlan(
-            productsBuildParameters: buildParameters,
+            destinationBuildParameters: buildParameters,
             toolsBuildParameters: buildParameters,
             graph: graph,
             fileSystem: fs,
@@ -69,8 +69,8 @@ final class LLBuildManifestBuilderTests: XCTestCase {
         )
         try llbuild.createProductCommand(buildProduct)
 
-        let basicReleaseCommandNames = [
-            AbsolutePath("/path/to/build/release/exe.product/Objects.LinkFileList").pathString,
+        var basicReleaseCommandNames = [
+            AbsolutePath("/path/to/build/\(buildParameters.triple)/release/exe.product/Objects.LinkFileList").pathString,
             "<exe-release.exe>",
             "C.exe-release.exe",
         ]
@@ -87,7 +87,7 @@ final class LLBuildManifestBuilderTests: XCTestCase {
             configuration: .debug
         ))
         plan = try BuildPlan(
-            productsBuildParameters: buildParameters,
+            destinationBuildParameters: buildParameters,
             toolsBuildParameters: buildParameters,
             graph: graph,
             fileSystem: fs,
@@ -97,12 +97,12 @@ final class LLBuildManifestBuilderTests: XCTestCase {
         result = try BuildPlanResult(plan: plan)
         buildProduct = try result.buildProduct(for: "exe")
 
-        llbuild = LLBuildManifestBuilder(plan, fileSystem: localFileSystem, observabilityScope: observability.topScope)
+        llbuild = LLBuildManifestBuilder(plan, fileSystem: fs, observabilityScope: observability.topScope)
         try llbuild.createProductCommand(buildProduct)
 
         let entitlementsCommandName = "C.exe-debug.exe-entitlements"
-        let basicDebugCommandNames = [
-            AbsolutePath("/path/to/build/debug/exe.product/Objects.LinkFileList").pathString,
+        var basicDebugCommandNames = [
+            AbsolutePath("/path/to/build/\(buildParameters.triple)/debug/exe.product/Objects.LinkFileList").pathString,
             "<exe-debug.exe>",
             "C.exe-debug.exe",
         ]
@@ -110,7 +110,7 @@ final class LLBuildManifestBuilderTests: XCTestCase {
         XCTAssertEqual(
             llbuild.manifest.commands.map(\.key).sorted(),
             (basicDebugCommandNames + [
-                AbsolutePath("/path/to/build/debug/exe-entitlement.plist").pathString,
+                AbsolutePath("/path/to/build/\(buildParameters.triple)/debug/exe-entitlement.plist").pathString,
                 entitlementsCommandName,
             ]).sorted()
         )
@@ -123,8 +123,8 @@ final class LLBuildManifestBuilderTests: XCTestCase {
         XCTAssertEqual(
             entitlementsCommand.inputs,
             [
-                .file("/path/to/build/debug/exe", isMutated: true),
-                .file("/path/to/build/debug/exe-entitlement.plist"),
+                .file("/path/to/build/\(buildParameters.triple)/debug/exe", isMutated: true),
+                .file("/path/to/build/\(buildParameters.triple)/debug/exe-entitlement.plist"),
             ]
         )
         XCTAssertEqual(
@@ -141,7 +141,7 @@ final class LLBuildManifestBuilderTests: XCTestCase {
             configuration: .release
         ))
         plan = try BuildPlan(
-            productsBuildParameters: buildParameters,
+            destinationBuildParameters: buildParameters,
             toolsBuildParameters: buildParameters,
             graph: graph,
             fileSystem: fs,
@@ -154,6 +154,12 @@ final class LLBuildManifestBuilderTests: XCTestCase {
         llbuild = LLBuildManifestBuilder(plan, fileSystem: localFileSystem, observabilityScope: observability.topScope)
         try llbuild.createProductCommand(buildProduct)
 
+        basicReleaseCommandNames = [
+            AbsolutePath("/path/to/build/\(buildParameters.triple)/release/exe.product/Objects.LinkFileList").pathString,
+            "<exe-release.exe>",
+            "C.exe-release.exe",
+        ]
+
         XCTAssertEqual(
             llbuild.manifest.commands.map(\.key).sorted(),
             basicReleaseCommandNames.sorted()
@@ -166,7 +172,7 @@ final class LLBuildManifestBuilderTests: XCTestCase {
             configuration: .debug
         ))
         plan = try BuildPlan(
-            productsBuildParameters: buildParameters,
+            destinationBuildParameters: buildParameters,
             toolsBuildParameters: buildParameters,
             graph: graph,
             fileSystem: fs,
@@ -176,12 +182,38 @@ final class LLBuildManifestBuilderTests: XCTestCase {
         result = try BuildPlanResult(plan: plan)
         buildProduct = try result.buildProduct(for: "exe")
 
-        llbuild = LLBuildManifestBuilder(plan, fileSystem: localFileSystem, observabilityScope: observability.topScope)
+        llbuild = LLBuildManifestBuilder(plan, fileSystem: fs, observabilityScope: observability.topScope)
         try llbuild.createProductCommand(buildProduct)
 
+        basicDebugCommandNames = [
+            AbsolutePath("/path/to/build/\(buildParameters.triple)/debug/exe.product/Objects.LinkFileList").pathString,
+            "<exe-debug.exe>",
+            "C.exe-debug.exe",
+        ]
+
         XCTAssertEqual(
             llbuild.manifest.commands.map(\.key).sorted(),
             basicDebugCommandNames.sorted()
         )
     }
+    
+    /// Verifies that two targets with the same name but different triples don't share same build manifest keys.
+    func testToolsBuildTriple() throws {
+        let (graph, fs, scope) = try macrosPackageGraph()
+        let productsTriple = Triple.x86_64MacOS
+        let toolsTriple = Triple.arm64Linux
+
+        let plan = try BuildPlan(
+            destinationBuildParameters: mockBuildParameters(shouldLinkStaticSwiftStdlib: true, triple: productsTriple),
+            toolsBuildParameters: mockBuildParameters(triple: toolsTriple),
+            graph: graph,
+            fileSystem: fs,
+            observabilityScope: scope
+        )
+
+        let builder = LLBuildManifestBuilder(plan, fileSystem: fs, observabilityScope: scope)
+        let manifest = try builder.generateManifest(at: "/manifest")
+
+        XCTAssertNotNil(manifest.commands["C.SwiftSyntax-debug-tool.module"])
+    }
 }
diff --git a/Tests/BuildTests/ModuleAliasingBuildTests.swift b/Tests/BuildTests/ModuleAliasingBuildTests.swift
index 23244d40a5a..6fb0b8d5d01 100644
--- a/Tests/BuildTests/ModuleAliasingBuildTests.swift
+++ b/Tests/BuildTests/ModuleAliasingBuildTests.swift
@@ -694,8 +694,9 @@ final class ModuleAliasingBuildTests: XCTestCase {
 
         XCTAssertNoDiagnostics(observability.diagnostics)
 
+        let buildParameters = mockBuildParameters(shouldLinkStaticSwiftStdlib: true)
         let result = try BuildPlanResult(plan: try BuildPlan(
-            buildParameters: mockBuildParameters(shouldLinkStaticSwiftStdlib: true),
+            buildParameters: buildParameters,
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -724,33 +725,33 @@ final class ModuleAliasingBuildTests: XCTestCase {
         XCTAssertMatch(
             fooLoggingArgs,
             [.anySequence, "-emit-objc-header", "-emit-objc-header-path",
-             "/path/to/build/debug/FooLogging.build/FooLogging-Swift.h", .anySequence]
+             "/path/to/build/\(buildParameters.triple)/debug/FooLogging.build/FooLogging-Swift.h", .anySequence]
         )
         XCTAssertMatch(
             barLoggingArgs,
             [.anySequence, "-emit-objc-header", "-emit-objc-header-path",
-             "/path/to/build/debug/BarLogging.build/BarLogging-Swift.h", .anySequence]
+             "/path/to/build/\(buildParameters.triple)/debug/BarLogging.build/BarLogging-Swift.h", .anySequence]
         )
         XCTAssertMatch(
             loggingArgs,
             [.anySequence, "-emit-objc-header", "-emit-objc-header-path",
-             "/path/to/build/debug/Logging.build/Logging-Swift.h", .anySequence]
+             "/path/to/build/\(buildParameters.triple)/debug/Logging.build/Logging-Swift.h", .anySequence]
         )
         #else
         XCTAssertNoMatch(
             fooLoggingArgs,
             [.anySequence, "-emit-objc-header", "-emit-objc-header-path",
-             "/path/to/build/debug/FooLogging.build/FooLogging-Swift.h", .anySequence]
+             "/path/to/build/\(buildParameters.triple)/debug/FooLogging.build/FooLogging-Swift.h", .anySequence]
         )
         XCTAssertNoMatch(
             barLoggingArgs,
             [.anySequence, "-emit-objc-header", "-emit-objc-header-path",
-             "/path/to/build/debug/BarLogging.build/BarLogging-Swift.h", .anySequence]
+             "/path/to/build/\(buildParameters.triple)/debug/BarLogging.build/BarLogging-Swift.h", .anySequence]
         )
         XCTAssertNoMatch(
             loggingArgs,
             [.anySequence, "-emit-objc-header", "-emit-objc-header-path",
-             "/path/to/build/debug/Logging.build/Logging-Swift.h", .anySequence]
+             "/path/to/build/\(buildParameters.triple)/debug/Logging.build/Logging-Swift.h", .anySequence]
         )
         #endif
     }
@@ -812,8 +813,9 @@ final class ModuleAliasingBuildTests: XCTestCase {
         )
         XCTAssertNoDiagnostics(observability.diagnostics)
 
+        let buildParameters = mockBuildParameters(shouldLinkStaticSwiftStdlib: true)
         let result = try BuildPlanResult(plan: try BuildPlan(
-            buildParameters: mockBuildParameters(shouldLinkStaticSwiftStdlib: true),
+            buildParameters: buildParameters,
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
@@ -842,23 +844,23 @@ final class ModuleAliasingBuildTests: XCTestCase {
         XCTAssertMatch(
             otherLoggingArgs,
             [.anySequence, "-emit-objc-header", "-emit-objc-header-path",
-             "/path/to/build/debug/OtherLogging.build/OtherLogging-Swift.h", .anySequence]
+             "/path/to/build/\(buildParameters.triple)/debug/OtherLogging.build/OtherLogging-Swift.h", .anySequence]
         )
         XCTAssertMatch(
             loggingArgs,
             [.anySequence, "-emit-objc-header", "-emit-objc-header-path",
-             "/path/to/build/debug/Logging.build/Logging-Swift.h", .anySequence]
+             "/path/to/build/\(buildParameters.triple)/debug/Logging.build/Logging-Swift.h", .anySequence]
         )
         #else
         XCTAssertNoMatch(
             otherLoggingArgs,
             [.anySequence, "-emit-objc-header", "-emit-objc-header-path",
-             "/path/to/build/debug/OtherLogging.build/OtherLogging-Swift.h", .anySequence]
+             "/path/to/build/\(buildParameters.triple)/debug/OtherLogging.build/OtherLogging-Swift.h", .anySequence]
         )
         XCTAssertNoMatch(
             loggingArgs,
             [.anySequence, "-emit-objc-header", "-emit-objc-header-path",
-             "/path/to/build/debug/Logging.build/Logging-Swift.h", .anySequence]
+             "/path/to/build/\(buildParameters.triple)/debug/Logging.build/Logging-Swift.h", .anySequence]
         )
         #endif
     }
diff --git a/Tests/BuildTests/PluginsBuildPlanTests.swift b/Tests/BuildTests/PluginsBuildPlanTests.swift
index 892c3da6725..7b2a1a78378 100644
--- a/Tests/BuildTests/PluginsBuildPlanTests.swift
+++ b/Tests/BuildTests/PluginsBuildPlanTests.swift
@@ -48,8 +48,16 @@ final class PluginsBuildPlanTests: XCTestCase {
             let (stdout, stderr) = try executeSwiftPackage(fixturePath, extraArgs: ["-v", "build-plugin-dependency"])
             XCTAssertMatch(stdout, .contains("Hello from dependencies-stub"))
             XCTAssertMatch(stderr, .contains("Build of product 'plugintool' complete!"))
-            XCTAssertTrue(localFileSystem.exists(fixturePath.appending(RelativePath(".build/\(hostTriple)/debug/plugintool"))))
-            XCTAssertTrue(localFileSystem.exists(fixturePath.appending(RelativePath(".build/\(hostTriple)/debug/placeholder"))))
+            XCTAssertTrue(
+                localFileSystem.exists(
+                    fixturePath.appending(RelativePath(".build/\(hostTriple)/debug/plugintool-tool"))
+                )
+            )
+            XCTAssertTrue(
+                localFileSystem.exists(
+                    fixturePath.appending(RelativePath(".build/\(hostTriple)/debug/placeholder"))
+                )
+            )
         }
 
         // When cross compiling the final product, plugin dependencies should still be built for the host
@@ -57,8 +65,16 @@ final class PluginsBuildPlanTests: XCTestCase {
             let (stdout, stderr) = try executeSwiftPackage(fixturePath, extraArgs: ["--triple", targetTriple, "-v", "build-plugin-dependency"])
             XCTAssertMatch(stdout, .contains("Hello from dependencies-stub"))
             XCTAssertMatch(stderr, .contains("Build of product 'plugintool' complete!"))
-            XCTAssertTrue(localFileSystem.exists(fixturePath.appending(RelativePath(".build/\(hostTriple)/debug/plugintool"))))
-            XCTAssertTrue(localFileSystem.exists(fixturePath.appending(RelativePath(".build/\(targetTriple)/debug/placeholder"))))
+            XCTAssertTrue(
+                localFileSystem.exists(
+                    fixturePath.appending(RelativePath(".build/\(hostTriple)/debug/plugintool-tool"))
+                )
+            )
+            XCTAssertTrue(
+                localFileSystem.exists(
+                    fixturePath.appending(RelativePath(".build/\(targetTriple)/debug/placeholder"))
+                )
+            )
         }
     }
 }
diff --git a/Tests/BuildTests/ProductBuildDescriptionTests.swift b/Tests/BuildTests/ProductBuildDescriptionTests.swift
index f07646f64a5..444565cef7b 100644
--- a/Tests/BuildTests/ProductBuildDescriptionTests.swift
+++ b/Tests/BuildTests/ProductBuildDescriptionTests.swift
@@ -53,7 +53,7 @@ final class ProductBuildDescriptionTests: XCTestCase {
         )
         XCTAssertNoDiagnostics(observability.diagnostics)
 
-        let id = ResolvedProduct.ID(targetName: "exe", packageIdentity: .plain("pkg"), buildTriple: .destination)
+        let id = ResolvedProduct.ID(productName: "exe", packageIdentity: .plain("pkg"), buildTriple: .destination)
         let package = try XCTUnwrap(graph.rootPackages.first)
         let product = try XCTUnwrap(graph.allProducts[id])
 
diff --git a/Tests/CommandsTests/PackageCommandTests.swift b/Tests/CommandsTests/PackageCommandTests.swift
index 73e2d58db2d..b5a673a6aad 100644
--- a/Tests/CommandsTests/PackageCommandTests.swift
+++ b/Tests/CommandsTests/PackageCommandTests.swift
@@ -1719,9 +1719,15 @@ final class PackageCommandTests: CommandsTestCase {
                 """
             )
             let hostTriple = try UserToolchain(swiftSDK: .hostSwiftSDK()).targetTriple
-            let hostTripleString = hostTriple.isDarwin() ? hostTriple.tripleString(forPlatformVersion: "") : hostTriple.tripleString
-            try localFileSystem.writeFileContents(packageDir.appending(components: "Binaries", "LocalBinaryTool.artifactbundle", "info.json"), string:
-                """
+            let hostTripleString = if hostTriple.isDarwin() {
+                hostTriple.tripleString(forPlatformVersion: "")
+            } else {
+                hostTriple.tripleString
+            }
+
+            try localFileSystem.writeFileContents(
+                packageDir.appending(components: "Binaries", "LocalBinaryTool.artifactbundle", "info.json"),
+                string: """
                 {   "schemaVersion": "1.0",
                     "artifacts": {
                         "LocalBinaryTool": {
@@ -1737,11 +1743,13 @@ final class PackageCommandTests: CommandsTestCase {
                 }
                 """
             )
-            try localFileSystem.writeFileContents(packageDir.appending(components: "Sources", "LocalBuiltTool", "main.swift"), string:
-                #"print("Hello")"#
+            try localFileSystem.writeFileContents(
+                packageDir.appending(components: "Sources", "LocalBuiltTool", "main.swift"),
+                string: #"print("Hello")"#
             )
-            try localFileSystem.writeFileContents(packageDir.appending(components: "Plugins", "MyPlugin", "plugin.swift"), string:
-                """
+            try localFileSystem.writeFileContents(
+                packageDir.appending(components: "Plugins", "MyPlugin", "plugin.swift"),
+                string: """
                 import PackagePlugin
                 import Foundation
                 @main
@@ -1797,8 +1805,9 @@ final class PackageCommandTests: CommandsTestCase {
             )
 
             // Create the sample vendored dependency package.
-            try localFileSystem.writeFileContents(packageDir.appending(components: "VendoredDependencies", "HelperPackage", "Package.swift"), string:
-                """
+            try localFileSystem.writeFileContents(
+                packageDir.appending(components: "VendoredDependencies", "HelperPackage", "Package.swift"),
+                string: """
                 // swift-tools-version: 5.5
                 import PackageDescription
                 let package = Package(
@@ -1824,9 +1833,25 @@ final class PackageCommandTests: CommandsTestCase {
                 )
                 """
             )
-            try localFileSystem.writeFileContents(packageDir.appending(components: "VendoredDependencies", "HelperPackage", "Sources", "HelperLibrary", "library.swift"), string: "public func Bar() { }"
+            try localFileSystem.writeFileContents(
+                packageDir.appending(
+                    components: "VendoredDependencies",
+                    "HelperPackage",
+                    "Sources",
+                    "HelperLibrary",
+                    "library.swift"
+                ),
+                string: "public func Bar() { }"
             )
-            try localFileSystem.writeFileContents(packageDir.appending(components: "VendoredDependencies", "HelperPackage", "Sources", "RemoteBuiltTool", "main.swift"), string: #"print("Hello")"#
+            try localFileSystem.writeFileContents(
+                packageDir.appending(
+                    components: "VendoredDependencies",
+                    "HelperPackage",
+                    "Sources",
+                    "RemoteBuiltTool",
+                    "main.swift"
+                ),
+                string: #"print("Hello")"#
             )
 
             // Check that we can invoke the plugin with the "plugin" subcommand.
diff --git a/Tests/CommandsTests/SwiftCommandStateTests.swift b/Tests/CommandsTests/SwiftCommandStateTests.swift
index b1d0b8fdfcc..071ee308448 100644
--- a/Tests/CommandsTests/SwiftCommandStateTests.swift
+++ b/Tests/CommandsTests/SwiftCommandStateTests.swift
@@ -258,7 +258,7 @@ final class SwiftCommandStateTests: CommandsTestCase {
         let explicitDwarfOptions = try GlobalOptions.parse(["--triple", "x86_64-unknown-windows-msvc", "-debug-info-format", "dwarf"])
         let explicitDwarf = try SwiftCommandState.makeMockState(options: explicitDwarfOptions)
         plan = try BuildPlan(
-            productsBuildParameters: explicitDwarf.productsBuildParameters,
+            destinationBuildParameters: explicitDwarf.productsBuildParameters,
             toolsBuildParameters: explicitDwarf.toolsBuildParameters,
             graph: graph,
             fileSystem: fs,
@@ -273,7 +273,7 @@ final class SwiftCommandStateTests: CommandsTestCase {
         let explicitCodeView = try SwiftCommandState.makeMockState(options: explicitCodeViewOptions)
 
         plan = try BuildPlan(
-            productsBuildParameters: explicitCodeView.productsBuildParameters,
+            destinationBuildParameters: explicitCodeView.productsBuildParameters,
             toolsBuildParameters: explicitCodeView.productsBuildParameters,
             graph: graph,
             fileSystem: fs,
@@ -296,7 +296,7 @@ final class SwiftCommandStateTests: CommandsTestCase {
         let implicitDwarfOptions = try GlobalOptions.parse(["--triple", "x86_64-unknown-windows-msvc"])
         let implicitDwarf = try SwiftCommandState.makeMockState(options: implicitDwarfOptions)
         plan = try BuildPlan(
-            productsBuildParameters: implicitDwarf.productsBuildParameters,
+            destinationBuildParameters: implicitDwarf.productsBuildParameters,
             toolsBuildParameters: implicitDwarf.toolsBuildParameters,
             graph: graph,
             fileSystem: fs,
@@ -309,7 +309,7 @@ final class SwiftCommandStateTests: CommandsTestCase {
         let explicitNoDebugInfoOptions = try GlobalOptions.parse(["--triple", "x86_64-unknown-windows-msvc", "-debug-info-format", "none"])
         let explicitNoDebugInfo = try SwiftCommandState.makeMockState(options: explicitNoDebugInfoOptions)
         plan = try BuildPlan(
-            productsBuildParameters: explicitNoDebugInfo.productsBuildParameters,
+            destinationBuildParameters: explicitNoDebugInfo.productsBuildParameters,
             toolsBuildParameters: explicitNoDebugInfo.toolsBuildParameters,
             graph: graph,
             fileSystem: fs,
diff --git a/Tests/PackageGraphPerformanceTests/PackageGraphPerfTests.swift b/Tests/PackageGraphPerformanceTests/PackageGraphPerfTests.swift
index c688b1d5439..6073cc22896 100644
--- a/Tests/PackageGraphPerformanceTests/PackageGraphPerfTests.swift
+++ b/Tests/PackageGraphPerformanceTests/PackageGraphPerfTests.swift
@@ -164,9 +164,9 @@ final class PackageGraphPerfTests: XCTestCasePerf {
     }
 
     func testRecursiveDependencies() throws {
-        var resolvedTarget = ResolvedTarget.mock(packageIdentity: "pkg", name: "t0")
+        var resolvedTarget = ResolvedModule.mock(packageIdentity: "pkg", name: "t0")
         for i in 1..<1000 {
-            resolvedTarget = ResolvedTarget.mock(packageIdentity: "pkg", name: "t\(i)", deps: resolvedTarget)
+            resolvedTarget = ResolvedModule.mock(packageIdentity: "pkg", name: "t\(i)", deps: resolvedTarget)
         }        
 
         let N = 10
diff --git a/Tests/PackageGraphTests/CrossCompilationPackageGraphTests.swift b/Tests/PackageGraphTests/CrossCompilationPackageGraphTests.swift
new file mode 100644
index 00000000000..dc50bab88c7
--- /dev/null
+++ b/Tests/PackageGraphTests/CrossCompilationPackageGraphTests.swift
@@ -0,0 +1,156 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2014-2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+@testable
+import SPMTestSupport
+
+@testable
+import PackageGraph
+
+import XCTest
+
+final class CrossCompilationPackageGraphTests: XCTestCase {
+    func testTrivialPackage() throws {
+        let graph = try trivialPackageGraph(pkgRootPath: "/Pkg").graph
+        try PackageGraphTester(graph) { result in
+            result.check(packages: "Pkg")
+            // "SwiftSyntax" is included for both host and target triples and is not pruned on this level
+            result.check(targets: "app", "lib")
+            result.check(testModules: "test")
+            result.checkTarget("app") { result in
+                result.check(buildTriple: .destination)
+                result.check(dependencies: "lib")
+            }
+            try result.checkTargets("lib") { results in
+                let result = try XCTUnwrap(results.first { $0.target.buildTriple == .destination })
+                result.check(dependencies: [])
+            }
+            result.checkTarget("test") { result in
+                result.check(buildTriple: .destination)
+                result.check(dependencies: "lib")
+            }
+        }
+    }
+
+    func testMacros() throws {
+        let graph = try macrosPackageGraph().graph
+        try PackageGraphTester(graph) { result in
+            result.check(packages: "swift-firmware", "swift-mmio", "swift-syntax")
+            // "SwiftSyntax" is included for both host and target triples and is not pruned on this level
+            result.check(
+                targets: "Core",
+                "HAL",
+                "MMIO",
+                "MMIOMacros",
+                "SwiftSyntax",
+                "SwiftSyntax"
+            )
+            result.check(testModules: "CoreTests", "HALTests")
+            try result.checkTargets("Core") { results in
+                let result = try XCTUnwrap(results.first { $0.target.buildTriple == .destination })
+                result.check(dependencies: "HAL")
+            }
+            try result.checkTargets("HAL") { results in
+                let result = try XCTUnwrap(results.first { $0.target.buildTriple == .destination })
+                result.check(buildTriple: .destination)
+                result.check(dependencies: "MMIO")
+            }
+            try result.checkTargets("MMIO") { results in
+                let result = try XCTUnwrap(results.first { $0.target.buildTriple == .destination })
+                result.check(buildTriple: .destination)
+                result.check(dependencies: "MMIOMacros")
+            }
+            try result.checkTargets("MMIOMacros") { results in
+                let result = try XCTUnwrap(results.first(where: { $0.target.buildTriple == .tools }))
+                result.check(buildTriple: .tools)
+                result.checkDependency("SwiftSyntax") { result in
+                    result.checkProduct { result in
+                        result.check(buildTriple: .tools)
+                        result.checkTarget("SwiftSyntax") { result in
+                            result.check(buildTriple: .tools)
+                        }
+                    }
+                }
+            }
+
+            result.checkTargets("SwiftSyntax") { results in
+                XCTAssertEqual(results.count, 2)
+
+                XCTAssertEqual(results.filter({ $0.target.buildTriple == .tools }).count, 1)
+                XCTAssertEqual(results.filter({ $0.target.buildTriple == .destination }).count, 1)
+            }
+        }
+    }
+
+    func testMacrosTests() throws {
+        let graph = try macrosTestsPackageGraph().graph
+        PackageGraphTester(graph) { result in
+            result.check(packages: "swift-mmio", "swift-syntax")
+            // "SwiftSyntax" is included for both host and target triples and is not pruned on this level
+            result.check(
+                targets: "MMIO",
+                "MMIOMacros",
+                "SwiftCompilerPlugin",
+                "SwiftCompilerPlugin",
+                "SwiftCompilerPluginMessageHandling",
+                "SwiftCompilerPluginMessageHandling",
+                "SwiftSyntax",
+                "SwiftSyntax",
+                "SwiftSyntaxMacros",
+                "SwiftSyntaxMacros",
+                "SwiftSyntaxMacrosTestSupport",
+                "SwiftSyntaxMacrosTestSupport"
+            )
+            result.check(testModules: "MMIOMacrosTests")
+            result.checkTarget("MMIO") { result in
+                result.check(buildTriple: .destination)
+                result.check(dependencies: "MMIOMacros")
+            }
+            result.checkTargets("MMIOMacros") { results in
+                XCTAssertEqual(results.count, 1)
+            }
+            result.checkTarget("MMIOMacrosTests") { result in
+                result.check(buildTriple: .tools)
+                result.checkDependency("MMIOMacros") { result in
+                    result.checkTarget { result in
+                        result.check(buildTriple: .tools)
+                        result.checkDependency("SwiftSyntaxMacros") { result in
+                            result.checkProduct { result in
+                                result.check(buildTriple: .tools)
+                            }
+                        }
+                        result.checkDependency("SwiftCompilerPlugin") { result in
+                            result.checkProduct { result in
+                                result.check(buildTriple: .tools)
+                                result.checkTarget("SwiftCompilerPlugin") { result in
+                                    result.check(buildTriple: .tools)
+                                    result.checkDependency("SwiftCompilerPluginMessageHandling") { result in
+                                        result.checkTarget { result in
+                                            result.check(buildTriple: .tools)
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            result.checkTargets("SwiftSyntax") { results in
+                XCTAssertEqual(results.count, 2)
+
+                XCTAssertEqual(results.filter({ $0.target.buildTriple == .tools }).count, 1)
+                XCTAssertEqual(results.filter({ $0.target.buildTriple == .destination }).count, 1)
+            }
+        }
+    }
+}
diff --git a/Tests/PackageGraphTests/ResolvedTargetTests.swift b/Tests/PackageGraphTests/ResolvedTargetTests.swift
index 5c10466603e..5546a9cc267 100644
--- a/Tests/PackageGraphTests/ResolvedTargetTests.swift
+++ b/Tests/PackageGraphTests/ResolvedTargetTests.swift
@@ -17,29 +17,29 @@ import PackageGraph
 import SPMTestSupport
 
 private func XCTAssertEqualTargetIDs(
-    _ lhs: [ResolvedTarget],
-    _ rhs: [ResolvedTarget],
+    _ lhs: [ResolvedModule],
+    _ rhs: [ResolvedModule],
     file: StaticString = #filePath,
     line: UInt = #line
 ) {
     XCTAssertEqual(lhs.map(\.id), rhs.map(\.id), file: file, line: line)
 }
 
-final class ResolvedTargetDependencyTests: XCTestCase {
+final class ResolvedModuleDependencyTests: XCTestCase {
     func test1() throws {
-        let t1 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t1")
-        let t2 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t2", deps: t1)
-        let t3 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t3", deps: t2)
+        let t1 = ResolvedModule.mock(packageIdentity: "pkg", name: "t1")
+        let t2 = ResolvedModule.mock(packageIdentity: "pkg", name: "t2", deps: t1)
+        let t3 = ResolvedModule.mock(packageIdentity: "pkg", name: "t3", deps: t2)
 
         XCTAssertEqualTargetIDs(try t3.recursiveTargetDependencies(), [t2, t1])
         XCTAssertEqualTargetIDs(try t2.recursiveTargetDependencies(), [t1])
     }
 
     func test2() throws {
-        let t1 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t1")
-        let t2 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t2", deps: t1)
-        let t3 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t3", deps: t2, t1)
-        let t4 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t4", deps: t2, t3, t1)
+        let t1 = ResolvedModule.mock(packageIdentity: "pkg", name: "t1")
+        let t2 = ResolvedModule.mock(packageIdentity: "pkg", name: "t2", deps: t1)
+        let t3 = ResolvedModule.mock(packageIdentity: "pkg", name: "t3", deps: t2, t1)
+        let t4 = ResolvedModule.mock(packageIdentity: "pkg", name: "t4", deps: t2, t3, t1)
 
         XCTAssertEqualTargetIDs(try t4.recursiveTargetDependencies(), [t3, t2, t1])
         XCTAssertEqualTargetIDs(try t3.recursiveTargetDependencies(), [t2, t1])
@@ -47,10 +47,10 @@ final class ResolvedTargetDependencyTests: XCTestCase {
     }
 
     func test3() throws {
-        let t1 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t1")
-        let t2 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t2", deps: t1)
-        let t3 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t3", deps: t2, t1)
-        let t4 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t4", deps: t1, t2, t3)
+        let t1 = ResolvedModule.mock(packageIdentity: "pkg", name: "t1")
+        let t2 = ResolvedModule.mock(packageIdentity: "pkg", name: "t2", deps: t1)
+        let t3 = ResolvedModule.mock(packageIdentity: "pkg", name: "t3", deps: t2, t1)
+        let t4 = ResolvedModule.mock(packageIdentity: "pkg", name: "t4", deps: t1, t2, t3)
 
         XCTAssertEqualTargetIDs(try t4.recursiveTargetDependencies(), [t3, t2, t1])
         XCTAssertEqualTargetIDs(try t3.recursiveTargetDependencies(), [t2, t1])
@@ -58,10 +58,10 @@ final class ResolvedTargetDependencyTests: XCTestCase {
     }
 
     func test4() throws {
-        let t1 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t1")
-        let t2 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t2", deps: t1)
-        let t3 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t3", deps: t2)
-        let t4 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t4", deps: t3)
+        let t1 = ResolvedModule.mock(packageIdentity: "pkg", name: "t1")
+        let t2 = ResolvedModule.mock(packageIdentity: "pkg", name: "t2", deps: t1)
+        let t3 = ResolvedModule.mock(packageIdentity: "pkg", name: "t3", deps: t2)
+        let t4 = ResolvedModule.mock(packageIdentity: "pkg", name: "t4", deps: t3)
 
         XCTAssertEqualTargetIDs(try t4.recursiveTargetDependencies(), [t3, t2, t1])
         XCTAssertEqualTargetIDs(try t3.recursiveTargetDependencies(), [t2, t1])
@@ -69,12 +69,12 @@ final class ResolvedTargetDependencyTests: XCTestCase {
     }
 
     func test5() throws {
-        let t1 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t1")
-        let t2 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t2", deps: t1)
-        let t3 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t3", deps: t2)
-        let t4 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t4", deps: t3)
-        let t5 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t5", deps: t2)
-        let t6 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t6", deps: t5, t4)
+        let t1 = ResolvedModule.mock(packageIdentity: "pkg", name: "t1")
+        let t2 = ResolvedModule.mock(packageIdentity: "pkg", name: "t2", deps: t1)
+        let t3 = ResolvedModule.mock(packageIdentity: "pkg", name: "t3", deps: t2)
+        let t4 = ResolvedModule.mock(packageIdentity: "pkg", name: "t4", deps: t3)
+        let t5 = ResolvedModule.mock(packageIdentity: "pkg", name: "t5", deps: t2)
+        let t6 = ResolvedModule.mock(packageIdentity: "pkg", name: "t6", deps: t5, t4)
 
         // precise order is not important, but it is important that the following are true
         let t6rd = try t6.recursiveTargetDependencies().map(\.id)
@@ -91,12 +91,12 @@ final class ResolvedTargetDependencyTests: XCTestCase {
     }
 
     func test6() throws {
-        let t1 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t1")
-        let t2 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t2", deps: t1)
-        let t3 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t3", deps: t2)
-        let t4 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t4", deps: t3)
-        let t5 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t5", deps: t2)
-        let t6 = ResolvedTarget.mock(
+        let t1 = ResolvedModule.mock(packageIdentity: "pkg", name: "t1")
+        let t2 = ResolvedModule.mock(packageIdentity: "pkg", name: "t2", deps: t1)
+        let t3 = ResolvedModule.mock(packageIdentity: "pkg", name: "t3", deps: t2)
+        let t4 = ResolvedModule.mock(packageIdentity: "pkg", name: "t4", deps: t3)
+        let t5 = ResolvedModule.mock(packageIdentity: "pkg", name: "t5", deps: t2)
+        let t6 = ResolvedModule.mock(
             packageIdentity: "pkg",
             name: "t6",
             deps: t4,
@@ -118,10 +118,10 @@ final class ResolvedTargetDependencyTests: XCTestCase {
     }
 
     func testConditions() throws {
-        let t1 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t1")
-        let t2 = ResolvedTarget.mock(packageIdentity: "pkg", name: "t2", deps: t1)
-        let t2NoConditions = ResolvedTarget.mock(packageIdentity: "pkg", name: "t2", deps: t1)
-        let t2WithConditions = ResolvedTarget.mock(
+        let t1 = ResolvedModule.mock(packageIdentity: "pkg", name: "t1")
+        let t2 = ResolvedModule.mock(packageIdentity: "pkg", name: "t2", deps: t1)
+        let t2NoConditions = ResolvedModule.mock(packageIdentity: "pkg", name: "t2", deps: t1)
+        let t2WithConditions = ResolvedModule.mock(
             packageIdentity: "pkg",
             name: "t2",
             deps: t1,
diff --git a/Tests/SPMBuildCoreTests/PluginInvocationTests.swift b/Tests/SPMBuildCoreTests/PluginInvocationTests.swift
index d06d5bb133d..6f35776a211 100644
--- a/Tests/SPMBuildCoreTests/PluginInvocationTests.swift
+++ b/Tests/SPMBuildCoreTests/PluginInvocationTests.swift
@@ -34,7 +34,7 @@ class PluginInvocationTests: XCTestCase {
             "/Foo/Sources/Foo/SomeFile.abc"
         )
         let observability = ObservabilitySystem.makeForTesting()
-        let graph = try loadPackageGraph(
+        let graph = try loadModulesGraph(
             fileSystem: fileSystem,
             manifests: [
                 Manifest.createRootManifest(
@@ -74,7 +74,8 @@ class PluginInvocationTests: XCTestCase {
         XCTAssertNoDiagnostics(observability.diagnostics)
         PackageGraphTester(graph) { graph in
             graph.check(packages: "Foo")
-            graph.check(targets: "Foo", "FooPlugin", "FooTool")
+            // "FooTool" duplicated as it's present for both build tools and end products triples.
+            graph.check(targets: "Foo", "FooPlugin", "FooTool", "FooTool")
             graph.checkTarget("Foo") { target in
                 target.check(dependencies: "FooPlugin")
             }
@@ -82,8 +83,10 @@ class PluginInvocationTests: XCTestCase {
                 target.check(type: .plugin)
                 target.check(dependencies: "FooTool")
             }
-            graph.checkTarget("FooTool") { target in
-                target.check(type: .executable)
+            graph.checkTargets("FooTool") { targets in
+                for target in targets {
+                    target.check(type: .executable)
+                }
             }
         }
 
@@ -188,13 +191,13 @@ class PluginInvocationTests: XCTestCase {
 
         // Construct a canned input and run plugins using our MockPluginScriptRunner().
         let outputDir = AbsolutePath("/Foo/.build")
-        let builtToolsDir = AbsolutePath("/path/to/build/debug")
         let pluginRunner = MockPluginScriptRunner()
+        let buildParameters = mockBuildParameters(
+            environment: BuildEnvironment(platform: .macOS, configuration: .debug)
+        )
         let results = try graph.invokeBuildToolPlugins(
             outputDir: outputDir,
-            buildParameters: mockBuildParameters(
-                environment: BuildEnvironment(platform: .macOS, configuration: .debug)
-            ),
+            buildParameters: buildParameters,
             additionalFileRules: [],
             toolSearchDirectories: [UserToolchain.default.swiftCompilerPath.parentDirectory],
             pkgConfigDirectories: [],
@@ -202,11 +205,12 @@ class PluginInvocationTests: XCTestCase {
             observabilityScope: observability.topScope,
             fileSystem: fileSystem
         )
+        let builtToolsDir = AbsolutePath("/path/to/build/\(buildParameters.triple)/debug")
 
         // Check the canned output to make sure nothing was lost in transport.
         XCTAssertNoDiagnostics(observability.diagnostics)
         XCTAssertEqual(results.count, 1)
-        let (evalTargetID, (evalTarget, evalResults)) = try XCTUnwrap(results.first)
+        let (_, (evalTarget, evalResults)) = try XCTUnwrap(results.first)
         XCTAssertEqual(evalTarget.name, "Foo")
 
         XCTAssertEqual(evalResults.count, 1)
@@ -1081,7 +1085,6 @@ class PluginInvocationTests: XCTestCase {
                 }
             }
 
-
             XCTAssertEqual(count, 2)
         }
     }
@@ -1089,7 +1092,7 @@ class PluginInvocationTests: XCTestCase {
     func checkParseArtifactsPlatformCompatibility(
         artifactSupportedTriples: [Triple],
         hostTriple: Triple
-    ) async throws -> [ResolvedTarget.ID: [BuildToolPluginInvocationResult]]  {
+    ) async throws -> [ResolvedModule.ID: [BuildToolPluginInvocationResult]]  {
         // Only run the test if the environment in which we're running actually supports Swift concurrency (which the plugin APIs require).
         try XCTSkipIf(!UserToolchain.default.supportsSwiftConcurrency(), "skipping because test environment doesn't support concurrency")
 
diff --git a/Tests/SourceKitLSPAPITests/SourceKitLSPAPITests.swift b/Tests/SourceKitLSPAPITests/SourceKitLSPAPITests.swift
index 127710d0785..759106a8fa6 100644
--- a/Tests/SourceKitLSPAPITests/SourceKitLSPAPITests.swift
+++ b/Tests/SourceKitLSPAPITests/SourceKitLSPAPITests.swift
@@ -27,7 +27,7 @@ class SourceKitLSPAPITests: XCTestCase {
         )
 
         let observability = ObservabilitySystem.makeForTesting()
-        let graph = try loadPackageGraph(
+        let graph = try loadModulesGraph(
             fileSystem: fs,
             manifests: [
                 Manifest.createRootManifest(
@@ -42,22 +42,45 @@ class SourceKitLSPAPITests: XCTestCase {
         )
         XCTAssertNoDiagnostics(observability.diagnostics)
 
+        let buildParameters = mockBuildParameters(shouldLinkStaticSwiftStdlib: true)
         let plan = try BuildPlan(
-            productsBuildParameters: mockBuildParameters(shouldLinkStaticSwiftStdlib: true),
-            toolsBuildParameters: mockBuildParameters(shouldLinkStaticSwiftStdlib: true),
+            destinationBuildParameters: buildParameters,
+            toolsBuildParameters: buildParameters,
             graph: graph,
             fileSystem: fs,
             observabilityScope: observability.topScope
         )
         let description = BuildDescription(buildPlan: plan)
 
-        try description.checkArguments(for: "exe", graph: graph, partialArguments: ["-module-name", "exe", "-emit-dependencies", "-emit-module", "-emit-module-path", "/path/to/build/debug/exe.build/exe.swiftmodule"])
-        try description.checkArguments(for: "lib", graph: graph, partialArguments: ["-module-name", "lib", "-emit-dependencies", "-emit-module", "-emit-module-path", "/path/to/build/debug/Modules/lib.swiftmodule"])
+        try description.checkArguments(
+            for: "exe",
+            graph: graph,
+            partialArguments: [
+                "-module-name", "exe",
+                "-emit-dependencies",
+                "-emit-module",
+                "-emit-module-path", "/path/to/build/\(buildParameters.triple)/debug/exe.build/exe.swiftmodule"
+            ]
+        )
+        try description.checkArguments(
+            for: "lib",
+            graph: graph,
+            partialArguments: [
+                "-module-name", "lib",
+                "-emit-dependencies",
+                "-emit-module",
+                "-emit-module-path", "/path/to/build/\(buildParameters.triple)/debug/Modules/lib.swiftmodule"
+            ]
+        )
     }
 }
 
 extension SourceKitLSPAPI.BuildDescription {
-    @discardableResult func checkArguments(for targetName: String, graph: ModulesGraph, partialArguments: [String]) throws -> Bool {
+    @discardableResult func checkArguments(
+        for targetName: String,
+        graph: ModulesGraph,
+        partialArguments: [String]
+    ) throws -> Bool {
         let target = try XCTUnwrap(graph.allTargets.first(where: { $0.name == targetName }))
         let buildTarget = try XCTUnwrap(self.getBuildTarget(for: target))