diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/AbstractNexusStagingRepositoryTask.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/AbstractNexusStagingRepositoryTask.kt
index 96aaf461..769fdac8 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/AbstractNexusStagingRepositoryTask.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/AbstractNexusStagingRepositoryTask.kt
@@ -17,17 +17,13 @@
 package io.github.gradlenexus.publishplugin
 
 import org.gradle.api.DefaultTask
-import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.Nested
-import org.gradle.kotlin.dsl.property
 import java.time.Duration
-import javax.inject.Inject
 
-abstract class AbstractNexusStagingRepositoryTask @Inject
-constructor(objects: ObjectFactory, repository: NexusRepository) : DefaultTask() {
+abstract class AbstractNexusStagingRepositoryTask : DefaultTask() {
 
     @get:Internal
     abstract val clientTimeout: Property<Duration>
@@ -36,16 +32,14 @@ constructor(objects: ObjectFactory, repository: NexusRepository) : DefaultTask()
     abstract val connectTimeout: Property<Duration>
 
     // TODO: Expose externally as interface with getters only
-    @Nested
-    val repository = objects.property<NexusRepository>().apply {
-        set(repository)
-    }
+    @get:Nested
+    abstract val repository: Property<NexusRepository>
 
     @get:Input
     abstract val repositoryDescription: Property<String>
 
     @get:Internal
-    internal abstract val useStaging: Property<Boolean>
+    abstract val useStaging: Property<Boolean>
 
     init {
         this.onlyIf { useStaging.getOrElse(false) }
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/AbstractTransitionNexusStagingRepositoryTask.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/AbstractTransitionNexusStagingRepositoryTask.kt
index b694678c..9813aba4 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/AbstractTransitionNexusStagingRepositoryTask.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/AbstractTransitionNexusStagingRepositoryTask.kt
@@ -17,38 +17,26 @@
 package io.github.gradlenexus.publishplugin
 
 import io.github.gradlenexus.publishplugin.internal.BasicActionRetrier
-import io.github.gradlenexus.publishplugin.internal.InvalidatingStagingRepositoryDescriptorRegistry
 import io.github.gradlenexus.publishplugin.internal.NexusClient
 import io.github.gradlenexus.publishplugin.internal.StagingRepository
 import io.github.gradlenexus.publishplugin.internal.StagingRepositoryTransitioner
 import org.gradle.api.Action
-import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.Property
-import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.TaskAction
-import org.gradle.kotlin.dsl.property
 
-abstract class AbstractTransitionNexusStagingRepositoryTask(
-    objects: ObjectFactory,
-    repository: NexusRepository,
-    registry: Provider<InvalidatingStagingRepositoryDescriptorRegistry>
-) : AbstractNexusStagingRepositoryTask(objects, repository) {
+abstract class AbstractTransitionNexusStagingRepositoryTask : AbstractNexusStagingRepositoryTask() {
 
-    @Input
-    val stagingRepositoryId = objects.property<String>().apply {
-        set(
-            registry.map {
-                it[repository.name].stagingRepositoryId
-            }
-        )
-    }
+    @get:Input
+    abstract val stagingRepositoryId: Property<String>
 
     @get:Internal
     abstract val transitionCheckOptions: Property<TransitionCheckOptions>
 
-    fun transitionCheckOptions(action: Action<in TransitionCheckOptions>) = action.execute(transitionCheckOptions.get())
+    fun transitionCheckOptions(action: Action<in TransitionCheckOptions>) {
+        action.execute(transitionCheckOptions.get())
+    }
 
     @TaskAction
     fun transitionStagingRepo() {
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/CloseNexusStagingRepository.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/CloseNexusStagingRepository.kt
index b6b37fb0..b12cb4ce 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/CloseNexusStagingRepository.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/CloseNexusStagingRepository.kt
@@ -16,21 +16,13 @@
 
 package io.github.gradlenexus.publishplugin
 
-import io.github.gradlenexus.publishplugin.internal.InvalidatingStagingRepositoryDescriptorRegistry
 import io.github.gradlenexus.publishplugin.internal.StagingRepositoryTransitioner
-import org.gradle.api.model.ObjectFactory
-import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.options.Option
-import javax.inject.Inject
 
-abstract class CloseNexusStagingRepository @Inject constructor(
-    objects: ObjectFactory,
-    repository: NexusRepository,
-    registry: Provider<InvalidatingStagingRepositoryDescriptorRegistry>
-) : AbstractTransitionNexusStagingRepositoryTask(objects, repository, registry) {
+abstract class CloseNexusStagingRepository : AbstractTransitionNexusStagingRepositoryTask() {
 
     @Option(option = "staging-repository-id", description = "staging repository id to close")
-    fun setStagingRepositoryId(stagingRepositoryId: String) {
+    fun setStagingRepositoryIdToClose(stagingRepositoryId: String) {
         this.stagingRepositoryId.set(stagingRepositoryId)
     }
 
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/FindStagingRepository.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/FindStagingRepository.kt
index 426fa0fd..2c6a6bbf 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/FindStagingRepository.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/FindStagingRepository.kt
@@ -20,36 +20,27 @@ import io.github.gradlenexus.publishplugin.internal.InvalidatingStagingRepositor
 import io.github.gradlenexus.publishplugin.internal.NexusClient
 import org.gradle.api.GradleException
 import org.gradle.api.Incubating
-import org.gradle.api.model.ObjectFactory
-import org.gradle.api.provider.Provider
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.Optional
 import org.gradle.api.tasks.TaskAction
-import org.gradle.kotlin.dsl.property
-import javax.inject.Inject
 
 @Incubating
-abstract class FindStagingRepository @Inject constructor(
-    objects: ObjectFactory,
-    extension: NexusPublishExtension,
-    repository: NexusRepository,
-    private val registry: Provider<InvalidatingStagingRepositoryDescriptorRegistry>
-) : AbstractNexusStagingRepositoryTask(objects, repository) {
+abstract class FindStagingRepository : AbstractNexusStagingRepositoryTask() {
 
-    @Optional
-    @Input
-    val packageGroup = objects.property<String>().apply {
-        set(extension.packageGroup)
-    }
+    @get:Internal
+    abstract val registry: Property<InvalidatingStagingRepositoryDescriptorRegistry>
 
-    @Input
-    val descriptionRegex = objects.property<String>().apply {
-        set(extension.repositoryDescription.map { "\\b" + Regex.escape(it) + "(\\s|$)" })
-    }
+    @get:Optional
+    @get:Input
+    abstract val packageGroup: Property<String>
+
+    @get:Input
+    abstract val descriptionRegex: Property<String>
 
-    @Internal
-    val stagingRepositoryId = objects.property<String>()
+    @get:Internal
+    abstract val stagingRepositoryId: Property<String>
 
     init {
         outputs.cacheIf("the task requests data from the external repository, so we don't want to cache it") {
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/InitializeNexusStagingRepository.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/InitializeNexusStagingRepository.kt
index 59ebae89..0357e79c 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/InitializeNexusStagingRepository.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/InitializeNexusStagingRepository.kt
@@ -20,26 +20,20 @@ import io.github.gradlenexus.publishplugin.internal.InvalidatingStagingRepositor
 import io.github.gradlenexus.publishplugin.internal.NexusClient
 import okhttp3.HttpUrl
 import org.gradle.api.GradleException
-import org.gradle.api.model.ObjectFactory
-import org.gradle.api.provider.Provider
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.Optional
 import org.gradle.api.tasks.TaskAction
-import org.gradle.kotlin.dsl.property
-import javax.inject.Inject
 
-abstract class InitializeNexusStagingRepository @Inject constructor(
-    objects: ObjectFactory,
-    extension: NexusPublishExtension,
-    repository: NexusRepository,
-    private val registry: Provider<InvalidatingStagingRepositoryDescriptorRegistry>
-) : AbstractNexusStagingRepositoryTask(objects, repository) {
+abstract class InitializeNexusStagingRepository : AbstractNexusStagingRepositoryTask() {
 
-    @Optional
-    @Input
-    val packageGroup = objects.property<String>().apply {
-        set(extension.packageGroup)
-    }
+    @get:Internal
+    abstract val registry: Property<InvalidatingStagingRepositoryDescriptorRegistry>
+
+    @get:Optional
+    @get:Input
+    abstract val packageGroup: Property<String>
 
     @TaskAction
     fun createStagingRepo() {
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/NexusPublishExtension.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/NexusPublishExtension.kt
index 543d3216..5cb47d7b 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/NexusPublishExtension.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/NexusPublishExtension.kt
@@ -17,7 +17,6 @@
 package io.github.gradlenexus.publishplugin
 
 import org.gradle.api.Action
-import org.gradle.api.NamedDomainObjectFactory
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Nested
@@ -38,7 +37,6 @@ abstract class NexusPublishExtension @Inject constructor(objects: ObjectFactory)
 
     abstract val repositoryDescription: Property<String>
 
-    // staging repository initialization can take a few minutes on Sonatype Nexus
     abstract val clientTimeout: Property<Duration>
 
     abstract val connectTimeout: Property<Duration>
@@ -46,20 +44,16 @@ abstract class NexusPublishExtension @Inject constructor(objects: ObjectFactory)
     @get:Nested
     abstract val transitionCheckOptions: TransitionCheckOptions
 
-    fun transitionCheckOptions(action: Action<in TransitionCheckOptions>) = action.execute(transitionCheckOptions)
+    fun transitionCheckOptions(action: Action<in TransitionCheckOptions>) {
+        action.execute(transitionCheckOptions)
+    }
 
     val repositories: NexusRepositoryContainer = objects.newInstance(
         DefaultNexusRepositoryContainer::class,
-        // `objects.domainObjectContainer(NexusRepository::class) { name -> ... }`,
-        // but in Kotlin 1.3 "New Inference" is not implemented yet, so we have to be explicit.
-        // https://kotlinlang.org/docs/whatsnew14.html#new-more-powerful-type-inference-algorithm
-        objects.domainObjectContainer(
-            NexusRepository::class,
-            NamedDomainObjectFactory { name ->
-                objects.newInstance(NexusRepository::class, name)
-            }
-        )
+        objects.domainObjectContainer(NexusRepository::class)
     )
 
-    fun repositories(action: Action<in NexusRepositoryContainer>) = action.execute(repositories)
+    fun repositories(action: Action<in NexusRepositoryContainer>) {
+        action.execute(repositories)
+    }
 }
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/NexusPublishPlugin.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/NexusPublishPlugin.kt
index 28afbaec..313b4d26 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/NexusPublishPlugin.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/NexusPublishPlugin.kt
@@ -19,6 +19,7 @@ package io.github.gradlenexus.publishplugin
 import io.github.gradlenexus.publishplugin.NexusRepository.PublicationType
 import io.github.gradlenexus.publishplugin.internal.InvalidatingStagingRepositoryDescriptorRegistry
 import io.github.gradlenexus.publishplugin.internal.StagingRepositoryDescriptorRegistryBuildService
+import org.gradle.api.Action
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.Task
@@ -28,14 +29,17 @@ import org.gradle.api.artifacts.repositories.UrlArtifactRepository
 import org.gradle.api.provider.Provider
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.plugins.PublishingPlugin
+import org.gradle.api.tasks.TaskContainer
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.invoke
 import org.gradle.kotlin.dsl.named
 import org.gradle.kotlin.dsl.register
+import org.gradle.kotlin.dsl.registerIfAbsent
 import org.gradle.kotlin.dsl.typeOf
 import org.gradle.kotlin.dsl.withType
 import org.gradle.util.GradleVersion
+import java.net.URI
 import java.time.Duration
 
 class NexusPublishPlugin : Plugin<Project> {
@@ -66,6 +70,7 @@ class NexusPublishPlugin : Plugin<Project> {
             useStaging.convention(project.provider { !project.version.toString().endsWith("-SNAPSHOT") })
             packageGroup.convention(project.provider { project.group.toString() })
             repositoryDescription.convention(project.provider { project.run { "$group:$name:$version" } })
+            // Staging repository initialization can take a few minutes on Sonatype Nexus.
             clientTimeout.convention(Duration.ofMinutes(5))
             connectTimeout.convention(Duration.ofMinutes(5))
             transitionCheckOptions.maxRetries.convention(60)
@@ -75,7 +80,11 @@ class NexusPublishPlugin : Plugin<Project> {
 
     private fun createRegistry(rootProject: Project): Provider<InvalidatingStagingRepositoryDescriptorRegistry> {
         if (GradleVersion.current() >= GradleVersion.version("6.1")) {
-            return rootProject.gradle.sharedServices.registerIfAbsent("stagingRepositoryUrlRegistry", StagingRepositoryDescriptorRegistryBuildService::class.java) {}.map { it.registry }
+            return rootProject.gradle.sharedServices.registerIfAbsent(
+                "stagingRepositoryUrlRegistry",
+                StagingRepositoryDescriptorRegistryBuildService::class,
+                Action { }
+            ).map { it.registry }
         }
         val registry = InvalidatingStagingRepositoryDescriptorRegistry()
         return rootProject.provider { registry }
@@ -87,70 +96,17 @@ class NexusPublishPlugin : Plugin<Project> {
             connectTimeout.convention(extension.connectTimeout)
             repositoryDescription.convention(extension.repositoryDescription)
             useStaging.convention(extension.useStaging)
+            // repository.convention() is set in configureRepositoryTasks().
         }
         rootProject.tasks.withType(AbstractTransitionNexusStagingRepositoryTask::class.java).configureEach {
             transitionCheckOptions.convention(extension.transitionCheckOptions)
+            stagingRepositoryId.convention(registry.map { it[repository.get().name].stagingRepositoryId })
         }
         extension.repositories.all {
             username.convention(rootProject.provider { rootProject.findProperty("${name}Username") as? String })
             password.convention(rootProject.provider { rootProject.findProperty("${name}Password") as? String })
             publicationType.convention(PublicationType.MAVEN)
-
-            val repository = this
-            val retrieveStagingProfileTask = rootProject.tasks.register<RetrieveStagingProfile>("retrieve${capitalizedName}StagingProfile", rootProject.objects, extension, repository)
-            val initializeTask = rootProject.tasks.register<InitializeNexusStagingRepository>(
-                "initialize${capitalizedName}StagingRepository",
-                rootProject.objects,
-                extension,
-                repository,
-                registry
-            )
-            val findStagingRepository = rootProject.tasks.register<FindStagingRepository>(
-                "find${capitalizedName}StagingRepository",
-                rootProject.objects,
-                extension,
-                repository,
-                registry
-            )
-            findStagingRepository {
-                description = "Finds the staging repository for ${repository.name}"
-            }
-            val closeTask = rootProject.tasks.register<CloseNexusStagingRepository>(
-                "close${capitalizedName}StagingRepository",
-                rootProject.objects,
-                repository,
-                registry
-            )
-            val releaseTask = rootProject.tasks.register<ReleaseNexusStagingRepository>(
-                "release${capitalizedName}StagingRepository",
-                rootProject.objects,
-                repository,
-                registry
-            )
-            val closeAndReleaseTask = rootProject.tasks.register<Task>(
-                "closeAndRelease${capitalizedName}StagingRepository"
-            )
-            retrieveStagingProfileTask {
-                description = "Gets and displays a staging profile id for a given repository and package group. This is a diagnostic task to get the value and put it into the NexusRepository configuration closure as stagingProfileId."
-            }
-            closeTask {
-                description = "Closes open staging repository in '${repository.name}' Nexus instance."
-                group = PublishingPlugin.PUBLISH_TASK_GROUP
-                mustRunAfter(initializeTask)
-                mustRunAfter(findStagingRepository)
-            }
-            releaseTask {
-                description = "Releases closed staging repository in '${repository.name}' Nexus instance."
-                group = PublishingPlugin.PUBLISH_TASK_GROUP
-                mustRunAfter(initializeTask)
-                mustRunAfter(findStagingRepository)
-                mustRunAfter(closeTask)
-            }
-            closeAndReleaseTask {
-                description = "Closes and releases open staging repository in '${repository.name}' Nexus instance."
-                group = PublishingPlugin.PUBLISH_TASK_GROUP
-                dependsOn(closeTask, releaseTask)
-            }
+            configureRepositoryTasks(rootProject.tasks, extension, this, registry)
         }
         extension.repositories.whenObjectRemoved {
             rootProject.tasks.named("initialize${capitalizedName}StagingRepository").configure {
@@ -170,12 +126,83 @@ class NexusPublishPlugin : Plugin<Project> {
             }
         }
         rootProject.tasks.register<Task>(SIMPLIFIED_CLOSE_AND_RELEASE_TASK_NAME) {
-            description = "Closes and releases open staging repositories in all configured Nexus instances."
             group = PublishingPlugin.PUBLISH_TASK_GROUP
+            description = "Closes and releases open staging repositories in all configured Nexus instances."
             enabled = false
         }
     }
 
+    private fun configureRepositoryTasks(
+        tasks: TaskContainer,
+        extension: NexusPublishExtension,
+        repo: NexusRepository,
+        registryProvider: Provider<InvalidatingStagingRepositoryDescriptorRegistry>
+    ) {
+        @Suppress("UNUSED_VARIABLE") // Keep it consistent.
+        val retrieveStagingProfileTask = tasks.register<RetrieveStagingProfile>(
+            "retrieve${repo.capitalizedName}StagingProfile"
+        ) {
+            group = PublishingPlugin.PUBLISH_TASK_GROUP
+            description = "Gets and displays a staging profile id for a given repository and package group. " +
+                "This is a diagnostic task to get the value and " +
+                "put it into the NexusRepository configuration closure as stagingProfileId."
+            repository.convention(repo)
+            packageGroup.convention(extension.packageGroup)
+        }
+        val initializeTask = tasks.register<InitializeNexusStagingRepository>(
+            "initialize${repo.capitalizedName}StagingRepository"
+        ) {
+            group = PublishingPlugin.PUBLISH_TASK_GROUP
+            description = "Initializes the staging repository in '${repo.name}' Nexus instance."
+            registry.set(registryProvider)
+            repository.convention(repo)
+            packageGroup.convention(extension.packageGroup)
+        }
+        val findStagingRepository = tasks.register<FindStagingRepository>(
+            "find${repo.capitalizedName}StagingRepository"
+        ) {
+            group = PublishingPlugin.PUBLISH_TASK_GROUP
+            description = "Finds the staging repository for ${repo.name}"
+            registry.set(registryProvider)
+            repository.convention(repo)
+            packageGroup.convention(extension.packageGroup)
+            descriptionRegex.convention(extension.repositoryDescription.map { "\\b" + Regex.escape(it) + "(\\s|$)" })
+        }
+        val closeTask = tasks.register<CloseNexusStagingRepository>(
+            "close${repo.capitalizedName}StagingRepository"
+        ) {
+            group = PublishingPlugin.PUBLISH_TASK_GROUP
+            description = "Closes open staging repository in '${repo.name}' Nexus instance."
+            repository.convention(repo)
+        }
+        val releaseTask = tasks.register<ReleaseNexusStagingRepository>(
+            "release${repo.capitalizedName}StagingRepository"
+        ) {
+            group = PublishingPlugin.PUBLISH_TASK_GROUP
+            description = "Releases closed staging repository in '${repo.name}' Nexus instance."
+            repository.convention(repo)
+        }
+        val closeAndReleaseTask = tasks.register<Task>(
+            "closeAndRelease${repo.capitalizedName}StagingRepository"
+        ) {
+            group = PublishingPlugin.PUBLISH_TASK_GROUP
+            description = "Closes and releases open staging repository in '${repo.name}' Nexus instance."
+        }
+
+        closeTask {
+            mustRunAfter(initializeTask)
+            mustRunAfter(findStagingRepository)
+        }
+        releaseTask {
+            mustRunAfter(initializeTask)
+            mustRunAfter(findStagingRepository)
+            mustRunAfter(closeTask)
+        }
+        closeAndReleaseTask {
+            dependsOn(closeTask, releaseTask)
+        }
+    }
+
     private fun configurePublishingForAllProjects(rootProject: Project, extension: NexusPublishExtension, registry: Provider<InvalidatingStagingRepositoryDescriptorRegistry>) {
         rootProject.afterEvaluate {
             allprojects {
@@ -194,8 +221,8 @@ class NexusPublishPlugin : Plugin<Project> {
                             val closeTask = rootProject.tasks.named<CloseNexusStagingRepository>("close${nexusRepo.capitalizedName}StagingRepository")
                             val releaseTask = rootProject.tasks.named<ReleaseNexusStagingRepository>("release${nexusRepo.capitalizedName}StagingRepository")
                             val publishAllTask = publishingProject.tasks.register("publishTo${nexusRepo.capitalizedName}") {
-                                description = "Publishes all Maven/Ivy publications produced by this project to the '${nexusRepo.name}' Nexus repository."
                                 group = PublishingPlugin.PUBLISH_TASK_GROUP
+                                description = "Publishes all Maven/Ivy publications produced by this project to the '${nexusRepo.name}' Nexus repository."
                             }
                             closeTask {
                                 mustRunAfter(publishAllTask)
@@ -228,11 +255,11 @@ class NexusPublishPlugin : Plugin<Project> {
         registry: Provider<InvalidatingStagingRepositoryDescriptorRegistry>
     ): ArtifactRepository = when (publicationType) {
         PublicationType.MAVEN -> project.theExtension<PublishingExtension>().repositories.maven {
-            configureArtifactRepo(nexusRepo, project, extension, registry, false)
+            configureArtifactRepo(nexusRepo, extension, registry, false)
         }
 
         PublicationType.IVY -> project.theExtension<PublishingExtension>().repositories.ivy {
-            configureArtifactRepo(nexusRepo, project, extension, registry, true)
+            configureArtifactRepo(nexusRepo, extension, registry, true)
             if (nexusRepo.ivyPatternLayout.isPresent) {
                 nexusRepo.ivyPatternLayout.get().let { this.patternLayout(it) }
             } else {
@@ -243,17 +270,12 @@ class NexusPublishPlugin : Plugin<Project> {
 
     private fun <T> T.configureArtifactRepo(
         nexusRepo: NexusRepository,
-        project: Project,
         extension: NexusPublishExtension,
         registry: Provider<InvalidatingStagingRepositoryDescriptorRegistry>,
         provideFallback: Boolean
     ) where T : UrlArtifactRepository, T : ArtifactRepository, T : AuthenticationSupported {
         name = nexusRepo.name
-        setUrl(
-            project.provider {
-                getRepoUrl(nexusRepo, extension, registry, provideFallback, this)
-            }
-        )
+        setUrl(getRepoUrl(nexusRepo, extension, registry, provideFallback, this))
         val allowInsecureProtocol = nexusRepo.allowInsecureProtocol.orNull
         if (allowInsecureProtocol != null) {
             isAllowInsecureProtocol = allowInsecureProtocol
@@ -308,17 +330,21 @@ class NexusPublishPlugin : Plugin<Project> {
         registry: Provider<InvalidatingStagingRepositoryDescriptorRegistry>,
         provideFallback: Boolean,
         artifactRepo: ArtifactRepository
-    ) = if (extension.useStaging.get()) {
-        val descriptorRegistry = registry.get()
-        if (provideFallback) {
-            descriptorRegistry.invalidateLater(nexusRepo.name, artifactRepo)
-            descriptorRegistry.tryGet(nexusRepo.name)?.stagingRepositoryUrl ?: nexusRepo.nexusUrl.get()
-        } else {
-            descriptorRegistry[nexusRepo.name].stagingRepositoryUrl
+    ): Provider<URI> =
+        extension.useStaging.flatMap { useStaging ->
+            if (useStaging) {
+                registry.map { descriptorRegistry ->
+                    if (provideFallback) {
+                        descriptorRegistry.invalidateLater(nexusRepo.name, artifactRepo)
+                        descriptorRegistry.tryGet(nexusRepo.name)?.stagingRepositoryUrl ?: nexusRepo.nexusUrl.get()
+                    } else {
+                        descriptorRegistry[nexusRepo.name].stagingRepositoryUrl
+                    }
+                }
+            } else {
+                nexusRepo.snapshotRepositoryUrl
+            }
         }
-    } else {
-        nexusRepo.snapshotRepositoryUrl.get()
-    }
 
     private fun configureSimplifiedCloseAndReleaseTask(rootProject: Project, extension: NexusPublishExtension) {
         if (extension.repositories.isNotEmpty()) {
@@ -344,7 +370,8 @@ class NexusPublishPlugin : Plugin<Project> {
     }
 }
 
-inline fun <reified T : Any> Project.theExtension(): T =
+private inline fun <reified T : Any> Project.theExtension(): T =
     typeOf<T>().let {
-        this.extensions.findByType(it) ?: throw IllegalStateException("The plugin cannot be applied without the publishing plugin")
+        this.extensions.findByType(it)
+            ?: error("The plugin cannot be applied without the publishing plugin")
     }
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/NexusRepository.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/NexusRepository.kt
index 52881182..8be42c23 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/NexusRepository.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/NexusRepository.kt
@@ -57,7 +57,7 @@ abstract class NexusRepository @Inject constructor(@Input val name: String) {
     abstract val stagingProfileId: Property<String>
 
     @get:Internal
-    internal val capitalizedName by lazy { name.capitalize() }
+    internal val capitalizedName: String by lazy { name.capitalize() }
 
     @get:Optional
     @get:Input
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/ReleaseNexusStagingRepository.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/ReleaseNexusStagingRepository.kt
index 918eef4c..4baaf6ec 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/ReleaseNexusStagingRepository.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/ReleaseNexusStagingRepository.kt
@@ -16,21 +16,13 @@
 
 package io.github.gradlenexus.publishplugin
 
-import io.github.gradlenexus.publishplugin.internal.InvalidatingStagingRepositoryDescriptorRegistry
 import io.github.gradlenexus.publishplugin.internal.StagingRepositoryTransitioner
-import org.gradle.api.model.ObjectFactory
-import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.options.Option
-import javax.inject.Inject
 
-abstract class ReleaseNexusStagingRepository @Inject constructor(
-    objects: ObjectFactory,
-    repository: NexusRepository,
-    registry: Provider<InvalidatingStagingRepositoryDescriptorRegistry>
-) : AbstractTransitionNexusStagingRepositoryTask(objects, repository, registry) {
+abstract class ReleaseNexusStagingRepository : AbstractTransitionNexusStagingRepositoryTask() {
 
     @Option(option = "staging-repository-id", description = "staging repository id to release")
-    fun setStagingRepositoryId(stagingRepositoryId: String) {
+    fun setStagingRepositoryIdToRelease(stagingRepositoryId: String) {
         this.stagingRepositoryId.set(stagingRepositoryId)
     }
 
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/RetrieveStagingProfile.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/RetrieveStagingProfile.kt
index 822a2f93..d44bc8a0 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/RetrieveStagingProfile.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/RetrieveStagingProfile.kt
@@ -19,26 +19,18 @@ package io.github.gradlenexus.publishplugin
 import io.github.gradlenexus.publishplugin.internal.NexusClient
 import org.gradle.api.GradleException
 import org.gradle.api.Incubating
-import org.gradle.api.model.ObjectFactory
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.TaskAction
-import org.gradle.kotlin.dsl.property
-import javax.inject.Inject
 
 /**
  * Diagnostic task for retrieving the [NexusRepository.stagingProfileId] for the [packageGroup] from the provided [NexusRepository] and logging it
  */
 @Incubating
-abstract class RetrieveStagingProfile @Inject constructor(
-    objects: ObjectFactory,
-    extension: NexusPublishExtension,
-    repository: NexusRepository
-) : AbstractNexusStagingRepositoryTask(objects, repository) {
+abstract class RetrieveStagingProfile : AbstractNexusStagingRepositoryTask() {
 
-    @Input
-    val packageGroup = objects.property<String>().apply {
-        set(extension.packageGroup)
-    }
+    @get:Input
+    abstract val packageGroup: Property<String>
 
     @TaskAction
     fun retrieveStagingProfile() {
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/InvalidatingStagingRepositoryDescriptorRegistry.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/InvalidatingStagingRepositoryDescriptorRegistry.kt
index a959669e..541e28c2 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/InvalidatingStagingRepositoryDescriptorRegistry.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/InvalidatingStagingRepositoryDescriptorRegistry.kt
@@ -44,11 +44,12 @@ class InvalidatingStagingRepositoryDescriptorRegistry : StagingRepositoryDescrip
         private fun ArtifactRepository.invalidate() {
             if (this is AbstractResolutionAwareArtifactRepository<*>) {
                 try {
-                    val invalidateDescriptorMethod = AbstractResolutionAwareArtifactRepository::class.java.declaredMethods.find { it.name.contains("invalidateDescriptor") }
-                    invalidateDescriptorMethod?.isAccessible = true
-                    invalidateDescriptorMethod?.invoke(this)
+                    AbstractResolutionAwareArtifactRepository::class.java
+                        .getDeclaredMethod("invalidateDescriptor")
+                        .apply { isAccessible = true }
+                        .invoke(this)
                 } catch (e: Exception) {
-                    log.warn("Failed to invalidate artifacty repository URL, publishing will not work correctly")
+                    log.warn("Failed to invalidate artifact repository URL, publishing will not work correctly.")
                 }
             }
         }
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/StagingRepository.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/StagingRepository.kt
index eb08f515..56657bfb 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/StagingRepository.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/StagingRepository.kt
@@ -33,7 +33,7 @@ data class StagingRepository constructor(val id: String, val state: State, val t
                 try {
                     return valueOf(stateAsString.toUpperCase())
                 } catch (e: IllegalArgumentException) {
-                    throw IllegalStateException("Unsupported repository state '$stateAsString'. Supported values: ${values()}")
+                    error("Unsupported repository state '$stateAsString'. Supported values: ${values()}")
                 }
             }
         }
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/StagingRepositoryDescriptor.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/StagingRepositoryDescriptor.kt
index 5d90dcb5..52b4ae32 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/StagingRepositoryDescriptor.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/StagingRepositoryDescriptor.kt
@@ -19,7 +19,7 @@ package io.github.gradlenexus.publishplugin.internal
 import java.net.URI
 
 data class StagingRepositoryDescriptor(private val baseUrl: URI, val stagingRepositoryId: String) {
-    val stagingRepositoryUrl by lazy {
+    val stagingRepositoryUrl: URI by lazy {
         URI.create("${baseUrl.toString().removeSuffix("/")}/staging/deployByRepositoryId/$stagingRepositoryId")
     }
 }
diff --git a/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/StagingRepositoryDescriptorRegistry.kt b/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/StagingRepositoryDescriptorRegistry.kt
index bfd2632b..58d696c4 100644
--- a/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/StagingRepositoryDescriptorRegistry.kt
+++ b/src/main/kotlin/io/github/gradlenexus/publishplugin/internal/StagingRepositoryDescriptorRegistry.kt
@@ -26,7 +26,7 @@ open class StagingRepositoryDescriptorRegistry {
         mapping[name] = descriptor
     }
 
-    operator fun get(name: String) = mapping[name] ?: throw IllegalStateException("No staging repository with name $name created")
+    operator fun get(name: String) = mapping[name] ?: error("No staging repository with name $name created")
 
     fun tryGet(name: String) = mapping[name]