thanks for response sir..

Are you planning on only working with video tracks?

mainly i am planning for video tracks only yet but if it can be with audio then it will be good.

because of you have overlapping events and can't move them, there's really no point in checking the other conditions.

yes sir you are right .. thats a good catch.. but upper event can be move its own upper track so by this tracks can be empty

i created this via completely chat GPT help
but it is not running .. so its all on you sir.. when you will be free

using System;
using System.Collections.Generic;
using ScriptPortal.Vegas;

public class EntryPoint
{
    public void FromVegas(Vegas vegas)
    {
        MergeTracks(vegas);
    }

    private void MergeTracks(Vegas vegas)
    {
        // Get all video tracks
        var videoTracks = new List<Track>();
        foreach (var track in vegas.Project.Tracks)
        {
            if (track.GetType() == typeof(VideoTrack))
            {
                videoTracks.Add(track);
            }
        }

        // Process tracks from the lowest to the highest
        for (int i = videoTracks.Count - 1; i > 0; i--)
        {
            var currentTrack = videoTracks[i];
            var upperTrack = videoTracks[i - 1];

            // Check if the upper track is valid and if the current track is a child
            if (IsValidTrack(upperTrack) && IsChildTrack(currentTrack, videoTracks))
            {
                // Move events from the current track to the upper track
                MoveEvents(currentTrack, upperTrack);
            }
        }
    }

    private bool IsValidTrack(Track track)
    {
        // Check if the track is a video track and meets all conditions
        if (track.GetType() == typeof(VideoTrack))
        {
            return HasTrackFX(track) &&
                   HasEnvelopes(track) &&
                   IsCompositeLevelOne(track) &&
                   IsCompositeModeSrcAlpha(track) &&
                   IsParentTrack(track);
        }
        return false;
    }

    private bool IsChildTrack(Track track, List<Track> allTracks)
    {
        // Check if the track is a child track
        foreach (var potentialParent in allTracks)
        {
            if (potentialParent != track)
            {
                // Assuming tracks are ordered, check if current track is logically a child
                if (IsValidTrack(potentialParent) && allTracks.IndexOf(potentialParent) < allTracks.IndexOf(track))
                {
                    return true;
                }
            }
        }
        return false;
    }

    private bool IsParentTrack(Track track)
    {
        // For VEGAS Pro, this logic might need adjustment if parent-child relationships are managed differently
        // Assuming tracks are ordered, a track above is logically a parent
        return true;
    }

    private void MoveEvents(Track sourceTrack, Track destinationTrack)
    {
        if (sourceTrack.GetType() == typeof(VideoTrack) && destinationTrack.GetType() == typeof(VideoTrack))
        {
            var sourceVideoTrack = (VideoTrack)sourceTrack;
            var destinationVideoTrack = (VideoTrack)destinationTrack;

            // Iterate over events in the source track
            var eventsToMove = new List<TrackEvent>(sourceVideoTrack.Events);

            foreach (var e in eventsToMove)
            {
                // Check if there's no event directly above this event in the destination track
                bool hasEventAbove = false;
                foreach (var ev in destinationVideoTrack.Events)
                {
                    if (ev.Start < e.Start + e.Length && ev.Start + ev.Length > e.Start)
                    {
                        hasEventAbove = true;
                        break;
                    }
                }

                if (!hasEventAbove)
                {
                    // Duplicate the event and add it to the destination track
                    var newEvent = new VideoEvent(e.Start, e.Length);
                    destinationVideoTrack.Events.Add(newEvent);

                    // Remove the event from the source track
                    sourceVideoTrack.Events.Remove(e);
                }
            }
        }
    }

    private bool HasTrackFX(Track track)
    {
        return track.Effects.Count > 0;
    }

    private bool HasEnvelopes(Track track)
    {
        return track.Envelopes.Count > 0;
    }

    private bool IsCompositeLevelOne(Track track)
    {
        if (track.GetType() == typeof(VideoTrack))
        {
            var videoTrack = (VideoTrack)track;
            const float levelThreshold = 0.0001f;
            return Math.Abs(videoTrack.CompositeLevel - 1.0f) < levelThreshold;
        }
        return false;
    }

    private bool IsCompositeModeSrcAlpha(Track track)
    {
        if (track.GetType() == typeof(VideoTrack))
        {
            var videoTrack = (VideoTrack)track;
            return videoTrack.CompositeMode == CompositeMode.SrcAlpha;
        }
        return false;
    }
}

If there is a transition between events N & N+1 on a lower track, but one of them is blocked by an event on the upper track ...

First of all, simplify things. You don't need (and it's multiple places in your script):

if (track.GetType() == typeof(VideoTrack))

Just use:

if (track.IsVideo())

I'm not sure what the IsChildTrack routine is supposed to be doing. If you want to check to see if a track is a child track and return "true" if it is not:

    private bool IsChildTrack(Track track)
    {
        // Check if the track is a child track
        if (track.IsVideo())
        {
            VideoTrack vidTrack = (VideoTrack)track;
            if (!vidTrack.IsCompositingChild)
            {
                return true;
            }
        }
        return false;
    }

It seem counter-intuitive to me, though, that you're returning "true" when it is NOT the case instead of returning true when it IS the case.

Does it have effects? No so return true???

I sort of understand where you're coming from in that all the "trues" means you can move but It makes more sense to me that "Does it have effects?" No = FALSE and then check for "Not - has effects" instead.

And when you say "doesn't work", what, exactly, does that mean?

You can try taking out some of the checks and then add them back in one at a time to see which one(s) is failing.

@iEmby why are you handling audio tracks separate from video tracks for removal? Both can be handled just fine in DeleteEmptyTracks. In fact, just scanning the video checking part, it appears that audio tracks may already be being removed before calling the RemoveEmptyAudioTracks routine? Remove this line and see if the audio is already gone after running it:

RemoveEmptyAudioTracks(vegas);

I always aim for simplicity. Let's look at this routine:

        private void RemoveEmptyAudioTracks(Vegas vegas)
        {
            List<AudioTrack> emptyAudioTracks = new List<AudioTrack>();

            // Iterate through all tracks
            foreach (Track track in vegas.Project.Tracks)
            {
                if (track.IsAudio() && track.Events.Count == 0)
                {
                    emptyAudioTracks.Add((AudioTrack)track);
                }
            }

            // Remove the empty audio tracks
            foreach (AudioTrack audioTrackToRemove in emptyAudioTracks)
            {
                vegas.Project.Tracks.Remove(audioTrackToRemove);
            }
        }

We can get rid of all the "list" stuff and just do this - because you're removing tracks, you DO need to go "backwards":

        private void RemoveEmptyAudioTracks(Vegas vegas)
        {
            for (int i = vegas.Project.Tracks.Count - 1; i >= 0; i--)
            {
                Track track = vegas.Project.Tracks[i];

                if (track.IsAudio() && track.Events.Count == 0)
                {
                    vegas.Project.Tracks.Remove(track);
                }
            }
        }