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

DUDE I THINK THAT WAS ME. Newbury Park High School?

Thank you for this! Gonna test drive it today.

Hi @notNickNorton,

No promises but I'll see how I go.

Holy cow, this is awesome!

I discovered a second use case, which is cutting back and forth between two clips (for perspective edits for instance).

So everyone reading this knows what's up, here's how it works. Select this:

To get this:

And for perspective cuts, select this:

To get this:

It does feel a little counterintuitive for what you select before running it, so I might try to tweak that myself a bit.

Thank you Kitch!

DUDE.

I had not worked on this in a while so hadn't been checking in. This script is now an F-ing miracle. Holy cow! Thank you!

It's hard to explain the euphoria I'm feeling now that I've found this!! You are a genius!! It even does it to multiple tracks at once. THANK YOU, THANK YOU, THANK YOU!!

Owen you are a star!
The old script was a massive timesaver, but this new one is super cool.
Thanks so much for making my life much easier.

Hi SF fam -- I posted a quick demo video about a very similar task/script idea I was playing with on the facebook group and it seemed a few people were interested. Huge thanks to @Owen_Granich_Young for pointing me in the direction of this already existing thread to continue the discussion.

I will link to two videos on the script:
1st is a quick demo in PT I posted on FB: https://youtu.be/97VUm13BhLs
2nd is an in-depth walkthrough and breakdown of the script made specifically for the forum: https://youtu.be/uAm1lvDKqrc

I know the 2nd video is quite long-winded--sorry!! lol
Here is a quick walkthrough for those of you who don't like video demos:
Step 1: Make any selection of an edit you want to "match" or duplicate the "geometry" of eventually.

Step 2: Fire the macro and you will be greeted with two core options: "Learn" or "Apply"

Step 3: Click "Learn" -- you will see SF automation of PT happen where fades, clip boundaries, and "gaps" are learned.

Step 4: Select a target clip(s) or selection length equal to or greater in length to the OG learned selection/edit.

Step 5 (Final): Fire the Macro again and click "Apply" and you will see this "new" content trimmed and matched perfectly to your OG edit

You will notice that throughout the process you will always have two options... "Gaps Only" and "Full Edit Fade/Gaps". Gaps only will simply delete content around the clips, while Full Edit matches all clip lengths, fades, and fade types perfectly.

I know the script is a little long, but so far I am having a lot of fun with it and hope to have some of ya'll give it a try. Always open to improvements or suggestions.
Future Plans: look into multi-track-OG-edit learning aka "checkerboard edits"... you can still do this by running the exact process above for A checkerboad, then B checkerboard. I know it's definitely possible to handle this as one script or an alternative one. If anyone is dying for that I can look into trying something. As mentioned in the videos, I am still sorta confused as to whether or not crossfade handling should be considered.

Hope you enjoy and would love some feedback or testers! Watch the videos if you are curious or confused about anything.

/** Match Edits - Learn & Apply
 * 4-Button System:
 * 1. Learn Gaps - Learn gap deletions only
 * 2. Learn Full Edit - Learn gaps + fades (ignore crossfades)
 * 3. Apply Gaps - Apply gap deletions only
 * 4. Apply Full Edit - Apply gaps + recreate fades
 */

sf.ui.proTools.appActivateMainWindow();

function L(s){ try{ log(s); }catch(e){} }

// PORTABLE: Use system temp directory for any user
var GAPS_FILE = "/tmp/match_edits_gaps.json";
var FULL_EDIT_FILE = "/tmp/match_edits_full_edit.json";

// ===== SPEED DEMON FADE LEARNING FUNCTIONS =====
function S(ms){ sf.wait({ intervalMs: ms }); }

function closeFadeIfOpen(){
  try{
    var w = sf.ui.proTools.windows.whoseTitle.contains("Fade").first;
    if (w && w.exists) { sf.keyboard.press({ keys: "escape" }); S(100); }
  }catch(e){}
}

