ModelActionRole role = actionInRole.getKey();
                            ModelAction action = actionInRole.getValue();
                            node.applyToSelf(role, action);
                        }
                    }
                });
            }

            registration.action(ModelActionRole.Initialize,

        schedulePendingActions()
    }

    override fun <P : FlowParameters> always(
        action: Class<out FlowAction<P>>,
        configure: Action<in FlowActionSpec<P>>
    ): FlowScope.Registration<P> {
        val parameters = configureParametersFor(action, configure)
        val registeredFlowAction = RegisteredFlowAction(action.uncheckedCast(), parameters)
        state.add(registeredFlowAction)

      contents: read
    runs-on: ubuntu-latest
    needs: build
    steps:
      - name: git clone
        uses: actions/checkout@v4
      - name: setup java
        uses: actions/setup-java@v4
        with:
          distribution: temurin
          java-version: 11
      - uses: actions/download-artifact@v4
        with:
          name: build-receipt.properties

 */

package org.gradle.model.internal.manage.schema.extract;

import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.Multimap;
import org.gradle.api.Action;
import org.gradle.internal.BiAction;
import org.gradle.model.internal.core.ChildNodeInitializerStrategy;
import org.gradle.model.internal.core.ChildNodeInitializerStrategyAccessor;

        modelNode.addLink(
            ModelRegistrations.of(modelNode.getPath().child(name))
                .action(ModelActionRole.Create, NODE_INITIALIZER_REGISTRY_MODEL_REFERENCE, new BiAction<MutableModelNode, NodeInitializerRegistry>() {
                    @Override
                    public void execute(MutableModelNode node, NodeInitializerRegistry nodeInitializerRegistry) {

    Defaults(ModelNode.State.DefaultsApplied, true), // Allows a mutation to setup default values for an element
    Initialize(ModelNode.State.Initialized, true), // Mutation action provided when an element is defined
    Mutate(ModelNode.State.Mutated, true), // Customisations
    Finalize(ModelNode.State.Finalized, true), // Post customisation default values

                }
            }
        }
    }
}

fun BuildScanConfiguration.whenEnvIsSet(envName: String, action: BuildScanConfiguration.(envValue: String) -> Unit) {
    val envValue: String? = environmentVariable(envName).orNull
    if (!envValue.isNullOrEmpty()) {
        action(envValue)
    }
}

fun Project.extractWatchFsData() {

    @Requires(
        value = IntegTestPreconditions.IsConfigCached,
        reason = "Isolation provided by Configuration Cache serialization"
    )
    def 'flow actions are isolated from each other'() {
        given: 'flow actions that share a bean'
        buildFile '''
            import org.gradle.api.flow.*
            import org.gradle.api.services.*
            import java.util.concurrent.atomic.AtomicInteger

        delegate.collectionSchema

    override fun whenObjectRemoved(action: Action<in T>): Action<in T> =
        delegate.whenObjectRemoved(action)

    override fun whenObjectRemoved(action: Closure<Any>) =
        delegate.whenObjectRemoved(action)

    override fun findAll(spec: Closure<Any>): MutableSet<T> =
        delegate.findAll(spec)

    private final ModelAction action;
    private final List<BindingPredicate> inputReferences;
    private final Collection<RuleBinder> binders;

    private int inputsBound;
    private final List<ModelBinding> inputBindings;

    public RuleBinder(BindingPredicate subjectReference, List<BindingPredicate> inputReferences, ModelAction action, Collection<RuleBinder> binders) {
        this.action = action;