@synthetic-ai/premiere-mcp 2.0.0

package/dist/tools/color-advanced.js

@@ -0,0 +1,772 @@
+import { buildToolScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getColorAdvancedTools(bridgeOptions) {
+    return {
+        lumetri_get_all: {
+            description: "Get all Lumetri Color parameter values for a clip. Returns exposure, contrast, highlights, shadows, whites, blacks, temperature, tint, saturation, vibrance, vignette, and all other parameters.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video 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 result = lumetriGetAll(${args.track_index}, ${args.clip_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_exposure: {
+            description: "Set Lumetri Color exposure for a clip. Range: -4.0 (very dark) to +4.0 (very bright). 0 = no change.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Exposure value from -4.0 to +4.0" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetExposure(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_contrast: {
+            description: "Set Lumetri Color contrast for a clip. Range: -100 to +100. 0 = no change.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Contrast value from -100 to +100" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetContrast(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_highlights: {
+            description: "Set Lumetri Color highlights for a clip. Range: -100 to +100. Positive values recover highlight detail.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Highlights value from -100 to +100" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetHighlights(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_shadows: {
+            description: "Set Lumetri Color shadows for a clip. Range: -100 to +100. Positive values lift shadows.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Shadows value from -100 to +100" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetShadows(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_whites: {
+            description: "Set Lumetri Color whites for a clip. Range: -100 to +100. Affects the brightest whites.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Whites value from -100 to +100" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetWhites(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_blacks: {
+            description: "Set Lumetri Color blacks for a clip. Range: -100 to +100. Negative values crush the blacks.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Blacks value from -100 to +100" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetBlacks(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_temperature: {
+            description: "Set Lumetri Color white balance temperature for a clip. Negative values are cooler (blue), positive values are warmer (orange).",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Temperature value (negative = cool/blue, positive = warm/orange)" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetTemperature(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_tint: {
+            description: "Set Lumetri Color white balance tint for a clip. Negative values are green, positive values are magenta.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Tint value (negative = green, positive = magenta)" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetTint(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_saturation: {
+            description: "Set Lumetri Color saturation for a clip. Range: 0 (black and white) to 200 (double saturation). 100 = no change.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Saturation value from 0 to 200. 100 = original." },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetSaturation(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_vibrance: {
+            description: "Set Lumetri Color vibrance for a clip. Range: -100 to +100. Vibrance selectively boosts less-saturated colors.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Vibrance value from -100 to +100" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetVibrance(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_faded_film: {
+            description: "Set Lumetri Color faded film amount for a clip. Range: 0 to 100. Creates a filmic fade/matte look.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Faded film amount from 0 to 100" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetFadedFilm(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_sharpen: {
+            description: "Set Lumetri Color sharpening for a clip. Range: 0 to 200. 0 = no sharpening.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Sharpen amount from 0 to 200" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetSharpen(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_curve_point: {
+            description: "Set a point on the RGB/Luma tone curve for Lumetri Color. Channel: 'luma', 'red', 'green', or 'blue'. Input/output values are 0-255.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    channel: { type: "string", description: "Curve channel: 'luma', 'red', 'green', or 'blue'" },
+                    input_value: { type: "number", description: "Input (x-axis) value from 0 to 255" },
+                    output_value: { type: "number", description: "Output (y-axis) value from 0 to 255" },
+                },
+                required: ["track_index", "clip_index", "channel", "input_value", "output_value"],
+            },
+            handler: async (args) => {
+                const safeChannel = args.channel.replace(/"/g, '\\"');
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.videoTracks[${args.track_index}];
+          if (!track || ${args.clip_index} >= track.clips.numItems) return __error("Track or clip not found");
+          var clip = track.clips[${args.clip_index}];
+          var lumetri = null;
+          for (var i = 0; i < clip.components.numItems; i++) {
+            if (clip.components[i].displayName === "Lumetri Color" || clip.components[i].matchName === "AE.ADBE Lumetri") {
+              lumetri = clip.components[i]; break;
+            }
+          }
+          if (!lumetri) {
+            app.enableQE();
+            clip.addVideoEffect(qe.project.getVideoEffectByName("Lumetri Color"));
+            for (var i = 0; i < clip.components.numItems; i++) {
+              if (clip.components[i].displayName === "Lumetri Color") { lumetri = clip.components[i]; break; }
+            }
+            if (!lumetri) return __error("Could not find or add Lumetri Color to clip");
+          }
+          var channelMap = { luma: "Luma Curve", red: "Red Curve", green: "Green Curve", blue: "Blue Curve" };
+          var curvePropName = channelMap["${safeChannel}"] || "Luma Curve";
+          var curveProp = null;
+          for (var p = 0; p < lumetri.properties.numItems; p++) {
+            var group = lumetri.properties[p];
+            if (group.properties) {
+              for (var sp = 0; sp < group.properties.numItems; sp++) {
+                if (group.properties[sp].displayName === curvePropName) {
+                  curveProp = group.properties[sp]; break;
+                }
+              }
+            }
+            if (group.displayName === curvePropName) { curveProp = group; break; }
+            if (curveProp) break;
+          }
+          if (!curveProp) return __error("Could not find curve property: " + curvePropName + ". Ensure Lumetri Color is applied.");
+          var normIn = ${args.input_value} / 255;
+          var normOut = ${args.output_value} / 255;
+          try {
+            var currentVal = curveProp.getValue(0, 0);
+            if (Array.isArray(currentVal)) {
+              currentVal.push(normIn, normOut);
+              curveProp.setValue(currentVal, true);
+            } else {
+              curveProp.setValue([0, 0, normIn, normOut, 1, 1], true);
+            }
+            return __result({ set: true, channel: "${safeChannel}", input: ${args.input_value}, output: ${args.output_value}, normalized: { in: normIn, out: normOut } });
+          } catch(e) {
+            return __error("Could not set curve point: " + e.toString() + ". Try using lumetri_auto_color or setting curves manually.");
+          }
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_shadow_color: {
+            description: "Set the shadow color wheel in Lumetri Color. Adjusts hue, saturation, and brightness of shadows.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    hue: { type: "number", description: "Hue angle in degrees (0-360)" },
+                    saturation: { type: "number", description: "Saturation amount (0-100)" },
+                    brightness: { type: "number", description: "Brightness adjustment (-100 to +100)" },
+                },
+                required: ["track_index", "clip_index", "hue", "saturation", "brightness"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetShadowColor(${args.track_index}, ${args.clip_index}, ${args.hue}, ${args.saturation}, ${args.brightness});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_midtone_color: {
+            description: "Set the midtone color wheel in Lumetri Color. Adjusts hue, saturation, and brightness of midtones.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    hue: { type: "number", description: "Hue angle in degrees (0-360)" },
+                    saturation: { type: "number", description: "Saturation amount (0-100)" },
+                    brightness: { type: "number", description: "Brightness adjustment (-100 to +100)" },
+                },
+                required: ["track_index", "clip_index", "hue", "saturation", "brightness"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetMidtoneColor(${args.track_index}, ${args.clip_index}, ${args.hue}, ${args.saturation}, ${args.brightness});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_highlight_color: {
+            description: "Set the highlight color wheel in Lumetri Color. Adjusts hue, saturation, and brightness of highlights.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    hue: { type: "number", description: "Hue angle in degrees (0-360)" },
+                    saturation: { type: "number", description: "Saturation amount (0-100)" },
+                    brightness: { type: "number", description: "Brightness adjustment (-100 to +100)" },
+                },
+                required: ["track_index", "clip_index", "hue", "saturation", "brightness"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetHighlightColor(${args.track_index}, ${args.clip_index}, ${args.hue}, ${args.saturation}, ${args.brightness});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_vignette_amount: {
+            description: "Set Lumetri Color vignette amount. Range: -5 (dark vignette) to +5 (light vignette). 0 = no vignette.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Vignette amount from -5 to +5" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetVignetteAmount(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_vignette_midpoint: {
+            description: "Set Lumetri Color vignette midpoint (size). Range: 0 to 100. Higher values move the vignette edge outward (smaller vignette).",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Vignette midpoint from 0 to 100" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetVignetteMidpoint(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_vignette_roundness: {
+            description: "Set Lumetri Color vignette roundness. Range: -100 (rectangular) to +100 (circular). 0 = square corners.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Vignette roundness from -100 to +100" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetVignetteRoundness(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_set_vignette_feather: {
+            description: "Set Lumetri Color vignette feather (softness). Range: 0 to 100. Higher values create a softer vignette edge.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    value: { type: "number", description: "Vignette feather from 0 to 100" },
+                },
+                required: ["track_index", "clip_index", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = lumetriSetVignetteFeather(${args.track_index}, ${args.clip_index}, ${args.value});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_apply_lut: {
+            description: "Apply a LUT (.cube or .3dl file) to a clip via Lumetri Color. The LUT file must be accessible on disk.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                    lut_path: { type: "string", description: "Full path to the LUT file (.cube or .3dl)" },
+                },
+                required: ["track_index", "clip_index", "lut_path"],
+            },
+            handler: async (args) => {
+                const lutPathEsc = args.lut_path.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+                const script = buildToolScript(`
+          var result = lumetriApplyLUT(${args.track_index}, ${args.clip_index}, "${lutPathEsc}");
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_remove_lut: {
+            description: "Remove the applied LUT from a clip's Lumetri Color effect.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video 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 result = lumetriRemoveLUT(${args.track_index}, ${args.clip_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_auto_color: {
+            description: "Apply automatic color correction to a clip using Lumetri Color. Sets reasonable default values for exposure and white balance.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video 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 result = lumetriAutoColor(${args.track_index}, ${args.clip_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_reset: {
+            description: "Reset all Lumetri Color parameters to their default (neutral) values for a clip.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video 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 result = lumetriReset(${args.track_index}, ${args.clip_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        lumetri_auto_white_balance: {
+            description: "Apply automatic white balance to a clip using Lumetri Color. Analyzes the clip and adjusts temperature and tint.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video 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 result = lumetriAutoWhiteBalance(${args.track_index}, ${args.clip_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        copy_color_grade: {
+            description: "Copy the Lumetri Color grade from a source clip. Use paste_color_grade afterward to apply it to other clips.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Source video track index (0-based)" },
+                    clip_index: { type: "number", description: "Source clip index on the track (0-based)" },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = copyColorGrade(${args.track_index}, ${args.clip_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        paste_color_grade: {
+            description: "Paste the previously copied Lumetri Color grade to a destination clip. Call copy_color_grade first.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Destination video track index (0-based)" },
+                    clip_index: { type: "number", description: "Destination clip index on the track (0-based)" },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = pasteColorGrade(${args.track_index}, ${args.clip_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_color_grade_to_all: {
+            description: "Copy a color grade from one clip and apply it to all clips on a specified track.",
+            parameters: {
+                type: "object",
+                properties: {
+                    src_track_index: { type: "number", description: "Source clip video track index (0-based)" },
+                    src_clip_index: { type: "number", description: "Source clip index (0-based)" },
+                    dest_track_index: { type: "number", description: "Destination track index where all clips will receive the grade" },
+                },
+                required: ["src_track_index", "src_clip_index", "dest_track_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = applyColorGradeToAll(${args.src_track_index}, ${args.src_clip_index}, ${args.dest_track_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_lut_to_all_clips: {
+            description: "Apply a LUT file to all clips on a video track via Lumetri Color.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    lut_path: { type: "string", description: "Full path to the LUT file (.cube or .3dl)" },
+                },
+                required: ["track_index", "lut_path"],
+            },
+            handler: async (args) => {
+                const lutPathEsc = args.lut_path.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.videoTracks[${args.track_index}];
+          if (!track) return __error("Video track not found at index ${args.track_index}");
+          var lutPath = "${lutPathEsc}";
+          var lutFile = new File(lutPath);
+          if (!lutFile.exists) return __error("LUT file not found: " + lutPath);
+          app.enableQE();
+          var applied = 0;
+          var errors = [];
+          for (var c = 0; c < track.clips.numItems; c++) {
+            var clip = track.clips[c];
+            try {
+              var lumetri = null;
+              for (var i = 0; i < clip.components.numItems; i++) {
+                if (clip.components[i].displayName === "Lumetri Color" || clip.components[i].matchName === "AE.ADBE Lumetri") {
+                  lumetri = clip.components[i]; break;
+                }
+              }
+              if (!lumetri) {
+                clip.addVideoEffect(qe.project.getVideoEffectByName("Lumetri Color"));
+                for (var i = 0; i < clip.components.numItems; i++) {
+                  if (clip.components[i].displayName === "Lumetri Color") { lumetri = clip.components[i]; break; }
+                }
+              }
+              if (!lumetri) { errors.push("Clip " + c + ": could not add Lumetri"); continue; }
+              var lutProp = null;
+              for (var p = 0; p < lumetri.properties.numItems; p++) {
+                var grp = lumetri.properties[p];
+                if (grp.properties) {
+                  for (var sp = 0; sp < grp.properties.numItems; sp++) {
+                    if (grp.properties[sp].displayName === "Input LUT" || grp.properties[sp].displayName === "Creative Look") {
+                      lutProp = grp.properties[sp]; break;
+                    }
+                  }
+                }
+                if (lutProp) break;
+              }
+              if (lutProp) { lutProp.setValue(lutPath, true); applied++; }
+              else { errors.push("Clip " + c + ": LUT property not found"); }
+            } catch(e) { errors.push("Clip " + c + ": " + e.toString()); }
+          }
+          return __result({ applied: applied, total: track.clips.numItems, errors: errors, lutPath: lutPath });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        reset_color_on_all_clips: {
+            description: "Reset Lumetri Color to default values on all clips on a video track.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video 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 track = seq.videoTracks[${args.track_index}];
+          if (!track) return __error("Video track not found at index ${args.track_index}");
+          var count = 0;
+          for (var c = 0; c < track.clips.numItems; c++) {
+            var clip = track.clips[c];
+            var lumetri = __findIntrinsic(clip, "lumetri");
+            if (lumetri) {
+              try { lumetri.remove(); count++; } catch(e) {}
+            }
+          }
+          return __result({ reset: count, total: track.clips.numItems });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_color_info: {
+            description: "Get color information and Lumetri Color settings for a clip.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video 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 result = getColorInfo(${args.track_index}, ${args.clip_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+    };
+}
+//# sourceMappingURL=color-advanced.js.map