function waitFadeWin(timeoutMs){
  var start = Date.now();
  while (Date.now() - start < timeoutMs) {
    try{
      var w = sf.ui.proTools.windows.whoseTitle.contains("Fade").first;
      if (w && w.exists) return w;
    }catch(e){}
    S(20);
  }
  return null;
}

function waitFadeClosed(timeoutMs){
  var start = Date.now();
  while (Date.now() - start < timeoutMs) {
    try{
      var w = sf.ui.proTools.windows.whoseTitle.contains("Fade").first;
      if (!w || !w.exists) return true;
    }catch(e){ return true; }
    S(20);
  }
  return false;
}

function pick(group, options){
  if (!group || !group.exists) return null;
  try{
    for (var i=0;i<options.length;i++){
      var opt = group.radioButtons.whoseTitle.is(options[i]).first;
      if (opt && opt.exists && opt.value.invalidate().isSelected) return options[i];
    }
  }catch(e){}
  return null;
}

function readOpenFast(){
  var w = sf.ui.proTools.windows.whoseTitle.contains("Fade").first;
  if (!w || !w.exists) return null;

  function ttl(el){ try{ return el.title.invalidate().value || ""; } catch(e){ return ""; } }
  function iv(el){  try{ return el.value.invalidate().intValue; }     catch(e){ return null; } }
  function isSel(rb){
    var i = iv(rb); if (i === 1) return true; if (i === 0) return false;
    try{ if (rb.value.invalidate().isSelected === true) return true; }catch(e){}
    try{ if (rb.value.invalidate().valueDescription === "selected") return true; }catch(e){}
    return false;
  }
  function pick(group, titles){
    if (!group || !group.exists) return null;
    for (var i=0;i<titles.length;i++){
      try{
        var rb = group.radioButtons.whoseTitle.is(titles[i]).first;
        if (rb.exists && isSel(rb)) return titles[i];
      }catch(e){}
    }
    try{
      var rbs = group.radioButtons.allItems;
      for (var j=0;j<rbs.length;j++){ if (isSel(rbs[j])) return ttl(rbs[j]) || "(unnamed)"; }
    }catch(e){}
    return null;
  }

  var title = ""; try{ title = ttl(w); }catch(e){}
  var kind = /cross\s*fade/i.test(title) ? "xfade" : (/in/i.test(title) ? "in" : "out");

  L("Reading fade properties from window: " + title + " (kind: " + kind + ")");

  var slope = (function(){
    try{ 
      var g = w.groups.whoseTitle.is("Slope").first;
      if (!g || !g.exists) {
        L("No Slope group found");
        return "unknown";
      }
      var result = pick(g, ["Equal Power","Equal Gain"]);
      L("Slope found: " + result);
      return result || "unknown";
    }catch(e){ 
      L("Slope error: " + e.message);
      return "unknown"; 
    }
  })();

  var inShape="n/a", outShape="n/a";
  if (kind === "in"){
    try{
      var gIn = w.groups.whoseTitle.contains("In Shape").first;
      if (!gIn.exists) gIn = w.groups.whoseTitle.contains("Shape").first;
      if (gIn && gIn.exists) {
        inShape = pick(gIn, ["Standard","S-Curve"]) || "Standard";
        L("In Shape found: " + inShape);
      }
    }catch(e){ L("In Shape error: " + e.message); }
  } else if (kind === "out"){
    try{
      var gOut = w.groups.whoseTitle.contains("Out Shape").first;
      if (!gOut.exists) gOut = w.groups.whoseTitle.contains("Shape").last;
      if (gOut && gOut.exists) {
        outShape = pick(gOut, ["Standard","S-Curve"]) || "Standard";
        L("Out Shape found: " + outShape);
      }
    }catch(e){ L("Out Shape error: " + e.message); }
  } else {
    try{
      var gIn2  = w.groups.whoseTitle.contains("In Shape").first;
      var gOut2 = w.groups.whoseTitle.contains("Out Shape").first;
      if (!gIn2.exists)  gIn2  = w.groups.whoseTitle.contains("Shape").first;
      if (!gOut2.exists) gOut2 = w.groups.whoseTitle.contains("Shape").last;
      if (gIn2 && gIn2.exists) {
        inShape  = pick(gIn2,  ["Standard","S-Curve"]) || "Standard";
        L("Crossfade In Shape found: " + inShape);
      }
      if (gOut2 && gOut2.exists) {
        outShape = pick(gOut2, ["Standard","S-Curve"]) || "Standard";
        L("Crossfade Out Shape found: " + outShape);
      }
    }catch(e){ L("Crossfade shapes error: " + e.message); }
  }
  
  var result = { kind: kind, slope: slope, inShape: inShape, outShape: outShape, preset: null };
  L("Final fade properties: " + JSON.stringify(result));
  return result;
}

