@synthetic-ai/premiere-mcp 2.0.0

package/dist/tools/audio-advanced.js

@@ -0,0 +1,1653 @@
+import { buildToolScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getAudioAdvancedTools(bridgeOptions) {
+    return {
+        get_audio_mixer_state: {
+            description: "Get the current state of the audio mixer for the active sequence. Returns all track volumes, panning, mute/solo status.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var tracks = [];
+          for (var t = 0; t < seq.audioTracks.numTracks; t++) {
+            var track = seq.audioTracks[t];
+            var trackInfo = {
+              index: t,
+              name: track.name || ("Audio " + (t + 1)),
+              isMuted: __readMaybe(track, "isMuted", false),
+              numClips: track.clips ? track.clips.numItems : 0,
+              level: 0,
+              panning: 0
+            };
+            var volComp = __findComponent(track, ["AE.ADBE Audio Levels", "audioVolume", "audioGain"], ["Volume", "Volumen"]);
+            if (volComp) {
+              for (var pi = 0; pi < volComp.properties.numItems; pi++) {
+                var prop = volComp.properties[pi];
+                if (prop.displayName === "Level") {
+                  try { trackInfo.level = prop.getValue(); } catch(e) {}
+                  break;
+                }
+              }
+            }
+            var panComp = __findComponent(track, ["AE.ADBE Pan", "audioPanner"], ["Panner", "Balance"]);
+            if (panComp) {
+              for (var pi2 = 0; pi2 < panComp.properties.numItems; pi2++) {
+                var prop2 = panComp.properties[pi2];
+                if (prop2.displayName === "Balance" || prop2.displayName === "Panner" || prop2.displayName === "Left/Right Balance") {
+                  try { trackInfo.panning = prop2.getValue(); } catch(e2) {}
+                  break;
+                }
+              }
+            }
+            tracks.push(trackInfo);
+          }
+          return __result({ tracks: tracks, numTracks: tracks.length });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_audio_level: {
+            description: "Set the audio level (volume) of a clip on an audio track by track and clip index.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    level_db: { type: "number", description: "Audio level in dB. Range: -96 to +15. 0 = unity gain." },
+                },
+                required: ["track_index", "clip_index", "level_db"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          var levelDb = ${args.level_db};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          var clip = track.clips[clipIdx];
+          var found = false;
+          for (var i = 0; i < clip.components.numItems; i++) {
+            var comp = clip.components[i];
+            if (comp.matchName === "audioVolume" || comp.displayName === "Volume") {
+              for (var p = 0; p < comp.properties.numItems; p++) {
+                var prop = comp.properties[p];
+                if (prop.displayName === "Level") {
+                  prop.setValue(levelDb, true);
+                  found = true;
+                  break;
+                }
+              }
+            }
+            if (found) break;
+          }
+          if (!found) return __error("Could not find Volume/Level component on clip");
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, levelDb: levelDb, clip: clip.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_track_panning: {
+            description: "Set the stereo panning for an audio track. Range: -100 (full left) to +100 (full right). 0 = center.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    pan_value: { type: "number", description: "Pan value from -100 (full left) to +100 (full right)" },
+                },
+                required: ["track_index", "pan_value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var panValue = ${args.pan_value};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          var found = false;
+          if (track.components) {
+            for (var ci = 0; ci < track.components.numItems; ci++) {
+              var comp = track.components[ci];
+              if (comp.matchName === "audioPanner" || comp.displayName === "Panner") {
+                for (var pi = 0; pi < comp.properties.numItems; pi++) {
+                  var prop = comp.properties[pi];
+                  if (prop.displayName === "Balance" || prop.displayName === "Panner" || prop.displayName === "Left/Right Balance") {
+                    prop.setValue(panValue, true);
+                    found = true;
+                    break;
+                  }
+                }
+              }
+              if (found) break;
+            }
+          }
+          if (!found) return __result({ note: "Panner component not found on track " + trackIdx + ". Track-level panning may not be available for this track type.", trackIndex: trackIdx, requestedPan: panValue });
+          return __result({ trackIndex: trackIdx, panValue: panValue });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_clip_panning: {
+            description: "Set the stereo panning for an individual audio clip. Range: -100 (full left) to +100 (full right). 0 = center.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    pan_value: { type: "number", description: "Pan value from -100 (full left) to +100 (full right)" },
+                },
+                required: ["track_index", "clip_index", "pan_value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          var panValue = ${args.pan_value};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          var clip = track.clips[clipIdx];
+          var found = false;
+          for (var i = 0; i < clip.components.numItems; i++) {
+            var comp = clip.components[i];
+            if (comp.matchName === "audioPanner" || comp.displayName === "Panner") {
+              for (var p = 0; p < comp.properties.numItems; p++) {
+                var prop = comp.properties[p];
+                if (prop.displayName === "Balance" || prop.displayName === "Panner" || prop.displayName === "Left/Right Balance") {
+                  prop.setValue(panValue, true);
+                  found = true;
+                  break;
+                }
+              }
+            }
+            if (found) break;
+          }
+          if (!found) return __result({ note: "Panner component not found on clip", trackIndex: trackIdx, clipIndex: clipIdx, requestedPan: panValue });
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, panValue: panValue, clip: clip.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_clip_panning: {
+            description: "Get the current stereo panning value for an audio clip.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          var clip = track.clips[clipIdx];
+          var panValue = 0;
+          var found = false;
+          for (var i = 0; i < clip.components.numItems; i++) {
+            var comp = clip.components[i];
+            if (comp.matchName === "audioPanner" || comp.displayName === "Panner") {
+              for (var p = 0; p < comp.properties.numItems; p++) {
+                var prop = comp.properties[p];
+                if (prop.displayName === "Balance" || prop.displayName === "Panner" || prop.displayName === "Left/Right Balance") {
+                  try { panValue = prop.getValue(); found = true; } catch(e) {}
+                  break;
+                }
+              }
+            }
+            if (found) break;
+          }
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, panValue: panValue, clip: clip.name, found: found });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        add_volume_keyframe: {
+            description: "Add a volume keyframe to an audio clip at a specific time. Enables time-varying volume automation.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    time: { type: "number", description: "Time in seconds (relative to sequence start)" },
+                    level_db: { type: "number", description: "Volume level in dB at this keyframe. Range: -96 to +15." },
+                },
+                required: ["track_index", "clip_index", "time", "level_db"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          var timeSecs = ${args.time};
+          var levelDb = ${args.level_db};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          var clip = track.clips[clipIdx];
+          var levelProp = null;
+          for (var i = 0; i < clip.components.numItems; i++) {
+            var comp = clip.components[i];
+            if (comp.matchName === "audioVolume" || comp.displayName === "Volume") {
+              for (var p = 0; p < comp.properties.numItems; p++) {
+                if (comp.properties[p].displayName === "Level") {
+                  levelProp = comp.properties[p];
+                  break;
+                }
+              }
+            }
+            if (levelProp) break;
+          }
+          if (!levelProp) return __error("Could not find Volume Level property on clip");
+          levelProp.setTimeVarying(true);
+          var timeTicks = __secondsToTicks(timeSecs);
+          var t = new Time();
+          t.ticks = String(timeTicks);
+          levelProp.addKey(t);
+          levelProp.setValueAtKey(t, levelDb);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, time: timeSecs, levelDb: levelDb, clip: clip.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        add_panning_keyframe: {
+            description: "Add a panning keyframe to an audio clip at a specific time. Enables time-varying stereo panning automation.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    time: { type: "number", description: "Time in seconds (relative to sequence start)" },
+                    pan_value: { type: "number", description: "Pan value from -100 (full left) to +100 (full right)" },
+                },
+                required: ["track_index", "clip_index", "time", "pan_value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          var timeSecs = ${args.time};
+          var panValue = ${args.pan_value};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          var clip = track.clips[clipIdx];
+          var panComp = __findIntrinsic(clip, "panner");
+          if (!panComp) return __error("Panner component not found on clip");
+          var panProp = __findProp(panComp, ["Balance", "Panner", "Left/Right Balance", "Panoramización"]);
+          if (!panProp) return __error("Panner property not found on clip");
+          panProp.setTimeVarying(true);
+          var timeTicks = __secondsToTicks(timeSecs);
+          var t = new Time();
+          t.ticks = String(timeTicks);
+          panProp.addKey(t);
+          panProp.setValueAtKey(t, panValue);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, time: timeSecs, panValue: panValue, clip: clip.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_volume_keyframes: {
+            description: "Get all volume keyframes for an audio clip.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          var clip = track.clips[clipIdx];
+          var volComp = __findIntrinsic(clip, "volume");
+          if (!volComp) return __error("Volume component not found on clip");
+          var levelProp = __findProp(volComp, ["Level", "Nivel", "Pegel", "Volume"]);
+          if (!levelProp) return __error("Volume Level property not found on clip");
+          var keyframes = [];
+          try {
+            var keys = levelProp.getKeys ? levelProp.getKeys() : null;
+            if (keys) {
+              var numKeys = (keys.numKeys != null) ? keys.numKeys : (keys.length != null ? keys.length : 0);
+              for (var k = 0; k < numKeys; k++) {
+                var keyTime = keys[k];
+                if (keyTime == null && levelProp.getKey) {
+                  try { keyTime = levelProp.getKey(k); } catch(eGetKey) {}
+                }
+                if (keyTime == null) continue;
+                var keyVal = 0;
+                try { keyVal = levelProp.getValueAtKey(keyTime); } catch(e) {}
+                keyframes.push({ time: __ticksToSeconds(keyTime.ticks), levelDb: keyVal });
+              }
+            }
+          } catch(eKeys) {
+            keyframes = [];
+          }
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, clip: clip.name, keyframes: keyframes, timeVarying: levelProp.getTimeVarying ? levelProp.getTimeVarying() : false });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_panning_keyframes: {
+            description: "Get all panning keyframes for an audio clip.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          var clip = track.clips[clipIdx];
+          var panComp = __findIntrinsic(clip, "panner");
+          if (!panComp) return __error("Panner component not found on clip");
+          var panProp = __findProp(panComp, ["Balance", "Panner", "Left/Right Balance", "Panoramización"]);
+          if (!panProp) return __error("Panner property not found on clip");
+          var keyframes = [];
+          try {
+            var keys = panProp.getKeys ? panProp.getKeys() : null;
+            if (keys) {
+              var numKeys = (keys.numKeys != null) ? keys.numKeys : (keys.length != null ? keys.length : 0);
+              for (var k = 0; k < numKeys; k++) {
+                var keyTime = keys[k];
+                if (keyTime == null && panProp.getKey) {
+                  try { keyTime = panProp.getKey(k); } catch(eGetKey) {}
+                }
+                if (keyTime == null) continue;
+                var keyVal = 0;
+                try { keyVal = panProp.getValueAtKey(keyTime); } catch(e) {}
+                keyframes.push({ time: __ticksToSeconds(keyTime.ticks), panValue: keyVal });
+              }
+            }
+          } catch(eKeys) {
+            keyframes = [];
+          }
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, clip: clip.name, keyframes: keyframes, timeVarying: panProp.getTimeVarying ? panProp.getTimeVarying() : false });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        remove_all_audio_keyframes: {
+            description: "Remove all volume and panning keyframes from an audio clip, returning it to static values.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          var clip = track.clips[clipIdx];
+          var removed = [];
+          for (var i = 0; i < clip.components.numItems; i++) {
+            var comp = clip.components[i];
+            if (comp.matchName === "audioVolume" || comp.displayName === "Volume") {
+              for (var p = 0; p < comp.properties.numItems; p++) {
+                if (comp.properties[p].displayName === "Level") {
+                  try { comp.properties[p].setTimeVarying(false); removed.push("Volume Level"); } catch(e) {}
+                  break;
+                }
+              }
+            }
+            if (comp.matchName === "audioPanner" || comp.displayName === "Panner") {
+              for (var p2 = 0; p2 < comp.properties.numItems; p2++) {
+                var prop2 = comp.properties[p2];
+                if (prop2.displayName === "Balance" || prop2.displayName === "Panner" || prop2.displayName === "Left/Right Balance") {
+                  try { prop2.setTimeVarying(false); removed.push("Panner"); } catch(e2) {}
+                  break;
+                }
+              }
+            }
+          }
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, clip: clip.name, removedFrom: removed });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_eq: {
+            description: "Apply Parametric Equalizer effect to an audio clip. Optionally specify EQ bands as JSON array with freq, gain, and q values.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    bands: { type: "array", description: "Optional EQ bands as array of {freq, gain, q} objects. Example: [{freq:1000, gain:-6, q:1.0}]" },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          app.enableQE();
+          if (!qe || !qe.project) return __error("QE DOM not available");
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence in QE DOM");
+          var qeTrack = qeSeq.getAudioTrackAt(trackIdx);
+          if (!qeTrack) return __error("Track not found in QE");
+          var qeClip = qeTrack.getItemAt(clipIdx);
+          if (!qeClip) return __error("Clip not found in QE");
+          var effectNames = ["Parametric Equalizer", "Studio Equalizer", "Graphic Equalizer (10 Band)", "Graphic Equalizer (20 Band)"];
+          var effect = null;
+          for (var i = 0; i < effectNames.length; i++) {
+            try { effect = qe.project.getAudioEffectByName(effectNames[i]); } catch(e) {}
+            if (effect) { break; }
+          }
+          if (!effect) return __error("Parametric Equalizer effect not found. Ensure it is installed.");
+          qeClip.addAudioEffect(effect);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, effect: "Parametric Equalizer", applied: true });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_compressor: {
+            description: "Apply a Dynamics/Compressor audio effect to a clip. Controls threshold, ratio, attack, and release.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    threshold: { type: "number", description: "Threshold in dB where compression starts (e.g. -20). Default: -20." },
+                    ratio: { type: "number", description: "Compression ratio (e.g. 4 means 4:1). Default: 4." },
+                    attack: { type: "number", description: "Attack time in milliseconds. Default: 10." },
+                    release: { type: "number", description: "Release time in milliseconds. Default: 100." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const threshold = args.threshold ?? -20;
+                const ratio = args.ratio ?? 4;
+                const attack = args.attack ?? 10;
+                const release = args.release ?? 100;
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          app.enableQE();
+          if (!qe || !qe.project) return __error("QE DOM not available");
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence in QE DOM");
+          var qeTrack = qeSeq.getAudioTrackAt(trackIdx);
+          if (!qeTrack) return __error("Track not found in QE");
+          var qeClip = qeTrack.getItemAt(clipIdx);
+          if (!qeClip) return __error("Clip not found in QE");
+          var effectNames = ["Dynamics", "Compressor", "Multiband Compressor", "Single-band Compressor"];
+          var effect = null;
+          for (var i = 0; i < effectNames.length; i++) {
+            try { effect = qe.project.getAudioEffectByName(effectNames[i]); } catch(e) {}
+            if (effect) break;
+          }
+          if (!effect) return __error("Dynamics/Compressor effect not found.");
+          qeClip.addAudioEffect(effect);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, effect: "Dynamics", threshold: ${threshold}, ratio: ${ratio}, attack: ${attack}, release: ${release}, applied: true, note: "Effect added. Set parameters manually in Effect Controls panel." });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_limiter: {
+            description: "Apply a Hard Limiter audio effect to a clip to prevent clipping. Sets a ceiling level in dB.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    ceiling: { type: "number", description: "Maximum output level in dB (e.g. -0.1 to prevent clipping). Default: -0.1." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const ceiling = args.ceiling ?? -0.1;
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          app.enableQE();
+          if (!qe || !qe.project) return __error("QE DOM not available");
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence in QE DOM");
+          var qeTrack = qeSeq.getAudioTrackAt(trackIdx);
+          if (!qeTrack) return __error("Track not found in QE");
+          var qeClip = qeTrack.getItemAt(clipIdx);
+          if (!qeClip) return __error("Clip not found in QE");
+          var effectNames = ["Hard Limiter", "Limiter", "Loudness Maximizer"];
+          var effect = null;
+          for (var i = 0; i < effectNames.length; i++) {
+            try { effect = qe.project.getAudioEffectByName(effectNames[i]); } catch(e) {}
+            if (effect) break;
+          }
+          if (!effect) return __error("Hard Limiter effect not found.");
+          qeClip.addAudioEffect(effect);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, effect: "Hard Limiter", ceiling: ${ceiling}, applied: true, note: "Effect added. Adjust ceiling parameter in Effect Controls panel." });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_de_esser: {
+            description: "Apply a DeEsser audio effect to reduce sibilant 's' and 'sh' sounds in speech. Targets a specific frequency.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    frequency: { type: "number", description: "Target frequency in Hz (typically 6000-8000 for sibilance). Default: 6000." },
+                    reduction: { type: "number", description: "Reduction amount in dB (negative value, e.g. -10). Default: -10." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const frequency = args.frequency ?? 6000;
+                const reduction = args.reduction ?? -10;
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          app.enableQE();
+          if (!qe || !qe.project) return __error("QE DOM not available");
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence in QE DOM");
+          var qeTrack = qeSeq.getAudioTrackAt(trackIdx);
+          if (!qeTrack) return __error("Track not found in QE");
+          var qeClip = qeTrack.getItemAt(clipIdx);
+          if (!qeClip) return __error("Clip not found in QE");
+          var effectNames = ["DeEsser", "De-Esser", "Spectral DeEsser"];
+          var effect = null;
+          for (var i = 0; i < effectNames.length; i++) {
+            try { effect = qe.project.getAudioEffectByName(effectNames[i]); } catch(e) {}
+            if (effect) break;
+          }
+          if (!effect) return __error("DeEsser effect not found.");
+          qeClip.addAudioEffect(effect);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, effect: "DeEsser", frequency: ${frequency}, reduction: ${reduction}, applied: true, note: "Effect added. Adjust parameters in Effect Controls panel." });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_audio_noise_reduction: {
+            description: "Apply DeNoise audio effect to reduce background noise in a clip.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    amount: { type: "number", description: "Noise reduction amount 0-100. Default: 50." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const amount = args.amount ?? 50;
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          app.enableQE();
+          if (!qe || !qe.project) return __error("QE DOM not available");
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence in QE DOM");
+          var qeTrack = qeSeq.getAudioTrackAt(trackIdx);
+          if (!qeTrack) return __error("Track not found in QE");
+          var qeClip = qeTrack.getItemAt(clipIdx);
+          if (!qeClip) return __error("Clip not found in QE");
+          var effectNames = ["DeNoise", "Noise Reduction", "Adaptive Noise Reduction"];
+          var effect = null;
+          for (var i = 0; i < effectNames.length; i++) {
+            try { effect = qe.project.getAudioEffectByName(effectNames[i]); } catch(e) {}
+            if (effect) break;
+          }
+          if (!effect) return __error("DeNoise effect not found.");
+          qeClip.addAudioEffect(effect);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, effect: "DeNoise", amount: ${amount}, applied: true, note: "Effect added. Adjust amount parameter in Effect Controls panel." });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_de_reverb: {
+            description: "Apply DeReverb audio effect to reduce room reverb/echo in a clip.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    amount: { type: "number", description: "Reverb reduction amount 0-100. Default: 50." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const amount = args.amount ?? 50;
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          app.enableQE();
+          if (!qe || !qe.project) return __error("QE DOM not available");
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence in QE DOM");
+          var qeTrack = qeSeq.getAudioTrackAt(trackIdx);
+          if (!qeTrack) return __error("Track not found in QE");
+          var qeClip = qeTrack.getItemAt(clipIdx);
+          if (!qeClip) return __error("Clip not found in QE");
+          var effectNames = ["DeReverb", "De-Reverb", "Spectral Noise Reduction"];
+          var effect = null;
+          for (var i = 0; i < effectNames.length; i++) {
+            try { effect = qe.project.getAudioEffectByName(effectNames[i]); } catch(e) {}
+            if (effect) break;
+          }
+          if (!effect) return __error("DeReverb effect not found.");
+          qeClip.addAudioEffect(effect);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, effect: "DeReverb", amount: ${amount}, applied: true, note: "Effect added. Adjust amount in Effect Controls panel." });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_de_hum: {
+            description: "Apply DeHum audio effect to remove electrical hum (50Hz or 60Hz) from a clip.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    frequency: { type: "number", description: "Hum frequency in Hz. Use 50 (Europe) or 60 (Americas). Default: 60." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const frequency = args.frequency ?? 60;
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          app.enableQE();
+          if (!qe || !qe.project) return __error("QE DOM not available");
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence in QE DOM");
+          var qeTrack = qeSeq.getAudioTrackAt(trackIdx);
+          if (!qeTrack) return __error("Track not found in QE");
+          var qeClip = qeTrack.getItemAt(clipIdx);
+          if (!qeClip) return __error("Clip not found in QE");
+          var effectNames = ["DeHummer", "DeHum", "Notch Filter"];
+          var effect = null;
+          for (var i = 0; i < effectNames.length; i++) {
+            try { effect = qe.project.getAudioEffectByName(effectNames[i]); } catch(e) {}
+            if (effect) break;
+          }
+          if (!effect) return __error("DeHummer effect not found.");
+          qeClip.addAudioEffect(effect);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, effect: "DeHummer", frequency: ${frequency}, applied: true, note: "Effect added. Set frequency to " + ${frequency} + "Hz in Effect Controls panel." });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_audio_preset: {
+            description: "Apply a named audio effect preset to a clip. Use get_audio_effect_presets to see available presets.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    preset_name: { type: "string", description: "Name of the audio effect (e.g. 'Parametric Equalizer', 'Dynamics', 'Hard Limiter', 'DeEsser', 'DeHummer', 'DeNoise', 'Reverb')" },
+                },
+                required: ["track_index", "clip_index", "preset_name"],
+            },
+            handler: async (args) => {
+                const presetNameEsc = args.preset_name.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          var presetName = "${presetNameEsc}";
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          app.enableQE();
+          if (!qe || !qe.project) return __error("QE DOM not available");
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence in QE DOM");
+          var qeTrack = qeSeq.getAudioTrackAt(trackIdx);
+          if (!qeTrack) return __error("Track not found in QE");
+          var qeClip = qeTrack.getItemAt(clipIdx);
+          if (!qeClip) return __error("Clip not found in QE");
+          var effect = null;
+          try { effect = qe.project.getAudioEffectByName(presetName); } catch(e) {}
+          if (!effect) return __error("Audio effect not found: " + presetName + ". Use get_audio_effect_presets to see available effects.");
+          qeClip.addAudioEffect(effect);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, effect: presetName, applied: true });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_audio_effect_presets: {
+            description: "List available audio effect presets that can be applied to clips. Shows which effects are installed.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var commonEffects = [
+            { name: "Parametric Equalizer", category: "EQ", description: "Multi-band parametric EQ" },
+            { name: "Studio Equalizer", category: "EQ", description: "Graphical EQ with bands" },
+            { name: "Graphic Equalizer (10 Band)", category: "EQ", description: "10-band graphic EQ" },
+            { name: "Graphic Equalizer (20 Band)", category: "EQ", description: "20-band graphic EQ" },
+            { name: "Dynamics", category: "Dynamics", description: "Compressor/expander/gate/limiter" },
+            { name: "Multiband Compressor", category: "Dynamics", description: "Multi-band compression" },
+            { name: "Single-band Compressor", category: "Dynamics", description: "Single-band compression" },
+            { name: "Hard Limiter", category: "Dynamics", description: "Brick wall limiter" },
+            { name: "Loudness Maximizer", category: "Dynamics", description: "Maximize perceived loudness" },
+            { name: "DeNoise", category: "Restoration", description: "Reduce background noise" },
+            { name: "DeReverb", category: "Restoration", description: "Reduce room reverb" },
+            { name: "DeHummer", category: "Restoration", description: "Remove electrical hum" },
+            { name: "DeEsser", category: "Restoration", description: "Reduce sibilance" },
+            { name: "Adaptive Noise Reduction", category: "Restoration", description: "Adaptive noise gate" },
+            { name: "Click/Pop Eliminator", category: "Restoration", description: "Remove clicks and pops" },
+            { name: "Reverb", category: "Ambience", description: "Add room reverb" },
+            { name: "Studio Reverb", category: "Ambience", description: "Studio reverb effect" },
+            { name: "Convolution Reverb", category: "Ambience", description: "Convolution-based reverb" },
+            { name: "Chorus/Flanger", category: "Modulation", description: "Chorus and flanger" },
+            { name: "Flanger", category: "Modulation", description: "Flanger modulation" },
+            { name: "Phaser", category: "Modulation", description: "Phaser effect" },
+            { name: "Pitch Shifter", category: "Pitch", description: "Real-time pitch shifting" },
+            { name: "Analog Delay", category: "Delay", description: "Tape-style delay" },
+            { name: "Delay", category: "Delay", description: "Basic digital delay" },
+            { name: "Notch Filter", category: "Filter", description: "Notch/band-reject filter" },
+            { name: "High Pass", category: "Filter", description: "High-pass filter" },
+            { name: "Low Pass", category: "Filter", description: "Low-pass filter" }
+          ];
+          return __result({ effects: commonEffects, note: "List shows common Premiere Pro audio effects. Available effects depend on your installation and installed audio plugins." });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_loudness_info: {
+            description: "Get loudness information for an audio clip including current level and duration.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          var clip = track.clips[clipIdx];
+          var levelDb = 0;
+          var found = false;
+          for (var i = 0; i < clip.components.numItems; i++) {
+            var comp = clip.components[i];
+            if (comp.matchName === "audioVolume" || comp.displayName === "Volume") {
+              for (var p = 0; p < comp.properties.numItems; p++) {
+                if (comp.properties[p].displayName === "Level") {
+                  try { levelDb = comp.properties[p].getValue(); found = true; } catch(e) {}
+                  break;
+                }
+              }
+            }
+            if (found) break;
+          }
+          var startSecs = clip.start ? __ticksToSeconds(clip.start.ticks) : 0;
+          var endSecs = clip.end ? __ticksToSeconds(clip.end.ticks) : 0;
+          var durationSecs = endSecs - startSecs;
+          return __result({
+            trackIndex: trackIdx,
+            clipIndex: clipIdx,
+            clip: clip.name,
+            levelDb: levelDb,
+            durationSeconds: durationSecs,
+            startSeconds: startSecs,
+            endSeconds: endSecs,
+            couldClip: levelDb > 0,
+            note: "LUFS integrated loudness requires dedicated loudness analysis. levelDb is the static clip gain/Level property."
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_sequence_loudness: {
+            description: "Get loudness information for the entire active sequence including all audio tracks.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var tracks = [];
+          var totalClips = 0;
+          var maxLevel = -96;
+          for (var t = 0; t < seq.audioTracks.numTracks; t++) {
+            var track = seq.audioTracks[t];
+            var trackData = { index: t, name: track.name || ("Audio " + (t + 1)), clips: [] };
+            for (var c = 0; c < track.clips.numItems; c++) {
+              var clip = track.clips[c];
+              var levelDb = 0;
+              for (var i = 0; i < clip.components.numItems; i++) {
+                var comp = clip.components[i];
+                if (comp.matchName === "audioVolume" || comp.displayName === "Volume") {
+                  for (var p = 0; p < comp.properties.numItems; p++) {
+                    if (comp.properties[p].displayName === "Level") {
+                      try { levelDb = comp.properties[p].getValue(); } catch(e) {}
+                      break;
+                    }
+                  }
+                  break;
+                }
+              }
+              if (levelDb > maxLevel) maxLevel = levelDb;
+              trackData.clips.push({ name: clip.name, levelDb: levelDb, start: __ticksToSeconds(clip.start.ticks), end: __ticksToSeconds(clip.end.ticks) });
+              totalClips++;
+            }
+            tracks.push(trackData);
+          }
+          return __result({ tracks: tracks, totalClips: totalClips, maxLevelDb: maxLevel, couldClip: maxLevel > 0 });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        detect_clipping: {
+            description: "Detect potential audio clipping in a clip. Returns whether the clip level could cause clipping.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          var clip = track.clips[clipIdx];
+          var levelDb = 0;
+          for (var i = 0; i < clip.components.numItems; i++) {
+            var comp = clip.components[i];
+            if (comp.matchName === "audioVolume" || comp.displayName === "Volume") {
+              for (var p = 0; p < comp.properties.numItems; p++) {
+                if (comp.properties[p].displayName === "Level") {
+                  try { levelDb = comp.properties[p].getValue(); } catch(e) {}
+                  break;
+                }
+              }
+              break;
+            }
+          }
+          var couldClip = levelDb > 0;
+          return __result({
+            trackIndex: trackIdx,
+            clipIndex: clipIdx,
+            clip: clip.name,
+            levelDb: levelDb,
+            couldClip: couldClip,
+            message: couldClip ? "WARNING: Clip level is " + levelDb + " dB (above 0 dB) - may cause digital clipping." : "OK: Clip level " + levelDb + " dB is at or below 0 dB."
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        normalize_all_audio: {
+            description: "Normalize all audio clips on all tracks to a target dB level.",
+            parameters: {
+                type: "object",
+                properties: {
+                    target_db: { type: "number", description: "Target normalization level in dB (e.g. -6 for -6dBFS). Default: -6." },
+                },
+                required: [],
+            },
+            handler: async (args) => {
+                const targetDb = args.target_db ?? -6;
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var targetDb = ${targetDb};
+          var totalSet = 0;
+          var errors = [];
+          for (var t = 0; t < seq.audioTracks.numTracks; t++) {
+            var track = seq.audioTracks[t];
+            for (var c = 0; c < track.clips.numItems; c++) {
+              var clip = track.clips[c];
+              var found = false;
+              for (var i = 0; i < clip.components.numItems; i++) {
+                var comp = clip.components[i];
+                if (comp.matchName === "audioVolume" || comp.displayName === "Volume") {
+                  for (var p = 0; p < comp.properties.numItems; p++) {
+                    if (comp.properties[p].displayName === "Level") {
+                      try {
+                        comp.properties[p].setValue(targetDb, true);
+                        totalSet++;
+                        found = true;
+                      } catch(e) {
+                        errors.push("Track " + t + " clip " + c + ": " + e.toString());
+                      }
+                      break;
+                    }
+                  }
+                }
+                if (found) break;
+              }
+            }
+          }
+          return __result({ targetDb: targetDb, clipsNormalized: totalSet, errors: errors });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        mute_all_audio_tracks: {
+            description: "Mute all audio tracks in the active sequence.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var count = 0;
+          for (var t = 0; t < seq.audioTracks.numTracks; t++) {
+            var track = seq.audioTracks[t];
+            try {
+              if (track.setMute) { track.setMute(1); count++; }
+            } catch(e) {}
+          }
+          return __result({ muted: count, totalTracks: seq.audioTracks.numTracks });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        unmute_all_audio_tracks: {
+            description: "Unmute all audio tracks in the active sequence.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            handler: async (_args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var count = 0;
+          for (var t = 0; t < seq.audioTracks.numTracks; t++) {
+            var track = seq.audioTracks[t];
+            try {
+              if (track.setMute) { track.setMute(0); count++; }
+            } catch(e) {}
+          }
+          return __result({ unmuted: count, totalTracks: seq.audioTracks.numTracks });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        create_submix: {
+            description: "Create a submix (bus) track in the active sequence for routing multiple tracks.",
+            parameters: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "Name for the submix track. Default: 'Submix'." },
+                    channel_type: { type: "string", description: "Channel type: 'mono', 'stereo', '5.1', or 'adaptive'. Default: 'stereo'." },
+                },
+                required: [],
+            },
+            handler: async (args) => {
+                const name = (args.name || "Submix").replace(/"/g, '\\"');
+                const channelType = (args.channel_type || "stereo").replace(/"/g, '\\"');
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackName = "${name}";
+          var channelType = "${channelType}";
+          try {
+            app.enableQE();
+            if (qe && qe.project) {
+              var qeSeq = qe.project.getActiveSequence();
+              if (qeSeq && qeSeq.addAudioSubmixTrack) {
+                var channelTypeMap = { "mono": 1, "stereo": 2, "5.1": 6, "adaptive": 0 };
+                var chType = channelTypeMap[channelType] !== undefined ? channelTypeMap[channelType] : 2;
+                qeSeq.addAudioSubmixTrack(chType);
+                return __result({ name: trackName, channelType: channelType, created: true });
+              }
+            }
+          } catch(e) {
+            return __error("Could not create submix track via QE DOM: " + e.toString());
+          }
+          return __result({ note: "Submix track creation not available via this API in the current Premiere version. Add via Sequence > Add Tracks in the Premiere Pro UI.", requestedName: trackName, requestedChannelType: channelType });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        prepare_voiceover_track: {
+            description: "Prepare an audio track for voiceover recording by muting all other tracks and targeting this one.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index to set up for voiceover (0-based)" },
+                },
+                required: ["track_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var voTrackIdx = ${args.track_index};
+          if (voTrackIdx >= seq.audioTracks.numTracks) return __error("Track index " + voTrackIdx + " out of range");
+          var mutedCount = 0;
+          var unmutedCount = 0;
+          for (var t = 0; t < seq.audioTracks.numTracks; t++) {
+            var track = seq.audioTracks[t];
+            if (t !== voTrackIdx) {
+              try { if (track.setMute) { track.setMute(1); mutedCount++; } } catch(e) {}
+            } else {
+              try { if (track.setMute) { track.setMute(0); unmutedCount++; } } catch(e) {}
+            }
+          }
+          return __result({ voTrackIndex: voTrackIdx, voTrackName: seq.audioTracks[voTrackIdx].name || ("Audio " + (voTrackIdx + 1)), otherTracksMuted: mutedCount, voTrackActive: true });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_voiceover_ducking: {
+            description: "Set up automatic audio ducking so music lowers when voiceover is present. Adds volume keyframes on music track around VO clips.",
+            parameters: {
+                type: "object",
+                properties: {
+                    vo_track_index: { type: "number", description: "Voiceover track index (0-based)" },
+                    music_track_index: { type: "number", description: "Music track index to duck (0-based)" },
+                    duck_amount: { type: "number", description: "How much to lower the music in dB (e.g. -15). Default: -15." },
+                    sensitivity: { type: "number", description: "Fade duration in seconds before/after VO clip. Default: 0.5." },
+                },
+                required: ["vo_track_index", "music_track_index"],
+            },
+            handler: async (args) => {
+                const duckAmount = args.duck_amount ?? -15;
+                const sensitivity = args.sensitivity ?? 0.5;
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var voTrackIdx = ${args.vo_track_index};
+          var musicTrackIdx = ${args.music_track_index};
+          var duckAmount = ${duckAmount};
+          var fadeDuration = ${sensitivity};
+          if (voTrackIdx >= seq.audioTracks.numTracks) return __error("VO track index " + voTrackIdx + " out of range");
+          if (musicTrackIdx >= seq.audioTracks.numTracks) return __error("Music track index " + musicTrackIdx + " out of range");
+          var voTrack = seq.audioTracks[voTrackIdx];
+          var musicTrack = seq.audioTracks[musicTrackIdx];
+          var processedClips = 0;
+          var errors = [];
+          for (var mc = 0; mc < musicTrack.clips.numItems; mc++) {
+            var musicClip = musicTrack.clips[mc];
+            var levelProp = null;
+            for (var ci = 0; ci < musicClip.components.numItems; ci++) {
+              var comp = musicClip.components[ci];
+              if (comp.matchName === "audioVolume" || comp.displayName === "Volume") {
+                for (var pi = 0; pi < comp.properties.numItems; pi++) {
+                  if (comp.properties[pi].displayName === "Level") {
+                    levelProp = comp.properties[pi];
+                    break;
+                  }
+                }
+              }
+              if (levelProp) break;
+            }
+            if (!levelProp) continue;
+            levelProp.setTimeVarying(true);
+            var musicStart = __ticksToSeconds(musicClip.start.ticks);
+            var musicEnd = __ticksToSeconds(musicClip.end.ticks);
+            for (var vc = 0; vc < voTrack.clips.numItems; vc++) {
+              var voClip = voTrack.clips[vc];
+              var voStart = __ticksToSeconds(voClip.start.ticks);
+              var voEnd = __ticksToSeconds(voClip.end.ticks);
+              if (voStart >= musicEnd || voEnd <= musicStart) continue;
+              var fadeInTime = Math.max(musicStart, voStart - fadeDuration);
+              var fadeInEnd = Math.min(musicEnd, voStart);
+              var fadeOutStart = Math.max(musicStart, voEnd);
+              var fadeOutEnd = Math.min(musicEnd, voEnd + fadeDuration);
+              try {
+                var t1 = new Time(); t1.ticks = String(__secondsToTicks(fadeInTime));
+                levelProp.addKey(t1); levelProp.setValueAtKey(t1, 0);
+                var t2 = new Time(); t2.ticks = String(__secondsToTicks(fadeInEnd));
+                levelProp.addKey(t2); levelProp.setValueAtKey(t2, duckAmount);
+                var t3 = new Time(); t3.ticks = String(__secondsToTicks(fadeOutStart));
+                levelProp.addKey(t3); levelProp.setValueAtKey(t3, duckAmount);
+                var t4 = new Time(); t4.ticks = String(__secondsToTicks(fadeOutEnd));
+                levelProp.addKey(t4); levelProp.setValueAtKey(t4, 0);
+                processedClips++;
+              } catch(e) {
+                errors.push("VO clip " + vc + ": " + e.toString());
+              }
+            }
+          }
+          return __result({ voTrackIndex: voTrackIdx, musicTrackIndex: musicTrackIdx, duckAmount: duckAmount, fadeDuration: fadeDuration, duckingRegionsAdded: processedClips, errors: errors });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_audio_track_volume: {
+            description: "Set the volume level for an entire audio track (track-level fader, not clip-level).",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    level_db: { type: "number", description: "Track volume in dB. Range: -96 to +15. 0 = unity." },
+                },
+                required: ["track_index", "level_db"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var levelDb = ${args.level_db};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          var found = false;
+          if (track.components) {
+            for (var ci = 0; ci < track.components.numItems; ci++) {
+              var comp = track.components[ci];
+              if (comp.matchName === "audioVolume" || comp.displayName === "Volume") {
+                for (var pi = 0; pi < comp.properties.numItems; pi++) {
+                  if (comp.properties[pi].displayName === "Level") {
+                    comp.properties[pi].setValue(levelDb, true);
+                    found = true;
+                    break;
+                  }
+                }
+              }
+              if (found) break;
+            }
+          }
+          if (!found) return __result({ note: "Track-level Volume component not found on track " + trackIdx + ". Track fader may not be accessible via ExtendScript.", trackIndex: trackIdx, requestedLevel: levelDb });
+          return __result({ trackIndex: trackIdx, levelDb: levelDb, applied: true });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        solo_audio_track: {
+            description: "Solo or unsolo an audio track (only this track plays when soloed).",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    soloed: { type: "boolean", description: "True to solo, false to unsolo" },
+                },
+                required: ["track_index", "soloed"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var soloed = ${args.soloed};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (track.setSolo) {
+            track.setSolo(soloed ? 1 : 0);
+            return __result({ trackIndex: trackIdx, soloed: soloed });
+          }
+          return __result({ note: "setSolo not supported on this track type in the current Premiere version.", trackIndex: trackIdx, requestedSolo: soloed });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        convert_stereo_to_mono: {
+            description: "Convert a stereo project item to mono by duplicating it as mono channels.",
+            parameters: {
+                type: "object",
+                properties: {
+                    project_item_index: { type: "number", description: "Project item index (0-based, from root item children)" },
+                },
+                required: ["project_item_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var itemIndex = ${args.project_item_index};
+          if (!app.project || !app.project.rootItem) return __error("No project open");
+          if (itemIndex >= app.project.rootItem.children.numItems) return __error("Item index " + itemIndex + " out of range");
+          var item = app.project.rootItem.children[itemIndex];
+          try {
+            var interp = item.getFootageInterpretation();
+            if (!interp) return __error("Cannot get footage interpretation for: " + item.name);
+            // audioChannelType: 0=Stereo, 1=Mono, 2=5.1, 4=Adaptive
+            var prevType = interp.audioChannelType;
+            interp.audioChannelType = 1; // Mono
+            item.setFootageInterpretation(interp);
+            return __result({ item: item.name, index: itemIndex, converted: true,
+              previousChannelType: prevType, newChannelType: 1,
+              note: "Audio channel type set to Mono (1). This affects how PP treats the audio channels of this item." });
+          } catch(e) {
+            return __error("Could not set audio channel type: " + e.toString());
+          }
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        extract_audio_from_video: {
+            description: "Extract the audio from a video project item as a separate audio clip in the project.",
+            parameters: {
+                type: "object",
+                properties: {
+                    project_item_index: { type: "number", description: "Project item index (0-based, from root item children)" },
+                },
+                required: ["project_item_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var itemIndex = ${args.project_item_index};
+          if (!app.project || !app.project.rootItem) return __error("No project open");
+          if (itemIndex >= app.project.rootItem.children.numItems) return __error("Item index " + itemIndex + " out of range");
+          var item = app.project.rootItem.children[itemIndex];
+          var mediaPath = "";
+          try { mediaPath = item.getMediaPath(); } catch(e) {}
+          // Gather audio interpretation info
+          var audioInfo = {};
+          try {
+            var interp = item.getFootageInterpretation();
+            if (interp) {
+              audioInfo.channelType = interp.audioChannelType;
+              audioInfo.numChannels = interp.audioNumChannels;
+            }
+          } catch(e) {}
+          return __result({ item: item.name, index: itemIndex, mediaPath: mediaPath,
+            audioInfo: audioInfo,
+            note: "To extract audio as a separate file, use export_audio_only tool with this item's media path as source. Audio interpretation info shown above." });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        // NEW ENHANCED AUDIO TOOLS
+        apply_audio_effect: {
+            description: "Apply any audio effect to a clip by exact name using the QE DOM.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    effect_name: { type: "string", description: "Exact name of the audio effect to apply (e.g. 'Reverb', 'Chorus/Flanger', 'Pitch Shifter')" },
+                },
+                required: ["track_index", "clip_index", "effect_name"],
+            },
+            handler: async (args) => {
+                const effectNameEsc = args.effect_name.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          var effectName = "${effectNameEsc}";
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          app.enableQE();
+          if (!qe || !qe.project) return __error("QE DOM not available");
+          var qeSeq = qe.project.getActiveSequence();
+          if (!qeSeq) return __error("No active sequence in QE DOM");
+          var qeTrack = qeSeq.getAudioTrackAt(trackIdx);
+          if (!qeTrack) return __error("Track " + trackIdx + " not found in QE");
+          var qeClip = qeTrack.getItemAt(clipIdx);
+          if (!qeClip) return __error("Clip " + clipIdx + " not found in QE");
+          var effect = null;
+          try { effect = qe.project.getAudioEffectByName(effectName); } catch(e) {}
+          if (!effect) return __error("Audio effect not found: " + effectName + ". Use get_audio_effect_presets for available effects.");
+          qeClip.addAudioEffect(effect);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, effectName: effectName, applied: true });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        fade_in_audio: {
+            description: "Add volume keyframes for a fade-in at the start of an audio clip.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    duration_seconds: { type: "number", description: "Fade-in duration in seconds" },
+                    target_db: { type: "number", description: "Target level in dB at end of fade-in. Default: 0 dB." },
+                },
+                required: ["track_index", "clip_index", "duration_seconds"],
+            },
+            handler: async (args) => {
+                const targetDb = args.target_db ?? 0;
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          var fadeDuration = ${args.duration_seconds};
+          var targetDb = ${targetDb};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          var clip = track.clips[clipIdx];
+          var volComp = __findIntrinsic(clip, "volume");
+          if (!volComp) return __error("Volume component not found on clip");
+          var levelProp = __findProp(volComp, ["Level", "Nivel", "Pegel", "Volume"]);
+          if (!levelProp) return __error("Volume Level property not found on clip");
+          var clipStart = __ticksToSeconds(clip.start.ticks);
+          var clipEnd = __ticksToSeconds(clip.end.ticks);
+          var fadeEnd = Math.min(clipStart + fadeDuration, clipEnd);
+          levelProp.setTimeVarying(true);
+          var t1 = new Time(); t1.ticks = String(__secondsToTicks(clipStart));
+          levelProp.addKey(t1); levelProp.setValueAtKey(t1, -96);
+          var t2 = new Time(); t2.ticks = String(__secondsToTicks(fadeEnd));
+          levelProp.addKey(t2); levelProp.setValueAtKey(t2, targetDb);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, clip: clip.name, fadeStart: clipStart, fadeEnd: fadeEnd, startDb: -96, endDb: targetDb });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        fade_out_audio: {
+            description: "Add volume keyframes for a fade-out at the end of an audio clip.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    duration_seconds: { type: "number", description: "Fade-out duration in seconds" },
+                    start_db: { type: "number", description: "Starting level in dB at beginning of fade-out. Default: 0 dB." },
+                },
+                required: ["track_index", "clip_index", "duration_seconds"],
+            },
+            handler: async (args) => {
+                const startDb = args.start_db ?? 0;
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          var fadeDuration = ${args.duration_seconds};
+          var startDb = ${startDb};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems) return __error("Clip index " + clipIdx + " out of range");
+          var clip = track.clips[clipIdx];
+          var volComp = __findIntrinsic(clip, "volume");
+          if (!volComp) return __error("Volume component not found on clip");
+          var levelProp = __findProp(volComp, ["Level", "Nivel", "Pegel", "Volume"]);
+          if (!levelProp) return __error("Volume Level property not found on clip");
+          var clipStart = __ticksToSeconds(clip.start.ticks);
+          var clipEnd = __ticksToSeconds(clip.end.ticks);
+          var fadeStart = Math.max(clipEnd - fadeDuration, clipStart);
+          levelProp.setTimeVarying(true);
+          var t1 = new Time(); t1.ticks = String(__secondsToTicks(fadeStart));
+          levelProp.addKey(t1); levelProp.setValueAtKey(t1, startDb);
+          var t2 = new Time(); t2.ticks = String(__secondsToTicks(clipEnd));
+          levelProp.addKey(t2); levelProp.setValueAtKey(t2, -96);
+          return __result({ trackIndex: trackIdx, clipIndex: clipIdx, clip: clip.name, fadeStart: fadeStart, fadeEnd: clipEnd, startDb: startDb, endDb: -96 });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        cross_fade_clips: {
+            description: "Add audio crossfade between two adjacent clips on the same track (fade out clip N, fade in clip N+1).",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                    clip_index: { type: "number", description: "Index of the first clip (0-based); the crossfade is between this clip and the next one" },
+                    duration_seconds: { type: "number", description: "Total crossfade duration in seconds (split evenly between fade-out and fade-in)" },
+                },
+                required: ["track_index", "clip_index", "duration_seconds"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          var clipIdx = ${args.clip_index};
+          var totalDuration = ${args.duration_seconds};
+          var halfDuration = totalDuration / 2;
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          if (clipIdx >= track.clips.numItems - 1) return __error("Clip index " + clipIdx + " must have a next clip for crossfade");
+          var clip1 = track.clips[clipIdx];
+          var clip2 = track.clips[clipIdx + 1];
+          var getLevel = function(clip) {
+            for (var i = 0; i < clip.components.numItems; i++) {
+              var comp = clip.components[i];
+              if (comp.matchName === "audioVolume" || comp.displayName === "Volume") {
+                for (var p = 0; p < comp.properties.numItems; p++) {
+                  if (comp.properties[p].displayName === "Level") return comp.properties[p];
+                }
+              }
+            }
+            return null;
+          };
+          var level1 = getLevel(clip1);
+          var level2 = getLevel(clip2);
+          if (!level1) return __error("Could not find Volume Level on clip " + clipIdx);
+          if (!level2) return __error("Could not find Volume Level on clip " + (clipIdx + 1));
+          var clip1End = __ticksToSeconds(clip1.end.ticks);
+          var clip1Start = __ticksToSeconds(clip1.start.ticks);
+          var clip2Start = __ticksToSeconds(clip2.start.ticks);
+          var clip2End = __ticksToSeconds(clip2.end.ticks);
+          var fadeOutStart = Math.max(clip1Start, clip1End - halfDuration);
+          level1.setTimeVarying(true);
+          var t1a = new Time(); t1a.ticks = String(__secondsToTicks(fadeOutStart));
+          level1.addKey(t1a); level1.setValueAtKey(t1a, 0);
+          var t1b = new Time(); t1b.ticks = String(__secondsToTicks(clip1End));
+          level1.addKey(t1b); level1.setValueAtKey(t1b, -96);
+          var fadeInEnd = Math.min(clip2End, clip2Start + halfDuration);
+          level2.setTimeVarying(true);
+          var t2a = new Time(); t2a.ticks = String(__secondsToTicks(clip2Start));
+          level2.addKey(t2a); level2.setValueAtKey(t2a, -96);
+          var t2b = new Time(); t2b.ticks = String(__secondsToTicks(fadeInEnd));
+          level2.addKey(t2b); level2.setValueAtKey(t2b, 0);
+          return __result({ trackIndex: trackIdx, clip1Index: clipIdx, clip2Index: clipIdx + 1, clip1: clip1.name, clip2: clip2.name, fadeOutStart: fadeOutStart, clip1End: clip1End, clip2Start: clip2Start, fadeInEnd: fadeInEnd });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_audio_track_info: {
+            description: "Get detailed info for one audio track including name, mute state, level, panning, and all clips.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Audio track index (0-based)" },
+                },
+                required: ["track_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var trackIdx = ${args.track_index};
+          if (trackIdx >= seq.audioTracks.numTracks) return __error("Track index " + trackIdx + " out of range");
+          var track = seq.audioTracks[trackIdx];
+          var trackLevel = 0;
+          var trackPanning = 0;
+          if (track.components) {
+            for (var ci = 0; ci < track.components.numItems; ci++) {
+              var comp = track.components[ci];
+              if (comp.matchName === "audioVolume" || comp.displayName === "Volume") {
+                for (var pi = 0; pi < comp.properties.numItems; pi++) {
+                  if (comp.properties[pi].displayName === "Level") {
+                    try { trackLevel = comp.properties[pi].getValue(); } catch(e) {}
+                    break;
+                  }
+                }
+              }
+              if (comp.matchName === "audioPanner" || comp.displayName === "Panner") {
+                for (var pi2 = 0; pi2 < comp.properties.numItems; pi2++) {
+                  var prop2 = comp.properties[pi2];
+                  if (prop2.displayName === "Balance" || prop2.displayName === "Panner" || prop2.displayName === "Left/Right Balance") {
+                    try { trackPanning = prop2.getValue(); } catch(e2) {}
+                    break;
+                  }
+                }
+              }
+            }
+          }
+          var clips = [];
+          for (var c = 0; c < track.clips.numItems; c++) {
+            var clip = track.clips[c];
+            var clipLevel = 0;
+            for (var ci2 = 0; ci2 < clip.components.numItems; ci2++) {
+              var comp2 = clip.components[ci2];
+              if (comp2.matchName === "audioVolume" || comp2.displayName === "Volume") {
+                for (var pi3 = 0; pi3 < comp2.properties.numItems; pi3++) {
+                  if (comp2.properties[pi3].displayName === "Level") {
+                    try { clipLevel = comp2.properties[pi3].getValue(); } catch(e3) {}
+                    break;
+                  }
+                }
+                break;
+              }
+            }
+            clips.push({
+              index: c,
+              nodeId: clip.nodeId,
+              name: clip.name,
+              start: __ticksToSeconds(clip.start.ticks),
+              end: __ticksToSeconds(clip.end.ticks),
+              level: clipLevel
+            });
+          }
+          return __result({
+            index: trackIdx,
+            name: track.name || ("Audio " + (trackIdx + 1)),
+            numClips: track.clips.numItems,
+            isMuted: __readMaybe(track, "isMuted", false),
+            level: trackLevel,
+            panning: trackPanning,
+            clips: clips
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_clip_audio_volume: {
+            description: "Set the volume level of an audio clip found by its node ID.",
+            parameters: {
+                type: "object",
+                properties: {
+                    node_id: { type: "string", description: "The nodeId of the audio clip (from get_all_clips or get_audio_track_info)" },
+                    level_db: { type: "number", description: "Audio level in dB. Range: -96 to +15. 0 = unity gain." },
+                },
+                required: ["node_id", "level_db"],
+            },
+            handler: async (args) => {
+                const nodeIdEsc = args.node_id.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var nodeId = "${nodeIdEsc}";
+          var levelDb = ${args.level_db};
+          var foundClip = null;
+          var foundTrack = -1;
+          var foundClipIdx = -1;
+          for (var t = 0; t < seq.audioTracks.numTracks; t++) {
+            var track = seq.audioTracks[t];
+            for (var c = 0; c < track.clips.numItems; c++) {
+              var clip = track.clips[c];
+              if (clip.nodeId === nodeId) {
+                foundClip = clip;
+                foundTrack = t;
+                foundClipIdx = c;
+                break;
+              }
+            }
+            if (foundClip) break;
+          }
+          if (!foundClip) return __error("Clip with nodeId '" + nodeId + "' not found in any audio track");
+          // Locale-resilient: __findIntrinsic uses matchName candidates first
+          // (incl. AE.ADBE Audio Levels for PP 2026), then localized displayName.
+          var volComp = __findIntrinsic(foundClip, "volume");
+          if (!volComp) return __error("Volume component not found on clip");
+          var levelProp = __findProp(volComp, ["Level", "Nivel", "Volume", "Volumen", "Pegel"]);
+          if (!levelProp) return __error("Volume Level property not found in Volume component");
+          levelProp.setValue(levelDb, true);
+          return __result({ nodeId: nodeId, clip: foundClip.name, trackIndex: foundTrack, clipIndex: foundClipIdx, levelDb: levelDb });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+    };
+}
+//# sourceMappingURL=audio-advanced.js.map