My ComplexPackagingElement implementation doest not package elements in getSubstitution method

I have created MyComplexPackagingElement class which is extended from ComplexPackagingElement to build my artifact . Overried method getSubstitution returns a list of DirectoryCopyPackagingElement. But the directory does not copied when building my artifact.

public class MyComplexPackagingElement
        extends ComplexPackagingElement<MyComplexPackagingElement>
        implements FacetBasedPackagingElement {

    public static final String FACET_ATTRIBUTE = "facetId";

    private String path;
    private String facetId;
    private MyFacet myFacet;
    private FacetPointer<MyFacet> pointer;

    public MyComplexPackagingElement(Project project) {
        super(MyComplexPackagingElementType.getInstance());
        this.myProject = project;
    }

    public MyComplexPackagingElement(MyFacet myFacet) {
        super(MyComplexPackagingElementType.getInstance());
        this.myFacet = myFacet;
        this.path = myFacet.getPath();
        this.pointer = FacetPointersManager.getInstance(myFacet.getModule().getProject()).create(myFacet);
        this.facetId = pointer.getId();
    }

    @Override
    public @Nullable List<? extends PackagingElement<?>> getSubstitution(@NotNull PackagingElementResolvingContext context, @NotNull ArtifactType artifactType) {
        return Lists.newArrayList(new DirectoryCopyPackagingElement(path));
    }

    @Override
    public @NotNull PackagingElementPresentation createPresentation(@NotNull ArtifactEditorContext context) {
        return new MyComplexPackagingElementPresentation(myFacet, context, pointer, "resources");
    }

    @Attribute(FACET_ATTRIBUTE)
    public String getFacetId() {
        return this.facetId;
    }

    public void setFacetId(String facetId) {
        this.facetId = facetId;
    }

    @Override
    public boolean isEqualTo(@NotNull PackagingElement<?> element) {
        if (element instanceof MyComplexPackagingElement) {
            MyComplexPackagingElement other = (MyComplexPackagingElement)element;
            return Objects.equals(path, other.path) && Objects.equals(facetId, other.facetId);
        }
        return false;
    }

    @Override
    public @Nullable MyComplexPackagingElement getState() {
        return this;
    }

    @Override
    public void loadState(@NotNull MyComplexPackagingElement state) {
        this.facetId = state.getFacetId();
        this.pointer = (this.facetId != null) ? FacetPointersManager.getInstance(this.myProject).create(this.facetId) : null;
        if (this.pointer != null) {
            this.myFacet = Objects.requireNonNull(this.pointer.getFacet());
            this.path = this.myFacet.getPath();
        }
    }

    @Nullable
    @Override
    public MyFacet findFacet(@NotNull PackagingElementResolvingContext context) {
        return ReadAction.compute(() -> this.pointer.findFacet(context.getModulesProvider(), context.getFacetsProvider()));
    }

    @Override
    public String toString() {
        return "my-facet-contents:" + this.pointer.getFacetName() + "(" + this.pointer.getModuleName() + ")";
    }
}

public class MyComplexPackagingElementType extends ComplexPackagingElementType<MyComplexPackagingElement> {

    public static MyComplexPackagingElementType getInstance() {
        return PackagingElementType.getInstance(MyComplexPackagingElementType.class);
    }

    public static final String TYPE_ID = "my-facet-contents";

    public MyComplexPackagingElementType() {
        super(TYPE_ID, () -> "My Facet Contents");
    }

    @Override
    public boolean canCreate(@NotNull ArtifactEditorContext context, @NotNull Artifact artifact) {
        Module[] modules = context.getModulesProvider().getModules();
        List<MyFacet> myFacets = MyFacetSourceItemsProvider.getMyFacets(context, modules);
        return !myFacets.isEmpty();
    }

    @Override
    public @NotNull List<? extends PackagingElement<?>> chooseAndCreate(@NotNull ArtifactEditorContext context,
                                                                        @NotNull Artifact artifact,
                                                                        @NotNull CompositePackagingElement<?> parent) {
        Collection<MyFacet> facets = MyFacetSourceItemsProvider.getMyFacets(context, context.getModulesProvider().getModules());

        ChooseFacetsDialog dialog = new ChooseFacetsDialog(context.getProject(), Lists.newArrayList(facets), "Choose My Facet", "");
        dialog.show();
        List<MyComplexPackagingElement> elements = Lists.newArrayList();
        if (dialog.isOK()) {
            for (MyFacet facet : dialog.getChosenElements()) {
                elements.add(new MyComplexPackagingElement(facet));
            }
        }
        return elements;
    }

    @Override
    public @NotNull MyComplexPackagingElement createEmpty(@NotNull Project project) {
        return new MyComplexPackagingElement(project);
    }

    @Override
    public @NlsActions.ActionText String getShowContentActionText() {
        return "Show Content of the Facet";
    }
}

<extensions defaultExtensionNs="com.intellij">
    <facetType implementation="com.example.demo.artifact.facet.MyFacetType" />
    <packaging.artifactType implementation="com.example.demo.artifact.MyArtifactType" />
    <packaging.elementType implementation="com.example.demo.artifact.facet.MyComplexPackagingElementType" />
    <packaging.sourceItemProvider implementation="com.example.demo.artifact.facet.MyFacetSourceItemsProvider" />
</extensions>

The usage is as follows:

// not work
// getFacetResourcesPackagingElements returns Lists.newArrayList(new MyComplexPackagingElement(path));
root.addOrFindChildren(myFacet.getFacetResourcesPackagingElements());

But this will work

root.addOrFindChildren(Lists.newArrayList(new DirectoryCopyPackagingElement(path)));

Have I made any mistakes? How do I get MyComplexPackagingElement to work?

Any help would be appreciated!