function near(a,b,t){ return Math.abs((+a)-(+b)) <= t; }

function uniqueFades(info){
  var raw = [];
  for (var i=0;i<info.clips.length;i++){
    var c = info.clips[i], n = String((c && (c.name || c.ClipName)) || "");
    if (n.indexOf("(fade") === 0 || n === "(cross fade)") raw.push(c);
  }
  var groups = [];
  for (var j=0;j<raw.length;j++){
    var s = +raw[j].StartTime, e = +raw[j].EndTime, len = e - s, g = null;
    for (var k=0;k<groups.length;k++){
      var G = groups[k];
      if (near(G.start,s,240) && near(G.length,len,240)) { g = G; break; } // 5ms tolerance
    }
    if (g) g.reps.push(raw[j]); else groups.push({ start:s, end:e, length:len, reps:[raw[j]] });
  }
  groups.sort(function(a,b){ return a.start - b.start; });
  return groups;
}

// Ask user which phase (2-step approach due to 3-button limit)
var phaseChoice = sf.interaction.displayDialog({
  title: "Match Edits",
  prompt: "Choose phase:",
  buttons: ["Learn", "Apply"],
  defaultButton: "Learn"
});

if (!phaseChoice) return;

var phase = phaseChoice && phaseChoice.button ? phaseChoice.button : phaseChoice;

if (phase === "Learn") {
  // Learn phase - ask for type
  var learnChoice = sf.interaction.displayDialog({
    title: "Learn Phase",
    prompt: "What to learn:",
    buttons: ["Gaps Only", "Full Edit (Gaps + Fades)"],
    defaultButton: "Full Edit (Gaps + Fades)"
  });
  
  if (!learnChoice) return;
  var learnType = learnChoice && learnChoice.button ? learnChoice.button : learnChoice;
  
  if (learnType === "Gaps Only") {
    learnGaps();
  } else if (learnType === "Full Edit (Gaps + Fades)") {
    learnFullEdit();
  }
} else if (phase === "Apply") {
  // Apply phase - ask for type
  var applyChoice = sf.interaction.displayDialog({
    title: "Apply Phase",
    prompt: "What to apply:",
    buttons: ["Gaps Only", "Full Edit (Gaps + Fades)"],
    defaultButton: "Full Edit (Gaps + Fades)"
  });
  
  if (!applyChoice) return;
  var applyType = applyChoice && applyChoice.button ? applyChoice.button : applyChoice;
  
  if (applyType === "Gaps Only") {
    applyGaps();
  } else if (applyType === "Full Edit (Gaps + Fades)") {
    applyFullEdit();
  }
}

