void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile
                    println "processing [\${input.name}]"
                    assert ${lenient} || input.file
                    def output = outputs.file(input.name + "." + parameters.targetColor.get())
                    if (input.file) {
                        output.text = input.text + "-" + parameters.targetColor.get()

For the aforementioned reasons, task output caching is automatically disabled for tasks whose output directories overlap with another task.

Build scans show tasks where caching was disabled due to overlapping outputs in the timeline:

[.screenshot]
image::build-cache/overlapping-outputs-timeline.png[]

== Reuse of outputs between different tasks

                outputs.file("output.txt")
                    .withPropertyName("$NON_ASCII_NAME")
                outputs.cacheIf { true }
                doLast {
                    file("output.txt").text = "output"
                }
            }
        """

        when:
        withBuildCache().run("createFile", "-Dfile.encoding=$fileEncoding")
        then:

        output.contains "Task 'b' file 'output.txt' with 'output-file'"
        output.contains "Task 'b2' file 'output.txt' with 'output-file'"

        when:
        succeeds "b", "b2"

        then:
        result.assertTasksSkipped(':a')
        result.assertTasksNotSkipped(':b', ':b2')
        output.contains "Task 'b' file 'output.txt' with 'output-file'"

// Fatal outputs a message at fatal level.
func Fatal(fields any) {
	defaultScope.Fatal(fields)
}

// Fatalf uses fmt.Sprintf to construct and log a message at fatal level.
func Fatalf(format string, args ...any) {
	defaultScope.Fatalf(format, args...)
}

// FatalEnabled returns whether output of messages using this scope is currently enabled for fatal-level output.
func FatalEnabled() bool {

                // See https://github.com/gradle/gradle/issues/18460.
                LOGGER.debug("More outputs are being registered even though the build output cleanup registry has already been finalized. New outputs: {}", files);
            } else {
                this.outputs.add(fileCollectionFactory.resolving(files));
            }
        }
    }

    @Override

        outputs.add(output);
    }

    /**
     * Returns concatenated non-empty output entries.
     */
    public String getOutput() {
        List<String> nonEmptyOutputs = filter(outputs, string -> !string.equals(""));
        return join("\n", nonEmptyOutputs);
    }

    /**
     * Returns all output entries.
     */
    public List<String> getOutputs() {
        return outputs;
    }

    /**

                void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile
                    println "processing \${input.name} using \${parameters.someFiles*.name}"
                    def output = outputs.file(input.name + ".green")
                    def paramContent = parameters.someFiles.collect { it.file ? it.text : it.list().length }.join("")
                    output.text = input.text + paramContent + ".green"

  Output live0 = ops::Add(root.WithOpName("live0"), m0.output, m1.output);
  Output live1 = ops::Add(root.WithOpName("live1"), m2.output, m3.output);

  Output halfdead0 =
      ops::Add(root.WithOpName("halfdead0"), m0.output, m2.output);
  Output halfdead1 =
      ops::Add(root.WithOpName("halfdead1"), m1.output, m3.output);

  std::unique_ptr<DeadnessAnalysis> result;

public class OutputSnapshotUtil {

    /**
     * Finds outputs that are still present since the last execution when overlapping outputs are present.
     *
     * Note: when there are no overlapping outputs, all outputs currently existing in the output locations
     * are considered outputs of the work.
     *
     * If a property did not exist after the previous execution then all the outputs for it will be ignored.
     *