import java.util.Optional;

/**
 * Summary result of the execution of the work scheduled for the current build.
 *
 * @see FlowProviders#getBuildWorkResult()
 * @since 8.1
 */
@Incubating
public interface BuildWorkResult {

    /**
     * A summary of the configuration time and execution time failure(s) that occurred as Gradle tried to execute the
     * scheduled work.
     *

    private
    val buildWorkResult by lazy {
        BuildWorkResultProvider()
    }

    override fun getBuildWorkResult(): Provider<BuildWorkResult> =
        buildWorkResult
}


class BuildWorkResultProvider : AbstractMinimalProvider<BuildWorkResult>() {

    private
    var result: BuildWorkResult? = null

    fun set(result: BuildWorkResult) {
        require(this.result == null)

                parameters.workResult = flowProviders.buildWorkResult
            }.get()

        '''

        expect:
        fails()

        and:
        // TODO(mlopatkin) The error message can be improved.
        failureHasCause(~/Could not isolate value ResultSource(.*) of type ResultSource.Params/)
    }

    def "task cannot depend on buildWorkResult, fails with clear message and problem is reported"() {

                }

                void apply($targetType target) {
                    flowScope.always(SetLavaLampColor) {
                        parameters.color = flowProviders.buildWorkResult.map {
                            it.failure.present ? 'red' : 'green'
                        }
                    }
                }
            }

     *                 )
     *             )
     *         );
     *     }
     * }
     * </pre>
     *
     * @see FlowAction
     * @see FlowScope
     */
    Provider<BuildWorkResult> getBuildWorkResult();

        state.add(registeredFlowAction)
        return DefaultFlowScopeRegistration()
    }

    private
    fun setBuildWorkResult(failure: Throwable?) {
        flowProviders.buildWorkResult.uncheckedCast<BuildWorkResultProvider>().apply {
            set { Optional.ofNullable(failure) }
        }
    }

    private
    fun schedulePendingActions() {

                    def projectDir = project.rootDir
                    def vfsService = project.gradle.services.get(VirtualFileSystem)
                    def projectDirAsResultOfBuild = flowProviders.buildWorkResult.map { projectDir }
                    flowScope.always(
                        VfsAction.class,
                        spec -> {
                            spec.getParameters().getRootDir().set(projectDirAsResultOfBuild)

You can obtain these providers from the link:{javadocPath}/org/gradle/api/flow/FlowProviders.html[FlowProviders] class.

[source,groovy]
----
flowProviders.buildWorkResult.map {
    [
        buildInvocationId: scopeIdsService.buildInvocationId,
        workspaceId: scopeIdsService.workspaceId,
        userId: scopeIdsService.userId
    ]
}
----

            def flowProviders = gradle.services.get(FlowProviders)
            flowScope.always(BuildFinishCall) {
                parameters.buildSuccess = flowProviders.buildWorkResult.map { result -> "Finished" }
            }
        """
    }

                text(" can only be used as input to flow actions.")
            }
        }
    }

    override suspend fun ReadContext.decode(): BuildWorkResultProvider {
        return flowProviders.buildWorkResult.uncheckedCast()
    }
}


object RegisteredFlowActionCodec : Codec<RegisteredFlowAction> {

    override suspend fun WriteContext.encode(value: RegisteredFlowAction) {