Copy region edits to next track - is a script like this possible?

UPDATE -- Many problems addressed (including if you only have 1 region selected also If you have Stereo tracks :) way more work on both process clips and how it handles cross fades. Not to mention realizing there's a bunch more functions i can do with SDK ... you could do the fades with SDK too but then user needs presets set so I decided to keep that simple for now.

Here's one I've given waaaaaay too much time to today, but it takes advantage of SDK and works like gangbusters. processCLipsWithTransitions is the sweet sweet sweetness to redefine clips with fades and cross fades as whole clips. Feels only right I share it and give back to all who have helped me on here along the way. Report any edge cases please... I put in some Adjust Bounds Guardrails last second:

const trimClip = () => sf.app.proTools.trimToSelection()
const fadeToStart = () => sf.ui.proTools.menuClick({ menuPath: [`Edit`, `Fades`, `Fade to Start`] });
const fadeToEnd = () => sf.ui.proTools.menuClick({ menuPath: [`Edit`, `Fades`, `Fade to End`] });
const clear = () => sf.app.proTools.clear()
const buttonFade = () => sf.keyboard.press({ keys: "f", }); //// try out SDK fade
const separateClip = () => sf.ui.proTools.menuClick({ menuPath: [`Edit`, `Separate Clip`, `At Selection`] });

function dismissDialog() {
    const dlg = sf.ui.proTools.confirmationDialog;
    //Wait 100ms for dialog box to appear
    dlg.elementWaitFor({
        timeout: 100,
        pollingInterval: 10,
        onError: 'Continue'
    });

    if (dlg.children.whoseRole.is("AXStaticText").whoseValue.is("One or more fade requests are invalid due to insufficient audio data within the fade bounds.  You may skip the invalid fade request(s), or adjust the bounds for those fades (where possible).").first.exists) {
        dlg.buttons.whoseTitle.is("Adjust Bounds").first.elementClick();

        dlg.elementWaitFor({
            waitType: 'Disappear',
            timeout: 100,
            pollingInterval: 10,
            onError: 'Continue'
        });
    }
}

function combineMultiTrack(clips) {
    // Filter out clips with unique start and end times
    const uniqueClips = clips.filter((clip, index, array) => {
        return array.findIndex(c => c.StartTime === clip.StartTime && c.EndTime === clip.EndTime) === index;
    });

    return uniqueClips;
}


function processClipsWithTransitions(makeWholeCips) {
    let clips = combineMultiTrack(makeWholeCips)
    let combinedClips = [];
    let crossFadeInProgress = false;
    let crossFadeStartTime = 0;
    let crossFadeEndTime = 0;

    for (let i = 0; i < clips.length; i++) {
        let clip = clips[i];

        if (clip.ClipName.includes("(cross fade)") && i > 0 && i < clips.length - 1) {
            if (!crossFadeInProgress) {
                crossFadeInProgress = true;
                crossFadeStartTime = clips[i - 1].StartTime;
                crossFadeEndTime = clips[i + 1].EndTime;
            } else {
                crossFadeEndTime = clips[i + 1].EndTime;
            }
        } else if (crossFadeInProgress) {
            combinedClips[combinedClips.length - 1].EndTime = crossFadeEndTime;
            crossFadeInProgress = false;
        } else if (clip.ClipName.includes("(fade in)") && i < clips.length - 1) {
            let nextClip = clips[i + 1];
            let combinedClip = {
                TrackName: clip.TrackName,
                ClipName: nextClip.ClipName,
                StartTime: clip.StartTime,
                EndTime: nextClip.EndTime
            };
            combinedClips.push(combinedClip);
            i++; // Skip the next clip as it's already combined
        } else if (clip.ClipName.includes("(fade out)") && i > 0) {
            combinedClips[combinedClips.length - 1].EndTime = clip.EndTime;
        } else {
            combinedClips.push(clip);
        }
    }

    return combinedClips;
}

function extractUniqueTrackNames(clipsArray) {
    let uniqueTrackNames = [];
    clipsArray.forEach(clip => {
        if (!uniqueTrackNames.includes(clip.TrackName)) {
            uniqueTrackNames.push(clip.TrackName);
        }
    });
    return uniqueTrackNames;
}

function extractClipsFromFirstTrack(clipsArray, originalTracks, pickIndex) {
    // Get the name of the first track
    const firstTrackName = originalTracks[pickIndex];

    // Filter the clips array to include only clips from the first track
    const clipsFromFirstTrack = clipsArray.filter(clip => clip.TrackName === firstTrackName);

    return clipsFromFirstTrack;
}

