instantiatorFactory: InstantiatorFactory,
        services: ServiceRegistry,
    ): FlowScheduler = FlowScheduler(
        instantiatorFactory,
        services,
    )

    @Provides
    fun createFlowParametersInstantiator(
        inspectionSchemeFactory: InspectionSchemeFactory,
        instantiatorFactory: InstantiatorFactory,
        services: ServiceRegistry,
    ) = FlowParametersInstantiator(

import org.gradle.internal.service.ServiceRegistry


internal
inline fun <reified T : Any> TaskInternal.serviceOf(): T =
    project.serviceOf()


inline fun <reified T : Any> Project.serviceOf(): T =
    (this as ProjectInternal).services.get()


inline fun <reified T : Any> GradleInternal.serviceOf(): T =
    services.get()


inline fun <reified T : Any> ServiceRegistry.get(): T =

        override fun <T> service(type: Class<T>): T = delegate.service(type)
    }

    class OwnerFlowScope(override val delegate: Gradle) : IsolateOwners() {
        override fun <T> service(type: Class<T>): T = (delegate as GradleInternal).services.get(type)
    }

    class OwnerFlowAction(override val delegate: OwnerFlowScope) : IsolateOwners() {
        override fun <T> service(type: Class<T>): T = delegate.service(type)
    }

            val settingsSource = TextResourceScriptSource(service<TextFileResourceLoader>().loadFile("settings file", settingsFile))
            lateinit var services: SettingsScopeServices
            val serviceRegistryFactory = object : ServiceRegistryFactory {
                override fun createFor(domainObject: Any): ServiceRegistry {
                    services = SettingsScopeServices(service<ServiceRegistry>(), domainObject as SettingsInternal)

    fileOperationsFor((gradle as GradleInternal).services, baseDir)


internal
fun fileOperationsFor(services: ServiceRegistry, baseDir: File?): FileOperations {
    val fileLookup = services.get<FileLookup>()
    val fileResolver = baseDir?.let { fileLookup.getFileResolver(it) } ?: fileLookup.fileResolver
    val fileCollectionFactory = services.get<FileCollectionFactory>().withResolver(fileResolver)

            val transform = readNonNull<Transform>()
            val project = getProject(path)
            val services = project.services
            TransformStep(
                transform,
                services[TransformInvocationFactory::class.java],
                services[DomainObjectContext::class.java],
                inputFingerprinter
            )
        }
    }

import org.gradle.internal.cc.impl.problems.ConfigurationCacheReport
import org.gradle.internal.serialize.beans.services.BeanConstructors
import org.gradle.internal.cc.impl.services.DefaultIsolatedProjectEvaluationListenerProvider
import org.gradle.internal.cc.impl.services.IsolatedActionCodecsFactory
import org.gradle.internal.cc.impl.services.RemoteScriptUpToDateChecker
import org.gradle.execution.ExecutionAccessChecker

dependencies {
    api(projects.stdlibJavaExtensions)
    api(projects.serialization)
    api(project(":core-api"))
    api(project(":problems-api"))
    api(project(":hashing"))
    api(project(":process-services"))
    api(project(":base-services"))
    api(project(":files"))
    api(project(":functional"))
    api(project(":logging"))
    api(project(":messaging"))
    api(project(":persistent-cache"))
    api(project(":snapshots"))

import org.gradle.api.initialization.Settings
import org.gradle.api.invocation.Gradle
import org.gradle.api.project.IsolatedProject
import org.gradle.api.publish.Publication
import org.gradle.api.services.BuildService
import org.gradle.api.services.internal.BuildServiceProvider
import org.gradle.api.tasks.SourceSet
import org.gradle.api.tasks.SourceSetContainer
import org.gradle.api.tasks.TaskContainer
import org.gradle.api.tasks.TaskDependency

    api(libs.kotlinReflect)

    implementation(projects.io)
    implementation(project(":base-services"))
    implementation(project(":enterprise-operations"))
    implementation(project(":functional"))
    implementation(project(":messaging"))
    implementation(project(":logging"))
    implementation(project(":process-services"))
    implementation(project(":persistent-cache"))
    implementation(project(":core-api"))