In addition to individual updates that happen on demand, all dependencies in
the std and cmd modules are updated to their latest available versions at least
twice during every major release cycle. This is done to avoid the possibility of
some dependencies being left on very old versions and in turn make their eventual

      - name: Setup uv
        uses: astral-sh/setup-uv@v7
        with:
          enable-cache: true
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
      - name: Install Dependencies
        run: uv sync --locked --no-dev --group github-actions
      # Allow debugging with tmate
      - name: Setup tmate session
        uses: mxschmitt/action-tmate@v3

      - name: Setup uv
        uses: astral-sh/setup-uv@v7
        with:
          enable-cache: true
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
      - name: Install Dependencies
        run: uv sync --locked --no-dev --group github-actions
      # Allow debugging with tmate
      - name: Setup tmate session
        uses: mxschmitt/action-tmate@v3

}

val resolvableConfigurations = configurations.filter { it.isCanBeResolved }
tasks.register("downloadDependencies") {
  description = "Download all dependencies to the Gradle cache"
  doLast {
    for (configuration in resolvableConfigurations) {
      configuration.files
    }
  }
}

normalization {
  runtimeClasspath {
    metaInf {

  "${it.module.group}:${it.module.name}:${it.versionConstraint.requiredVersion}"
}


val testRuntimeOnly = configurations.maybeCreate("testRuntimeOnly")
dependencies {
  testRuntimeOnly(library("junit-jupiter-engine"))
  testRuntimeOnly(library("junit-vintage-engine"))
  testRuntimeOnly(library("junit-platform-launcher"))
}

tasks.withType<Test> {
  useJUnitPlatform()

    ktlint()
  }
  kotlinGradle {
    target("*.kts")
    targetExclude("build/**/*.kts")
    ktlint()
  }
}

repositories {
  google()
  mavenCentral()
  gradlePluginPortal()
}

dependencies {
  implementation(libs.gradlePlugin.kotlin)
  implementation(libs.gradlePlugin.mavenPublish)
  implementation(libs.gradlePlugin.dokka)
  implementation(libs.gradlePlugin.binaryCompatibilityValidator)

  - [Dependencies](#dependencies-8)
    - [Added](#added-8)
    - [Changed](#changed-8)
    - [Removed](#removed-8)
- [v1.18.11](#v11811)
  - [Downloads for v1.18.11](#downloads-for-v11811)
  - [Changelog since v1.18.10](#changelog-since-v11810)
  - [Changes by Kind](#changes-by-kind-8)
    - [Bug or Regression](#bug-or-regression-8)
  - [Dependencies](#dependencies-9)
    - [Added](#added-9)

            // Verify child elements namespace updated recursively
            Element dependencies = DomUtils.findChildElement(root, "dependencies");
            assertNotNull(dependencies);
            assertEquals(expectedNamespaceUri, dependencies.namespaceURI());

            Element dependency = DomUtils.findChildElement(dependencies, "dependency");
            assertNotNull(dependency);

        if (isContinue) "--continue" else "",
    )

fun Dependencies.dependsOn(buildTypeId: RelativeId) {
    dependency(buildTypeId) {
        snapshot {
            onDependencyFailure = FailureAction.FAIL_TO_START
            onDependencyCancel = FailureAction.FAIL_TO_START
        }
    }
}

fun Dependencies.compileAllDependency(compileAllId: String) {

    Guava is a suite of core and expanded libraries that include
    utility classes, Google's collections, I/O classes, and
    much more.
  </description>
  <url>https://github.com/google/guava</url>
  <dependencies>
    <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>failureaccess</artifactId>
      <version>${failureaccess.version}</version>
    </dependency>
    <dependency>