val arch = if (os == Os.MACOS) Arch.AARCH64 else Arch.AMD64
                    if (os == Os.WINDOWS) {
                        listOf("jprofiler")
                    } else {
                        listOf("async-profiler", "async-profiler-heap")
                    }.map { FlameGraphGenerationBuildSpec(scenario, os, arch, it) }
                }
            }

        val buildScanTagForGroovyMajor = buildScanTagParam("Groovy$bundleGroovyMajor")
        val buildScanTags =
            if (bundleGroovyMajor != null) listOf(buildScanTagForType, buildScanTagForGroovyMajor) else listOf(buildScanTagForType)
        val extraSysProp = mutableListOf<String>()
        val extraTasks = mutableListOf<String>()
        if (bundleGroovyMajor != null) {

import projects.StageProject

val stageWithOsTriggers: Map<StageName, List<Os>> =
    mapOf(
        StageName.PULL_REQUEST_FEEDBACK to listOf(Os.LINUX, Os.WINDOWS),
        StageName.READY_FOR_NIGHTLY to listOf(Os.LINUX, Os.WINDOWS, Os.MACOS),
        StageName.READY_FOR_RELEASE to listOf(Os.LINUX, Os.WINDOWS, Os.MACOS),
    )

class StageTriggers(
    model: CIBuildModel,
    stage: Stage,
    prevStage: Stage?,

import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.kotlin.readValue
import com.fasterxml.jackson.module.kotlin.registerKotlinModule
import java.io.File

val ignoredSubprojects =
    listOf(
        "soak", // soak test
        "distributions-integ-tests", // build distribution testing
        "architecture-test", // sanity check
    )

interface GradleSubprojectProvider {

tasks.withType<KotlinCompile> {
  compilerOptions {
    freeCompilerArgs = listOf("-module-name=okhttp")
  }
}

apply(plugin = "io.github.usefulness.maven-sympathy")

mavenPublishing {
  configure(KotlinMultiplatform(javadocJar = JavadocJar.Empty(), androidVariantsToPublish = listOf("release")))

                failureMessage = "This build might be leaking credentials"
                reverse = false
                stopBuildOnFailure = true
            }
        }
    }

    if (os !in listOf(Os.WINDOWS, Os.MACOS)) {
        steps {
            exec {
                name = "EC2_BUILD_CUSTOMIZATIONS"
                executionMode = BuildStep.ExecutionMode.ALWAYS

Para lograr esto, el backend `:80` debe tener una lista de "orígenes permitidos".

En este caso, la lista tendría que incluir `http://localhost:8080` para que el frontend `:8080` funcione correctamente.

## Comodines

También es posible declarar la lista como `"*"` (un "comodín") para decir que todos están permitidos.

    // Less than 16,384 chars, because we index on a 14-bit index in the ranges table.
    assertThat(compactTable.mappings.length).isLessThan(1 shl 14)

    // Confirm the data strings are ASCII.
    for (dataString in listOf<String>(compactTable.sections, compactTable.ranges)) {
      for (codePoint in dataString.codePoints()) {
        assertThat(codePoint and 0x7f).isEqualTo(codePoint)
      }
    }

    val parallelizationMethod: ParallelizationMethod,
) : BuildTypeBucket {
    constructor(
        subproject: GradleSubproject,
        parallelizationMethod: ParallelizationMethod,
    ) : this(listOf(subproject), parallelizationMethod)

    val name = truncateName(subprojects.joinToString(","))

    private fun truncateName(str: String) =
        // Can't exceed Linux file name limit 255 char on TeamCity

  fun getWithCustomSocketFactory() {
    client =
      client
        .newBuilder()
        .sslSocketFactory(CustomSSLSocketFactory(client.sslSocketFactory), client.x509TrustManager!!)
        .connectionSpecs(
          listOf(
            ConnectionSpec
              .Builder(ConnectionSpec.MODERN_TLS)
              .supportsTlsExtensions(false)
              .build(),
          ),
        ).eventListener(