function learnGaps() {
  L("=== LEARNING GAPS ===");
  
  var sel = sf.ui.proTools.selectionGetInSamples();
  if (!sel) {
    L("ERROR: Make a selection on reference track");
    return;
  }

  var selectionStart = sel.selectionStart;
  var selectionEnd = sel.selectionEnd;
  var selectionLength = selectionEnd - selectionStart;

  L("Reference selection: " + selectionStart + " → " + selectionEnd + " (" + selectionLength + ")");

  var info = sf.app.proTools.getSelectedClipInfo();
  if (!info || !info.clips) {
    L("ERROR: No clips found");
    return;
  }

  // Collect all boundaries
  var boundaries = [selectionStart, selectionEnd];
  for (var i = 0; i < info.clips.length; i++) {
    var clip = info.clips[i];
    var start = +clip.StartTime;
    var end = +clip.EndTime;
    
    if (start >= selectionStart && start <= selectionEnd) boundaries.push(start);
    if (end >= selectionStart && end <= selectionEnd) boundaries.push(end);
  }

  // Sort and dedupe
  boundaries = boundaries.sort(function(a,b){return a-b;});
  var unique = [];
  for (var j = 0; j < boundaries.length; j++) {
    if (unique.length === 0 || boundaries[j] !== unique[unique.length-1]) {
      unique.push(boundaries[j]);
    }
  }

  L("Found " + unique.length + " boundaries");

  // Calculate gaps (inverse of clips)
  var gaps = [];
  for (var k = 0; k < unique.length - 1; k++) {
    var gapStart = unique[k];
    var gapEnd = unique[k + 1];
    
    // Check if this is a gap (no clip spans this exact range)
    var isGap = true;
    for (var m = 0; m < info.clips.length; m++) {
      var c = info.clips[m];
      if (c.StartTime === gapStart && c.EndTime === gapEnd) {
        isGap = false;
        break;
      }
    }
    
    if (isGap) {
      // Store as relative positions (will work after trimming)
      gaps.push({ 
        start: gapStart - selectionStart,
        end: gapEnd - selectionStart
      });
      L("Gap: " + (gapStart - selectionStart) + " → " + (gapEnd - selectionStart) + " (" + (gapEnd - gapStart) + ")");
    }
  }

  // Save gaps
  var data = {
    referenceStart: selectionStart,    // Store absolute start position
    referenceEnd: selectionEnd,        // Store absolute end position  
    referenceLength: selectionLength,
    gaps: gaps,
    timestamp: Date.now()
  };

  try {
    sf.system.exec({
      commandLine: `bash -lc 'cat > "${GAPS_FILE}" << "JSON"\n${JSON.stringify(data, null, 2)}\nJSON'`,
      timeout: 5000
    });
    L("Saved " + gaps.length + " gaps to " + GAPS_FILE);
  } catch (e) {
    L("ERROR: Could not save gaps: " + e.message);
  }
}

function applyGaps() {
  L("=== APPLYING GAPS (MULTI-TRACK) ===");
  
  // Load gaps
  var data;
  try {
    var result = sf.system.exec({
      commandLine: `bash -lc 'cat "${GAPS_FILE}"'`,
      timeout: 5000
    });
    data = JSON.parse(result.result);
  } catch (e) {
    L("ERROR: Could not load gaps: " + e.message);
    return;
  }

  var sel = sf.ui.proTools.selectionGetInSamples();
  if (!sel) {
    L("ERROR: Make a selection on target track(s)");
    return;
  }

  var targetStart = sel.selectionStart;
  var targetEnd = sel.selectionEnd;
  
  L("Target selection: " + targetStart + " → " + targetEnd + " (multi-track)");

  // RESTORE EXACT ORIGINAL SELECTION BOUNDARIES (preserves height)
  L("Restoring original selection boundaries: " + data.referenceStart + " → " + data.referenceEnd);
  sf.ui.proTools.selectionSetInSamples({ 
    selectionStart: data.referenceStart, 
    selectionEnd: data.referenceEnd 
  });
  L("Selection restored to original boundaries (height preserved)");
  
  // TRIM THE CLIP TO MATCH THE SELECTION (works on all selected tracks)
  sf.keyboard.press({ keys: "cmd+t" });
  L("Trimmed clips to match selection (all tracks)");
  
  // Update our variables to match the restored selection
  targetStart = data.referenceStart;
  targetEnd = data.referenceEnd;
  targetLength = data.referenceLength;
  
  // Now apply gaps using simple math (identical selection lengths) - works on all selected tracks
  L("Applying " + data.gaps.length + " gaps to all selected tracks...");
  for (var i = 0; i < data.gaps.length; i++) {
    var gap = data.gaps[i];
    var absStart = targetStart + gap.start;
    var absEnd = targetStart + gap.end;
    
    L("Deleting gap: " + absStart + " → " + absEnd + " (" + (absEnd - absStart) + ")");
    
    sf.ui.proTools.selectionSetInSamples({ 
      selectionStart: absStart, 
      selectionEnd: absEnd 
    });
    sf.keyboard.press({ keys: "backspace" });
  }

  L("Applied " + data.gaps.length + " gaps to all selected tracks");
  
  // CLEANUP: Delete JSON file to avoid clutter
  try {
    sf.system.exec({ commandLine: `rm -f "${GAPS_FILE}"`, timeout: 2000 });
    L("Cleaned up temporary file: " + GAPS_FILE);
  } catch (e) {
    L("Note: Could not clean up temp file (non-critical)");
  }
}

