if (c != null) {
                //there is already registered conflict with at least one matching participant, hook up to this conflict
                c.candidates = candidates;
                c.participants.addAll(participants);
                return c;
            }
        }

        //No conflict with matching participants found, create new
        Conflict c = new Conflict(participants, candidates);

@startuml
box ":toolingApi side"
  participant ConsumerConnection
  participant ModelProducer
end box
box ":launcher side"
  participant DefaultConnection
  participant ProviderConnection
end box

ConsumerConnection -> ModelProducer: request
activate ModelProducer
ModelProducer -> DefaultConnection: request
note right
DefaultConnection has entry points to accept calls from different ToolingAPI versions
end note

        }
        return new HasConflict(conflict.participants);
    }

    static PotentialConflict noConflict() {
        return NO_CONFLICT;
    }

    private static class HasConflict implements PotentialConflict {

        private final Set<ModuleIdentifier> participants;

        private HasConflict(Set<ModuleIdentifier> participants) {
            this.participants = participants;
        }

        @Override

OperationParamsBuilder --> LongRunningOperation: operation params
LongRunningOperation -> AsyncConsumerActionExecutor: run()
box "ConsumerActionExecutor chain"
	participant ProgressLogging
	participant LoggingInitializer
	participant LazyConsumer
end box
AsyncConsumerActionExecutor -> ProgressLogging: run()
ProgressLogging -> LoggingInitializer: run()
LoggingInitializer -> LazyConsumer: run()

        Dispatch<String> client1Handler = Mock()
        Dispatch<String> client2Handler = Mock()
        Dispatch<String> serverHandler = Mock()
        def server = new Participant()
        def client1 = new Participant()
        def client2 = new Participant()
        client1.connectTo(server)
        client2.connectTo(server)
        server.addHandler("channel", serverHandler)
        client1.addHandler("channel", client1Handler)

<project>
  <modelVersion>4.0.0</modelVersion>

  <groupId>lifecycle-participant-reactor-dependency-injection</groupId>
  <artifactId>parent</artifactId>
  <version>1.0</version>
  <packaging>pom</packaging>

  <modules>
    <module>module-a</module>
    <module>module-b</module>
  </modules>

        List<String> reactorOrder =
                getReactorOrder("lifecycle-participant-reactor-dependency-injection", InjectReactorDependency.class);
        assertEquals(Arrays.asList("parent", "module-b", "module-a"), reactorOrder);
    }

    private <T> List<String> getReactorOrder(String testProject, Class<T> participant) throws Exception {
        PlexusContainer container = getContainer();

<project>
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>lifecycle-participant-reactor-dependency-injection</groupId>
    <artifactId>parent</artifactId>
    <version>1.0</version>
  </parent>

  <artifactId>module-b</artifactId>

🔁 🛠️ 🌅 ⚖️ 🌘 💖 👉 📊. 🕰 💧 ⚪️➡️ 🔝 🔝. & 🔠 🏓 1️⃣ 🍕 🔗 ⚖️ 🛠️ 📟.

```mermaid
sequenceDiagram

participant client as Client
participant handler as Exception handler
participant dep as Dep with yield
participant operation as Path Operation
participant tasks as Background tasks

    Note over client,tasks: Can raise exception for dependency, handled after response is sent

<project>
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>lifecycle-participant-reactor-dependency-injection</groupId>
    <artifactId>parent</artifactId>
    <version>1.0</version>
  </parent>

  <artifactId>module-a</artifactId>