sequenceDiagram
    title NATS — PROPALGATION_EVENT : Pair A propage vers Pair B

    participant AppA as App Pair A
    participant NATSA as NATS A
    participant NodeA as Node A
    participant StreamA as StreamService A
    participant NodeB as Node B
    participant NATSB as NATS B
    participant DBB as DB Pair B (oc-lib)

    AppA->>NATSA: Publish(PROPALGATION_EVENT, {Action, DataType, Payload})
    NATSA->>NodeA: ListenNATS callback → PROPALGATION_EVENT
    NodeA->>NodeA: resp.FromApp != "oc-discovery" ? → continuer
    NodeA->>NodeA: json.Unmarshal → PropalgationMessage{Action, DataType, Payload}

    alt Action == PB_DELETE
        NodeA->>StreamA: ToPartnerPublishEvent(PB_DELETE, dt, user, payload)
        StreamA->>StreamA: searchPeer(PARTNER) → [Pair B, ...]
        StreamA->>NodeB: write(PeerID_B, addr_B, dt, user, payload, ProtocolDeleteResource)
        Note over NodeB: /opencloud/resource/delete/1.0

        NodeB->>NodeB: handleEventFromPartner(evt, ProtocolDeleteResource)
        NodeB->>NATSB: SetNATSPub(REMOVE_RESOURCE, {DataType, resource JSON})
        NATSB->>DBB: Supprimer ressource dans DB B

    else Action == PB_UPDATE (via ProtocolUpdateResource)
        NodeA->>StreamA: ToPartnerPublishEvent(PB_UPDATE, dt, user, payload)
        StreamA->>NodeB: write → /opencloud/resource/update/1.0
        NodeB->>NATSB: SetNATSPub(CREATE_RESOURCE, {DataType, resource JSON})
        NATSB->>DBB: Upsert ressource dans DB B

    else Action == PB_CONSIDERS + WORKFLOW_EXECUTION
        NodeA->>NodeA: Unmarshal → executionConsidersPayload{PeerIDs:[PeerID_B, ...]}
        loop Pour chaque peer_id cible
            NodeA->>StreamA: PublishCommon(dt, user, PeerID_B, ProtocolConsidersResource, payload)
            StreamA->>NodeB: write → /opencloud/resource/considers/1.0
            NodeB->>NodeB: passConsidering(evt)
            NodeB->>NATSB: SetNATSPub(PROPALGATION_EVENT, {PB_CONSIDERS, dt, payload})
            NATSB->>DBB: (traité par oc-workflow sur NATS B)
        end

    else Action == PB_PLANNER (broadcast)
        NodeA->>NodeA: Unmarshal → {peer_id: nil, ...payload}
        loop Pour chaque stream ProtocolSendPlanner ouvert
            NodeA->>StreamA: PublishCommon(nil, user, pid, ProtocolSendPlanner, payload)
            StreamA->>NodeB: write → /opencloud/resource/planner/1.0
        end

    else Action == PB_CLOSE_PLANNER
        NodeA->>NodeA: Unmarshal → {peer_id: PeerID_B}
        NodeA->>StreamA: Streams[ProtocolSendPlanner][PeerID_B].Stream.Close()
        NodeA->>StreamA: delete(Streams[ProtocolSendPlanner], PeerID_B)

    else Action == PB_SEARCH + DataType == PEER
        NodeA->>NodeA: Unmarshal → {search: "..."}
        NodeA->>NodeA: GetPeerRecord(ctx, search)
        Note over NodeA: Résolution via DB A + Indexer + DHT
        NodeA->>NATSA: SetNATSPub(SEARCH_EVENT, {PEER, PeerRecord JSON})
        NATSA->>NATSA: (AppA reçoit le résultat)

    else Action == PB_SEARCH + autre DataType
        NodeA->>NodeA: Unmarshal → {type:"all"|"known"|"partner", search:"..."}
        NodeA->>NodeA: PubSubService.SearchPublishEvent(ctx, dt, type, user, search)
        Note over NodeA: Voir diagrammes 10 et 11
    end