function learnFullEdit() {
  L("=== LEARNING FULL EDIT (GAPS + FADES) ===");
  
  var sel = sf.ui.proTools.selectionGetInSamples();
  if (!sel) {
    L("ERROR: Make a selection on reference track");
    return;
  }

  var selectionStart = sel.selectionStart;
  var selectionEnd = sel.selectionEnd;
  var selectionLength = selectionEnd - selectionStart;

  L("Reference selection: " + selectionStart + " → " + selectionEnd + " (" + selectionLength + ")");

  var info = sf.app.proTools.getSelectedClipInfo();
  if (!info || !info.clips) {
    L("ERROR: No clips found");
    return;
  }

  // Collect all boundaries (same as learnGaps)
  var boundaries = [selectionStart, selectionEnd];
  for (var i = 0; i < info.clips.length; i++) {
    var clip = info.clips[i];
    var start = +clip.StartTime;
    var end = +clip.EndTime;
    
    if (start >= selectionStart && start <= selectionEnd) boundaries.push(start);
    if (end >= selectionStart && end <= selectionEnd) boundaries.push(end);
  }

  // Sort and dedupe
  boundaries = boundaries.sort(function(a,b){return a-b;});
  var unique = [];
  for (var j = 0; j < boundaries.length; j++) {
    if (unique.length === 0 || boundaries[j] !== unique[unique.length-1]) {
      unique.push(boundaries[j]);
    }
  }

  L("Found " + unique.length + " boundaries");

  // Calculate gaps (same as learnGaps)
  var gaps = [];
  for (var k = 0; k < unique.length - 1; k++) {
    var gapStart = unique[k];
    var gapEnd = unique[k + 1];
    
    // Check if this is a gap (no clip spans this exact range)
    var isGap = true;
    for (var m = 0; m < info.clips.length; m++) {
      var c = info.clips[m];
      if (c.StartTime === gapStart && c.EndTime === gapEnd) {
        isGap = false;
        break;
      }
    }
    
    if (isGap) {
      gaps.push({ 
        start: gapStart - selectionStart,
        end: gapEnd - selectionStart
      });
      L("Gap: " + (gapStart - selectionStart) + " → " + (gapEnd - selectionStart) + " (" + (gapEnd - gapStart) + ")");
    }
  }

  // NEW: Learn fades using Speed Demon approach (with properties)
  var fades = [];
  var fadeGroups = uniqueFades(info);
  L("Found " + fadeGroups.length + " unique fade group(s) in selection");
  
  // Close any open fade dialogs first
  closeFadeIfOpen();
  
  // Learn each fade group
  for (var i = 0; i < fadeGroups.length; i++) {
    var fadeGroup = fadeGroups[i];
    
    // Skip if fade is outside our selection
    if (fadeGroup.start >= selectionEnd || fadeGroup.end <= selectionStart) {
      L("Skipping fade outside selection: " + fadeGroup.start + " → " + fadeGroup.end);
      continue;
    }
    
    // Read fade properties using Speed Demon approach first
    sf.ui.proTools.selectionSetInSamples({ selectionStart: fadeGroup.start, selectionEnd: fadeGroup.end });
    sf.keyboard.press({ keys: "cmd+f" });
    var w = waitFadeWin(2000);
    if (!w) { 
      L("— Fade " + (i+1) + ": no window"); 
      continue; 
    }
    
    var props = readOpenFast() || { kind:"unknown", slope:"unknown", inShape:"unknown", outShape:"unknown", preset:null };
    sf.keyboard.press({ keys: "escape" });
    waitFadeClosed(120);
    
    // Check if this is a crossfade (skip it)
    if (props.kind === "xfade") {
      L("Skipping crossfade: " + fadeGroup.start + " → " + fadeGroup.end + " (kind: " + props.kind + ")");
      continue;
    }
    
    // Also check if it spans across clip boundaries
    var isCrossfade = false;
    for (var j = 0; j < unique.length - 1; j++) {
      var boundary = unique[j];
      if (fadeGroup.start < boundary && fadeGroup.end > boundary) {
        isCrossfade = true;
        break;
      }
    }
    
    if (isCrossfade) {
      L("Skipping crossfade: " + fadeGroup.start + " → " + fadeGroup.end + " (spans boundaries)");
      continue;
    }
    
    // Store relative to selection start
    var relativeStart = fadeGroup.start - selectionStart;
    var relativeEnd = fadeGroup.end - selectionStart;
    
    fades.push({
      start: relativeStart,
      end: relativeEnd,
      duration: relativeEnd - relativeStart,
      kind: props.kind,
      slope: props.slope,
      inShape: props.inShape,
      outShape: props.outShape,
      preset: props.preset
    });
    
    L("Learned fade: " + props.kind + " @ " + relativeStart + "→" + relativeEnd + " (" + props.slope + ", " + props.inShape + "/" + props.outShape + ")");
  }

  // Save full edit data
  var data = {
    referenceStart: selectionStart,
    referenceEnd: selectionEnd,
    referenceLength: selectionLength,
    gaps: gaps,
    fades: fades,
    timestamp: Date.now()
  };

  try {
    sf.system.exec({
      commandLine: `bash -lc 'cat > "${FULL_EDIT_FILE}" << "JSON"\n${JSON.stringify(data, null, 2)}\nJSON'`,
      timeout: 5000
    });
    L("Saved " + gaps.length + " gaps and " + fades.length + " fades to " + FULL_EDIT_FILE);
  } catch (e) {
    L("ERROR: Could not save full edit: " + e.message);
  }
}

