Infinite Clip-Gained clips on to be muted on Pro Tools.

Hello Denis,
I took Raphael' work and tried to change it as you requested.
This will work clip by clip and ignore fades.
This is taking care of the safeties as well.
It will select all track, work clip by clip and all selected tracks.

As original select all track and clear volume automation.

As last request, mute all clips with clip gain lower than -30dB including -minus infinite.

I've read you would like variants of the script so I tried to set it up so its easier to implement (hopefully)
Let me know what variants you want,.

Its not thoroughly tested, so let me know how it works.

/** @param {'volume'|'waveform'} trackView */
function setTrackViewSelectorTo(trackView) {
    const selectedTrack = sf.ui.proTools.selectedTrack;
    const trackViewSelectorPopupButton = selectedTrack.popupButtons.whoseTitle.is("Track View selector").first;

    if (trackView === 'volume' && !['volume', 'vol'].includes(trackViewSelectorPopupButton.value.value)) {
        trackViewSelectorPopupButton.popupMenuSelect({ menuPath: ['volume'], isShift: true, isOption: true });
    }

    if (trackView === 'waveform' && !['waveform', 'wave'].includes(trackViewSelectorPopupButton.value.value)) {
        trackViewSelectorPopupButton.popupMenuSelect({ menuPath: ['waveform'], isShift: true, isOption: true });
    }
}


/**
 * Alternative to Edit > Select All, since there is a bug that sometimes selects all tracks when automating that menu item.
 */
function selectAllClips() {
    // Shortcut to bring edit selection to start of session
    sf.keyboard.press({
        keys: "return",
    });

    // Shortcut to extend edit selection to end of session
    sf.keyboard.press({
        keys: "alt+shift+return",
    });
};


function clearAllVolumeAutomation() {
    setTrackViewSelectorTo('volume');

    selectAllClips();
    sf.ui.proTools.menuClick({ menuPath: ['Edit', 'Clear'] });
};


function setMainTrackOutputWindowFaderToUnity() {
    try {
        sf.ui.proTools.mainTrackOutputWindow.sliders.whoseTitle.is("Volume").first.elementClick()
    } catch (e) { }
};


function setTrackSize(track) {

    let isTrackTooSmall = (track.frame.h <= 43) ? true : false;
    if (isTrackTooSmall) {

        const f = sf.ui.proTools.selectedTrack.frame

        const popupMenu = sf.ui.proTools.selectedTrack.popupMenuOpenFromElement({
            relativePosition: { x: f.w - 10, y: 5 },
            isOption: true,
            isShift: true,
        }).popupMenu;

        popupMenu.menuClickPopupMenu({
            menuPath: ["small"]
        });
    }
};


function timeCounter() {

    // get current counter
    const mainCounter = sf.ui.proTools.getCurrentTimecode().stringValue

    let originalTimeCounter
    /// Bars Beats .  
    if (mainCounter.includes("|")) originalTimeCounter = "Bars|Beats"
    //  Min Secs .    
    else if (mainCounter.includes(":") && mainCounter.includes(".")) originalTimeCounter = "Min:Secs"
    //  Time code
    else if (mainCounter.split(":").length == 4) originalTimeCounter = "Timecode"
    //  Feet+Frames
    else if (mainCounter.includes("+")) originalTimeCounter = "Feet+Frames"
    //  Samples.     
    else originalTimeCounter = "Samples"

    return originalTimeCounter
}




function setSafeties() {
    const menusToEnable = [
        ["Options", "Link Track and Edit Selection"],
        ["View", "Edit Window Views", "I/O"],
        ["Options", "Link Timeline and Edit Selection"]

    ]

    menusToEnable.forEach(menu => {
        sf.ui.proTools.menuClick({ menuPath: menu, targetValue: "Enable" })
    });
};


function openTrackOutput() {

    const selectedTrackName = sf.ui.proTools.selectedTrackNames[0]
    const isOutputWinOpen = sf.ui.proTools.mainTrackOutputWindow.exists

    let isSelectedTrackOutputWin
    try { isSelectedTrackOutputWin = sf.ui.proTools.mainTrackOutputWindow.buttons.first.value.invalidate().value === selectedTrackName } catch (err) { }

    if (!isOutputWinOpen || !isSelectedTrackOutputWin) {
        sf.ui.proTools.selectedTrack.trackOutputToggleShow();
    };
};


function getClipInfo() {

    let clipGainValue
    const isClipMuted = sf.ui.proTools.getMenuItem("Edit", "Unmute Clips").isEnabled

    sf.ui.proTools.menuClick({ menuPath: ["Edit", "Automation", "Convert Clip Gain to Volume Automation"] });
    clipGainValue = sf.ui.proTools.mainTrackOutputWindow.textFields.whoseTitle.is("Volume Numerical").first.value.invalidate().value

    sf.ui.proTools.menuClick({ menuPath: ["Edit", "Undo Convert Clip Gain to Volume Automation"] });

    clipGainValue === "-∞" ? clipGainValue = -143 : clipGainValue

    return {
        clipGain: clipGainValue,
        isClipMuted
    };

};




