configurations {
    create("gradleScriptsElements") {
        isVisible = false
        isCanBeResolved = false
        isCanBeConsumed = true
        attributes.attribute(Usage.USAGE_ATTRIBUTE, objects.named("start-scripts"))
        outgoing.artifact(startScripts)
    }

 * If the compiled script is not found in this cache, it will try to find it in the global cache,
 * which will use the delegate script class compiler in case of a miss. The lookup in this cache is
 * more efficient than looking in the global cache, as we do not check the script's hash code here,
 * assuming that it did not change during the build.
 */

[[sec:basic_usage]]
== Using an init script

Initialization scripts, also called _init scripts_, are similar to other scripts in Gradle.
Initialization scripts run before the build starts.

They are useful for various purposes:

* Setting up enterprise-wide configurations (e.g., custom plugin locations)
* Configuring properties based on the environment (e.g., developer's machine vs. CI server)

     *
     * Gradle runtime.
     */
    ClassLoaderScope getBaseClassLoaderScope();

    /**
     * The scope for this settings object.
     *
     * Gradle runtime + this object's script's additions.
     */
    ClassLoaderScope getClassLoaderScope();

    ServiceRegistry getServices();

    @Override
    BuildCacheConfigurationInternal getBuildCache();

    @Override

create in the script's temporary file system before it starts executing.

As an example, run_hello.txt says:

	# hello world
	go run hello.go
	stderr 'hello world'
	! stdout .

	-- hello.go --
	package main
	func main() { println("hello world") }

Each script runs in a fresh temporary work directory tree, available to scripts as $WORK.

		})
}

func scriptHandle() script.Cmd {
	return script.Command(
		script.CmdUsage{
			Summary: "set the HTTP handler that will serve the script's output",
			Args:    "handler [dir]",
			Detail: []string{
				"The handler will be passed the script's current working directory and environment as arguments.",
				"Valid handlers include 'dir' (for general http.Dir serving), 'bzr', 'fossil', 'git', and 'hg'",
			},
		},

func (s *State) Getwd() string { return s.pwd }

// Logf writes output to the script's log without updating its stdout or stderr
// buffers. (The output log functions as a kind of meta-stderr.)
func (s *State) Logf(format string, args ...any) {
	fmt.Fprintf(&s.log, format, args...)
}

// flushLog writes the contents of the script's log to w and clears the log.
func (s *State) flushLog(w io.Writer) error {

        loadValidatedToolingModel(KotlinDslScriptsModel)
    }

    def 'exceptions in different scripts are reported on the corresponding scripts'() {

        given:
        requireIsolatedUserHome()

        when:
        def spec = withMultipleSubprojects()
        spec.scripts["a"] << "throw RuntimeException(\"ex1\")"
        spec.scripts["b"] << "throw RuntimeException(\"ex2\")"

        def scripts = []

        when:
        finder.findScripts(scripts)

        then:
        scripts.empty
    }

    def "does nothing when init.d directory does not exist in distribution"() {
        def scripts = []

        when:
        finder.findScripts(scripts)

        then:
        scripts.empty
    }

import java.util.Map;


/**
 * Editor model for a set of Kotlin DSL scripts.
 * <p>
 * Can only be requested on the root project, the builder will throw otherwise.
 * <p>
 * Requires the <code>prepareKotlinBuildScriptModel</code> task to be executed before building the model.
 * See {@link KotlinDslModelsParameters#PREPARATION_TASK_NAME}
 * <p>