function createNewArrayWithAdjustedTimes(clipsArray) {
    let newArray = [];
    for (let i = 1; i < clipsArray.length; i++) {
        let startTime = clipsArray[i - 1].EndTime;
        let endTime = clipsArray[i].StartTime;
        newArray.push({ StartTime: startTime, EndTime: endTime });
    }
    return newArray;
}

function performFadeActions(clips, originalTracks) {
    let highestEndTime = Math.max(...clips.map(clip => clip.EndTime));
    let processedCrossfades = new Set();


    clips.some((clip, index) => {
        if (clip.EndTime >= highestEndTime) {
            if (clip.ClipName === "(fade out)") {
                // Process the last "(fade out)" clip
                sf.ui.proTools.selectionSetInSamples({
                    selectionStart: clip.StartTime,
                    selectionEnd: clip.StartTime
                });
                fadeToEnd();
            }
            return true; // Break out of the loop if the clip's end time is greater than or equal to the highest end time
        }

        if (clip.ClipName === "(fade in)") {
            // Move to the end time of the fade in clip and perform fadeToStart function
            sf.ui.proTools.selectionSetInSamples({
                selectionStart: clip.EndTime,
                selectionEnd: clip.EndTime
            });
            fadeToStart();
        } else if (clip.ClipName === "(fade out)") {
            // Move to the start time of the fade out clip and perform fadeToEnd function
            sf.ui.proTools.selectionSetInSamples({
                selectionStart: clip.StartTime,
                selectionEnd: clip.StartTime
            });
            fadeToEnd();
        } else if (clip.ClipName === "(cross fade)" && !processedCrossfades.has(index)) {

            sf.ui.proTools.selectionSetInSamples({
                selectionStart: clip.StartTime,
                selectionEnd: clip.EndTime
            });

            //// this is not working right now...
            if (!sf.ui.proTools.getMenuItem("Edit", "Fades", "Create...").isEnabled) {

                // Calculate halfway point
                const halfwayTime = (clip.StartTime + clip.EndTime) / 2;

                // Select halfway point
                sf.ui.proTools.selectionSetInSamples({
                    selectionStart: halfwayTime,
                    selectionEnd: halfwayTime
                });

                // Execute separateClip() function
                separateClip();

                // Continue with the rest of the actions
                sf.ui.proTools.selectionSetInSamples({
                    selectionStart: clip.StartTime,
                    selectionEnd: clip.EndTime
                });

            }
            buttonFade();
            dismissDialog();

            sf.app.proTools.selectTracksByName({ trackNames: originalTracks.slice(1), selectionMode: "Replace" })

            sf.wait({ intervalMs: 50 });

            // Mark crossfade as processed
            processedCrossfades.add(index);
        }

        return false;
    });
}




function main() {
    sf.ui.proTools.invalidate();
    ///get Info on all Selected Clips & Tracks
    let getInfo = sf.app.proTools.getSelectedClipInfo();
    /// get Unique Track Names for Navigating
    let originalTracks = extractUniqueTrackNames(getInfo.clips)
    /// Get Clip Info on Tracks 1
    let firstTrackClips = extractClipsFromFirstTrack(getInfo.clips, originalTracks, 0);
    /// Get full clip info on Track 1
    let cuts = processClipsWithTransitions(firstTrackClips)

    /// Sets Clips only range
    let originalSelection = () => sf.ui.proTools.selectionSetInSamples({
        selectionStart: firstTrackClips[0].StartTime,
        selectionEnd: firstTrackClips[firstTrackClips.length - 1].EndTime
    });

    //select all tracks but the guide track
    /* sf.ui.proTools.trackSelectByName({ names: originalTracks.slice(1) }) */
    sf.app.proTools.selectTracksByName({ trackNames: originalTracks.slice(1), selectionMode: "Replace" })

    if (cuts.length > 1) {
        /// Create Array of ranges to Match Track 2
        let bside = createNewArrayWithAdjustedTimes(cuts)
        bside.forEach(clip => {
            sf.ui.proTools.selectionSetInSamples({
                selectionStart: clip.StartTime,
                selectionEnd: clip.EndTime
            });

            clear()
        });

    }
    originalSelection()
    trimClip()
    performFadeActions(firstTrackClips, originalTracks)
}

sf.ui.proTools.mainCounterDoWithValue({
    targetValue: `Samples`,
    action: main
})