function getOriginalToolSelection() {
    // Get original Tools Selection
    const originalToolSelection = sf.ui.proTools.mainWindow.cursorToolCluster.buttons.filter(btn =>
        btn.title.value == "Smart tool" ||
        btn.title.value == "Trim tool" ||
        btn.title.value == "Selector tool" ||
        btn.title.value.startsWith("Grabber tool")
    ).filter(btn => btn.value.invalidate().value === "Selected")
    return originalToolSelection
};


function setOriginalToolSelection(originalToolSelection) {
    ///Set Original Tools Selection
    originalToolSelection.map(selBtn => selBtn.title.value).indexOf("Smart Tool") > 0 ?
        originalToolSelection.filter(selBtn => selBtn.title.value === "Smart Tool")[0].elementClick() :
        originalToolSelection[0].elementClick()
};


/**
* @param {Object} clipInfo
* @param {string} clipInfo.clipGain
* @param {boolean} clipInfo.isClipMuted
*/
function doWithClip(clipInfo) {

    function muteClips() {
        if (sf.ui.proTools.getMenuItem("Edit", "Mute Clips").isEnabled) {
            sf.ui.proTools.menuClick({ menuPath: ["Edit", "Mute Clips"] })
        };
    };

    if (+clipInfo.clipGain < -30 && !clipInfo.isClipMuted) { muteClips(); }

};


function clipDoForEachSelectedClipWitFades(doAction) {
    sf.ui.proTools.appActivateMainWindow();
    sf.ui.proTools.invalidate();

    setSafeties()

    let error = []
    let currentSelectionStart
    let mainCounter
    let lastSelectionStart
    const selectedTracksH = sf.ui.proTools.selectedTrackHeaders;
    const originalToolSelection = getOriginalToolSelection()
    const isOutputWinOpen = sf.ui.proTools.mainTrackOutputWindow.exists

    let originalTimeCOunter = timeCounter()
    sf.ui.proTools.mainCounterSetValue({ targetValue: "Samples" })

    // Dor for each selected track
    selectedTracksH.map(track => {

        sf.ui.proTools.menuClick({ menuPath: ["File", "Save"] });

        // Track select & scroll to view
        track.trackSelect();
        track.trackScrollToView();

        setTrackSize(track);


        clearAllVolumeAutomation();
        selectAllClips();


        const originalSelection = sf.ui.proTools.selectionGet()

        setTrackViewSelectorTo('waveform');

        openTrackOutput();
        setMainTrackOutputWindowFaderToUnity();

        sf.engine.runInBackground(() => {

            while (true) {
                try {

                    //Move to next clip
                    sf.keyboard.press({ keys: "ctrl+tab" });
                    //Check selection to end loop or continue selecting next clip
                    currentSelectionStart = sf.ui.proTools.invalidate().selectionGetInSamples().selectionStart

                    if (lastSelectionStart === currentSelectionStart) break; // Last clip
                    if (currentSelectionStart > originalSelection.selectionEnd) break; //Last selected clip(for manual initial selection variant)

                    //Save this iteration start to compare with the next
                    lastSelectionStart = currentSelectionStart

                    if (sf.ui.proTools.getMenuItem("Edit", "Mute").exists) continue;// Skip if it's a fade

                    // Get main couter for error log
                    mainCounter = sf.ui.proTools.getCurrentTimecode().stringValue.trim()

                    // Do to clip
                    doAction(getClipInfo())


                } catch (err) {
                    error.push(track.normalizedTrackName + " - " + mainCounter)
                }

                sf.wait({ intervalMs: 20 })
            }
        });
        // Select original selection
        sf.ui.proTools.selectionSet({ selectionStart: originalSelection.selectionStart, selectionEnd: originalSelection.selectionEnd });
        // Center start selection
        sf.keyboard.press({ keys: "left" });
    });

    // Set original couter
    sf.ui.proTools.mainCounterSetValue({ targetValue: originalTimeCOunter })
    // Set original Tool Selection and Track Selection
    setOriginalToolSelection(originalToolSelection);
    // Set original selected tracks
    sf.ui.proTools.trackSelectByName({ names: selectedTracksH.map(n => n.normalizedTrackName) });
    if (!isOutputWinOpen) { sf.ui.proTools.selectedTrack.trackOutputToggleShow(); }

    if (error.length > 0) { alert(error.join("\n")) } else { alert("Finished without errors.") }

};


clipDoForEachSelectedClipWitFades(doWithClip);