Faster way to re-arrange many layers?

@Stephen Marsh oh good to know, thanks!

A note: this only works when the folders of interest are pasted into a blank file.  Otherwise is starts pulling the wrong layers and I didn't have time to fix that error, because it's a workaround I can live with, and this already took forever.  But if anyone wants to improve it, feel free...

It took a lot of tweaking but this script maintains relative layer order.

function main() {
    if (app.documents.length === 0) {
        alert("No document open!");
        return;
    }

    var docRef = app.activeDocument;
    var allLayerSets = getAllLayerSets(docRef);
    var selectedLayerSets = getSelectedLayerSets(allLayerSets);

    if (selectedLayerSets.length === 0) {
        alert("No folders selected!");
        return;
    }

    var maxLayers = 0;
    for (var i = 0; i < selectedLayerSets.length; i++) {
        var layerSet = selectedLayerSets[i];
        var layerCount = getLayerCount(layerSet);
        if (layerCount > maxLayers) {
            maxLayers = layerCount;
        }
    }

    var newFolders = [];
    for (var j = 0; j < maxLayers; j++) {
        var newFolder = docRef.layerSets.add();
        newFolder.name = "New Folder " + (j + 1);
        newFolders.push(newFolder);
    }

    var layerSets = selectedLayerSets.slice(); // Create a copy to preserve original order

    // Iterate over new folders and process layers from the bottom of the old folders
    for (var k = 0; k < newFolders.length; k++) {
        var targetFolder = newFolders[k];
        for (var l = 0; l < layerSets.length; l++) {
            var folder = layerSets[l];
            var layers = getLayerChildren(folder);
            if (layers.length > 0) {
                var layer = layers.pop(); // Get the bottom-most layer and remove it
                try {
                    layer.move(targetFolder, ElementPlacement.PLACEATEND);
                } catch (e) {
                    alert("Error moving layer: " + e.message);
                    return;
                }
                if (layers.length === 0) {
                    layerSets.splice(l, 1); // Remove folder if it is empty
                    l--; // Adjust index after removal
                }
            }
        }
    }

    // Delete empty original folders
    for (var m = 0; m < selectedLayerSets.length; m++) {
        var folderToDelete = selectedLayerSets[m];
        if (getLayerCount(folderToDelete) === 0) {
            try {
                folderToDelete.remove();
            } catch (e) {
                alert("Error deleting folder: " + e.message);
                return;
            }
        }
    }

    alert("Script completed successfully with layers in the correct order!");
}

function getAllLayerSets(docRef) {
    var layerSets = [];
    function recurseLayers(layers) {
        for (var i = 0; i < layers.length; i++) {
            var layer = layers[i];
            if (layer.typename === "LayerSet") {
                layerSets.push(layer);
                recurseLayers(layer.layers);
            }
        }
    }
    recurseLayers(docRef.layers);
    return layerSets;
}

function getSelectedLayerSets(allLayerSets) {
    var selectedLayerSets = [];
    for (var i = 0; i < allLayerSets.length; i++) {
        var layerSet = allLayerSets[i];
        if (layerSet.visible) { // Assume visibility as a proxy for selection
            selectedLayerSets.push(layerSet);
        }
    }
    return selectedLayerSets;
}

function getLayerCount(layerSet) {
    return layerSet.layers.length;
}

function getLayerChildren(layerSet) {
    var layers = [];
    for (var i = 0; i < layerSet.layers.length; i++) {
        layers.push(layerSet.layers[i]); // Push each layer to the array in original order
    }
    return layers;
}

main();