* </ul>
 *
 * <p>
 * A value source implementation will most likely take parameters. To do this create a
 * subtype of {@link ValueSourceParameters} and declare this type as the type parameter
 * to the value source implementation.
 * </p>
 *
 * <p>
 * A value source implementation doesn't have to be thread-safe, as the single call
 * to {@link #obtain()} is synchronized.
 * </p>

    api(project(":declarative-dsl-tooling-models"))
    api(libs.kotlinStdlib)


    implementation(libs.inject)
    testImplementation(libs.mockitoKotlin2)

    implementation(project(":base-services"))
    implementation(project(":resources"))
    implementation(project(":model-core"))

    implementation(libs.guava)
    implementation(libs.kotlinReflect)

    integTestImplementation(project(":internal-testing"))

plugins {
    id("gradlebuild.distribution.implementation-java")
}

description = "Provides high-level insights into a Gradle build (--profile)"

dependencies {
    api(projects.stdlibJavaExtensions)
    api(projects.serviceProvider)
    api(projects.time)
    api(project(":base-services"))
    api(project(":core"))
    api(project(":core-api"))
    api(project(":enterprise-logging"))

    implementation(project(":logging"))

    api(project(":problems-api"))
    api(project(":snapshots"))

    implementation(projects.time)
    implementation(project(":logging"))
    implementation(projects.enterpriseOperations) {
        because("Adds generic build operations for the execution engine")
    }

    implementation(libs.commonsLang)
    implementation(libs.commonsIo)

    testImplementation(project(":native"))

 */

plugins {
    id("gradlebuild.distribution.implementation-java")
}

description = "Controls for the instrumentation agent potentially applied to the process"

dependencies {
    api(projects.stdlibJavaExtensions)

    implementation(projects.baseServices)
    implementation(projects.functional)

    implementation(libs.jsr305)
    implementation(libs.slf4jApi)

            dependencies {
                implementation(kotlin("test-common"))
                implementation(kotlin("test-annotations-common"))
            }
        }

        named("jsTest") {
            dependencies {
                implementation(kotlin("test-js"))
            }
        }

        named("jvmTest") {
            dependencies {
                implementation(kotlin("test-junit5"))

    api(project(":hashing"))
    api(project(":base-services"))
    api(project(":messaging"))
    api(project(":native"))

    api(libs.jsr305)

    implementation(project(":files"))
    implementation(project(":logging"))

    implementation(libs.guava)
    implementation(libs.commonsIo)

    testImplementation(project(":process-services"))
    testImplementation(project(":core-api"))

    api(project(":stdlib-java-extensions"))
    api(project(":daemon-protocol"))
    api(project(":logging"))

    implementation(project(":core-api"))
    implementation(project(":messaging"))
    implementation(project(":concurrent"))
    implementation(project(":logging-api"))
    implementation(project(":problems-api"))

    api(project(":file-collections"))
    api(project(":jvm-services"))
    api(project(":persistent-cache"))
    api(project(":core"))

    implementation(project(":logging"))
    implementation(libs.guava)
    implementation(libs.slf4jApi)
    implementation(libs.commonsIo)
    implementation(libs.commonsLang)

    testImplementation(testFixtures(project(":core")))

    testRuntimeOnly(project(":distributions-jvm")) {

    api(libs.asm)
    api(libs.javaPoet)
    api(libs.jsr305)

    implementation(libs.asmTree)
    implementation(libs.jacksonAnnotations)
    implementation(libs.jacksonDatabind)

    implementation(projects.stdlibJavaExtensions)
    implementation(project(":base-services"))
    implementation(project(":base-asm"))

    testCompileOnly(libs.jetbrainsAnnotations)