function applyFullEdit() {
  L("=== APPLYING FULL EDIT (GAPS + FADES) - MULTI-TRACK ===");
  
  // Load full edit data
  var data;
  try {
    var result = sf.system.exec({
      commandLine: `bash -lc 'cat "${FULL_EDIT_FILE}"'`,
      timeout: 5000
    });
    data = JSON.parse(result.result);
  } catch (e) {
    L("ERROR: Could not load full edit: " + e.message);
    return;
  }

  var sel = sf.ui.proTools.selectionGetInSamples();
  if (!sel) {
    L("ERROR: Make a selection on target track(s)");
    return;
  }

  var targetStart = sel.selectionStart;
  var targetEnd = sel.selectionEnd;
  
  L("Target selection: " + targetStart + " → " + targetEnd + " (multi-track)");

  // RESTORE EXACT ORIGINAL SELECTION BOUNDARIES (preserves height)
  L("Restoring original selection boundaries: " + data.referenceStart + " → " + data.referenceEnd);
  sf.ui.proTools.selectionSetInSamples({ 
    selectionStart: data.referenceStart, 
    selectionEnd: data.referenceEnd 
  });
  L("Selection restored to original boundaries (height preserved)");
  
  // TRIM THE CLIP TO MATCH THE SELECTION (works on all selected tracks)
  sf.keyboard.press({ keys: "cmd+t" });
  L("Trimmed clips to match selection (all tracks)");
  
  // Update our variables to match the restored selection
  targetStart = data.referenceStart;
  targetEnd = data.referenceEnd;
  targetLength = data.referenceLength;
  
  // Apply gaps first (works on all selected tracks)
  L("Applying " + data.gaps.length + " gaps to all selected tracks...");
  for (var i = 0; i < data.gaps.length; i++) {
    var gap = data.gaps[i];
    var absStart = targetStart + gap.start;
    var absEnd = targetStart + gap.end;
    
    L("Deleting gap: " + absStart + " → " + absEnd + " (" + (absEnd - absStart) + ")");
    
    sf.ui.proTools.selectionSetInSamples({ 
      selectionStart: absStart, 
      selectionEnd: absEnd 
    });
    sf.keyboard.press({ keys: "backspace" });
  }
  
  // NEW: Apply fades with detailed properties (works on all selected tracks)
  L("Applying " + data.fades.length + " fades with properties to all selected tracks...");
  for (var i = 0; i < data.fades.length; i++) {
    var fade = data.fades[i];
    var absStart = targetStart + fade.start;
    var absEnd = targetStart + fade.end;
    
    L("Creating " + fade.kind + " fade: " + absStart + " → " + absEnd + " (" + fade.duration + ") - " + fade.slope + ", " + fade.inShape + "/" + fade.outShape);
    
    sf.ui.proTools.selectionSetInSamples({ 
      selectionStart: absStart, 
      selectionEnd: absEnd 
    });
    
    // Create fade using Pro Tools menu (exact path with ellipsis)
    sf.ui.proTools.menuClick({ menuPath: ['Edit', 'Fades', 'Create...'] });
    S(200);
    
    // Apply fade properties if we have detailed info
    if (fade.kind !== "unknown" && fade.slope !== "unknown") {
      try {
        var fadeWin = waitFadeWin(2000);
        if (fadeWin) {
          // Set slope
          if (fade.slope !== "unknown") {
            try {
              var slopeGroup = fadeWin.groups.whoseTitle.is("Slope").first;
              if (slopeGroup && slopeGroup.exists) {
                var slopeRadio = slopeGroup.radioButtons.whoseTitle.is(fade.slope).first;
                if (slopeRadio && slopeRadio.exists) {
                  slopeRadio.elementClick();
                  S(50);
                }
              }
            } catch(e) { L("Could not set slope: " + e.message); }
          }
          
          // Set shapes based on fade kind
          if (fade.kind === "in" && fade.inShape !== "unknown") {
            try {
              var inGroup = fadeWin.groups.whoseTitle.contains("In Shape").first;
              if (!inGroup.exists) inGroup = fadeWin.groups.whoseTitle.contains("Shape").first;
              if (inGroup && inGroup.exists) {
                var inRadio = inGroup.radioButtons.whoseTitle.is(fade.inShape).first;
                if (inRadio && inRadio.exists) {
                  inRadio.elementClick();
                  S(50);
                }
              }
            } catch(e) { L("Could not set in shape: " + e.message); }
          } else if (fade.kind === "out" && fade.outShape !== "unknown") {
            try {
              var outGroup = fadeWin.groups.whoseTitle.contains("Out Shape").first;
              if (!outGroup.exists) outGroup = fadeWin.groups.whoseTitle.contains("Shape").last;
              if (outGroup && outGroup.exists) {
                var outRadio = outGroup.radioButtons.whoseTitle.is(fade.outShape).first;
                if (outRadio && outRadio.exists) {
                  outRadio.elementClick();
                  S(50);
                }
              }
            } catch(e) { L("Could not set out shape: " + e.message); }
          }
          
          // Close fade window
          sf.keyboard.press({ keys: "return" });
          waitFadeClosed(120);
        }
      } catch(e) { 
        L("Error applying fade properties: " + e.message);
        // Close window if open
        try { sf.keyboard.press({ keys: "escape" }); waitFadeClosed(120); } catch(e2) {}
      }
    } else {
      // Simple fade creation without properties
      sf.keyboard.press({ keys: "return" });
      S(100);
    }
  }

  L("Applied " + data.gaps.length + " gaps and " + data.fades.length + " fades to all selected tracks");
  
  // CLEANUP: Delete JSON file to avoid clutter
  try {
    sf.system.exec({ commandLine: `rm -f "${FULL_EDIT_FILE}"`, timeout: 2000 });
    L("Cleaned up temporary file: " + FULL_EDIT_FILE);
  } catch (e) {
    L("Note: Could not clean up temp file (non-critical)");
  }
}

Cheers!
James