@synthetic-ai/premiere-mcp 2.0.0

package/dist/tools/transitions-motion.js

@@ -0,0 +1,680 @@
+import { buildToolScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getTransitionsMotionTools(bridgeOptions) {
+    return {
+        fade_in: {
+            description: "Add a video fade-in to a clip by animating opacity from 0 to 100% over the specified duration.",
+            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)" },
+                    duration_seconds: { type: "number", description: "Duration of the fade-in in seconds. Default: 1.0." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const duration = args.duration_seconds ?? 1.0;
+                const script = buildToolScript(`
+          var result = fadeIn(${args.track_index}, ${args.clip_index}, ${duration});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        fade_out: {
+            description: "Add a video fade-out to a clip by animating opacity from 100% to 0 at the end.",
+            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)" },
+                    duration_seconds: { type: "number", description: "Duration of the fade-out in seconds. Default: 1.0." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const duration = args.duration_seconds ?? 1.0;
+                const script = buildToolScript(`
+          var result = fadeOut(${args.track_index}, ${args.clip_index}, ${duration});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        cross_fade_clips: {
+            description: "Create a cross-fade between two adjacent clips by animating opacity. Clip A fades out while Clip B fades in.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index (0-based)" },
+                    clip_index_a: { type: "number", description: "Index of the first clip (fades out)" },
+                    clip_index_b: { type: "number", description: "Index of the second clip (fades in)" },
+                    duration_seconds: { type: "number", description: "Duration of the cross-fade in seconds. Default: 1.0." },
+                },
+                required: ["track_index", "clip_index_a", "clip_index_b"],
+            },
+            handler: async (args) => {
+                const duration = args.duration_seconds ?? 1.0;
+                const script = buildToolScript(`
+          var result = crossFadeClips(${args.track_index}, ${args.clip_index_a}, ${args.clip_index_b}, ${duration});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_opacity_keyframes: {
+            description: "Set multiple opacity keyframes on a video clip for custom fade effects. Keyframes are relative to clip start.",
+            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)" },
+                    keyframes: { type: "array", description: "Array of keyframe objects: [{time: seconds_from_clip_start, value: opacity_0_to_100}]" },
+                },
+                required: ["track_index", "clip_index", "keyframes"],
+            },
+            handler: async (args) => {
+                const keyframesJson = JSON.stringify(JSON.stringify(args.keyframes));
+                const script = buildToolScript(`
+          var result = setOpacityKeyframes(${args.track_index}, ${args.clip_index}, ${keyframesJson});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_warp_stabilizer: {
+            description: "Apply Warp Stabilizer effect to a video clip to reduce camera shake. Smoothness controls how much stabilization is applied.",
+            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)" },
+                    smoothness: { type: "number", description: "Stabilization smoothness 0-100. Default: 50. Higher = more stable but more cropping." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const smoothness = args.smoothness ?? 50;
+                const script = buildToolScript(`
+          var result = applyWarpStabilizer(${args.track_index}, ${args.clip_index}, ${smoothness});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_stabilization_status: {
+            description: "Check if Warp Stabilizer is applied to a clip and get its status.",
+            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 = getStabilizationStatus(${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_gaussian_blur: {
+            description: "Apply Gaussian Blur video effect to 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)" },
+                    blurriness: { type: "number", description: "Blur amount. Default: 10. Higher values = more blur." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const blurriness = args.blurriness ?? 10;
+                const script = buildToolScript(`
+          var result = applyGaussianBlur(${args.track_index}, ${args.clip_index}, ${blurriness});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_directional_blur: {
+            description: "Apply Directional Blur video effect to a clip for a motion blur 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)" },
+                    direction: { type: "number", description: "Blur direction angle in degrees. Default: 0 (horizontal)." },
+                    length: { type: "number", description: "Blur length in pixels. Default: 10." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const direction = args.direction ?? 0;
+                const length = args.length ?? 10;
+                const script = buildToolScript(`
+          var result = applyDirectionalBlur(${args.track_index}, ${args.clip_index}, ${direction}, ${length});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_sharpen: {
+            description: "Apply Sharpen video effect to a clip to increase edge definition.",
+            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)" },
+                    amount: { type: "number", description: "Sharpening amount. Default: 50." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const amount = args.amount ?? 50;
+                const script = buildToolScript(`
+          var result = applySharpen(${args.track_index}, ${args.clip_index}, ${amount});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_unsharp_mask: {
+            description: "Apply Unsharp Mask video effect to a clip for controlled sharpening with radius and threshold.",
+            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)" },
+                    amount: { type: "number", description: "Sharpening amount percentage. Default: 100." },
+                    radius: { type: "number", description: "Radius of sharpening in pixels. Default: 2.0." },
+                    threshold: { type: "number", description: "Threshold for edge detection. Default: 3." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const amount = args.amount ?? 100;
+                const radius = args.radius ?? 2.0;
+                const threshold = args.threshold ?? 3;
+                const script = buildToolScript(`
+          var result = applyUnsharpMask(${args.track_index}, ${args.clip_index}, ${amount}, ${radius}, ${threshold});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_lens_distortion_removal: {
+            description: "Apply Lens Distortion effect to correct barrel/pincushion lens distortion.",
+            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)" },
+                    curvature: { type: "number", description: "Curvature correction. Negative = correct barrel distortion. Default: -50." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const curvature = args.curvature ?? -50;
+                const script = buildToolScript(`
+          var result = applyLensDistortionRemoval(${args.track_index}, ${args.clip_index}, ${curvature});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_video_noise_reduction: {
+            description: "Apply Median video effect to reduce digital noise/grain in 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)" },
+                    amount: { type: "number", description: "Noise reduction radius (1-5). Default: 2." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const amount = args.amount ?? 2;
+                const script = buildToolScript(`
+          var result = applyVideoNoiseReduction(${args.track_index}, ${args.clip_index}, ${amount});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_mirror: {
+            description: "Apply Mirror video effect to a clip to create a reflection.",
+            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)" },
+                    angle: { type: "number", description: "Reflection angle in degrees. Default: 0 (horizontal mirror)." },
+                    center_x: { type: "number", description: "Center X position as fraction (0-1). Default: 0.5 (center)." },
+                    center_y: { type: "number", description: "Center Y position as fraction (0-1). Default: 0.5 (center)." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const angle = args.angle ?? 0;
+                const centerX = args.center_x ?? 0.5;
+                const centerY = args.center_y ?? 0.5;
+                const script = buildToolScript(`
+          var result = applyMirror(${args.track_index}, ${args.clip_index}, ${angle}, ${centerX}, ${centerY});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_corner_pin: {
+            description: "Apply Corner Pin effect to distort a clip by moving its four corners. Useful for screen replacements.",
+            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)" },
+                    corners: { type: "array", description: "Array of 4 corner points as fractions: [{x,y},{x,y},{x,y},{x,y}] in order: upper-left, upper-right, lower-right, lower-left." },
+                },
+                required: ["track_index", "clip_index", "corners"],
+            },
+            handler: async (args) => {
+                const cornersJson = JSON.stringify(JSON.stringify(args.corners));
+                const script = buildToolScript(`
+          var result = applyCornerPin(${args.track_index}, ${args.clip_index}, ${cornersJson});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_crop: {
+            description: "Crop a video clip by specified percentages from each edge using the Crop 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)" },
+                    left: { type: "number", description: "Crop from left edge as percentage (0-100). Default: 0." },
+                    right: { type: "number", description: "Crop from right edge as percentage (0-100). Default: 0." },
+                    top: { type: "number", description: "Crop from top edge as percentage (0-100). Default: 0." },
+                    bottom: { type: "number", description: "Crop from bottom edge as percentage (0-100). Default: 0." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const left = args.left ?? 0;
+                const right = args.right ?? 0;
+                const top = args.top ?? 0;
+                const bottom = args.bottom ?? 0;
+                const script = buildToolScript(`
+          var result = setCrop(${args.track_index}, ${args.clip_index}, ${left}, ${right}, ${top}, ${bottom});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_crop: {
+            description: "Get the current crop 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 = getCrop(${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);
+            },
+        },
+        reset_crop: {
+            description: "Reset crop to zero (remove all cropping) from 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 = resetCrop(${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);
+            },
+        },
+        get_transform_properties: {
+            description: "Get all transform properties (position, scale, rotation, anchor point, opacity) for a video 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 seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var track = seq.videoTracks[${args.track_index}];
+          if (!track) return __error("Video track ${args.track_index} not found");
+          var clip = track.clips[${args.clip_index}];
+          if (!clip) return __error("Clip ${args.clip_index} not found on track ${args.track_index}");
+
+          var motion = __findIntrinsic(clip, "motion");
+          var opacityComp = __findIntrinsic(clip, "opacity");
+
+          function readVal(prop) {
+            if (!prop) return null;
+            try { return prop.getValue(); } catch(e) { return null; }
+          }
+
+          var data = { name: clip.name };
+
+          if (motion) {
+            data.position = readVal(__findProp(motion, ["Position", "Posición", "Position"]));
+            data.scale = readVal(__findProp(motion, ["Scale", "Escala", "Skalierung"]));
+            data.rotation = readVal(__findProp(motion, ["Rotation", "Rotación", "Drehung"]));
+            data.anchorPoint = readVal(__findProp(motion, ["Anchor Point", "Punto de anclaje", "Ankerpunkt"]));
+          } else {
+            data.motion = "not found";
+          }
+
+          if (opacityComp) {
+            data.opacity = readVal(__findProp(opacityComp, ["Opacity", "Opacidad", "Deckkraft"]));
+          } else {
+            data.opacity = null;
+          }
+
+          return __result(data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        reset_transform: {
+            description: "Reset all transform properties (position, scale, rotation) to default 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 = resetTransform(${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);
+            },
+        },
+        center_clip: {
+            description: "Center a video clip in the frame (set position to sequence center).",
+            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 = centerClip(${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);
+            },
+        },
+        fit_clip_to_frame: {
+            description: "Scale a clip to fit the sequence frame while maintaining aspect ratio (letterbox/pillarbox).",
+            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 = fitClipToFrame(${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);
+            },
+        },
+        fill_frame: {
+            description: "Scale a clip to fill the sequence frame (cropping edges if needed, no letterbox).",
+            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 = fillFrame(${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);
+            },
+        },
+        create_pip: {
+            description: "Create a Picture-in-Picture (PIP) effect by scaling and repositioning a clip. The clip is placed at a corner at reduced size.",
+            parameters: {
+                type: "object",
+                properties: {
+                    main_track_index: { type: "number", description: "Main (background) video track index (0-based)" },
+                    main_clip_index: { type: "number", description: "Main clip index (0-based)" },
+                    pip_track_index: { type: "number", description: "PIP (foreground) video track index (0-based)" },
+                    pip_clip_index: { type: "number", description: "PIP clip index (0-based)" },
+                    position: { type: "string", description: "Corner position: 'top-left', 'top-right', 'bottom-left', 'bottom-right', or 'center'. Default: 'bottom-right'." },
+                    scale: { type: "number", description: "PIP scale as percentage of frame. Default: 30." },
+                },
+                required: ["main_track_index", "main_clip_index", "pip_track_index", "pip_clip_index"],
+            },
+            handler: async (args) => {
+                const position = (args.position || "bottom-right").replace(/"/g, '\\"');
+                const scale = args.scale ?? 30;
+                const script = buildToolScript(`
+          var result = createPIP(${args.main_track_index}, ${args.main_clip_index}, ${args.pip_track_index}, ${args.pip_clip_index}, "${position}", ${scale});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        remove_pip: {
+            description: "Remove PIP effect by resetting the clip's position and scale back to full frame.",
+            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 = removePIP(${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);
+            },
+        },
+        set_uniform_scale: {
+            description: "Enable or disable uniform scaling (lock/unlock width-height scale ratio) for a video 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)" },
+                    enabled: { type: "boolean", description: "True to lock uniform scale, false to allow independent width/height scaling" },
+                },
+                required: ["track_index", "clip_index", "enabled"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = setUniformScale(${args.track_index}, ${args.clip_index}, ${args.enabled});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        apply_spherize: {
+            description: "Apply Spherize effect to a video clip to create a spherical/fisheye distortion.",
+            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)" },
+                    radius: { type: "number", description: "Sphere radius as percentage. Default: 50." },
+                    center_x: { type: "number", description: "Center X position as fraction (0-1). Default: 0.5." },
+                    center_y: { type: "number", description: "Center Y position as fraction (0-1). Default: 0.5." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const radius = args.radius ?? 50;
+                const centerX = args.center_x ?? 0.5;
+                const centerY = args.center_y ?? 0.5;
+                const script = buildToolScript(`
+          var result = applySpherize(${args.track_index}, ${args.clip_index}, ${radius}, ${centerX}, ${centerY});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_time_remapping: {
+            description: "Enable or disable time remapping on a video clip for variable speed effects.",
+            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)" },
+                    enabled: { type: "boolean", description: "True to enable time remapping, false to disable" },
+                },
+                required: ["track_index", "clip_index", "enabled"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = setTimeRemapping(${args.track_index}, ${args.clip_index}, ${args.enabled});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        freeze_frame: {
+            description: "Freeze a frame at a specific time on a clip for a specified duration.",
+            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)" },
+                    time: { type: "number", description: "Time in seconds where the freeze frame occurs" },
+                    duration: { type: "number", description: "Duration of the freeze frame in seconds. Default: 2.0." },
+                },
+                required: ["track_index", "clip_index", "time"],
+            },
+            handler: async (args) => {
+                const duration = args.duration ?? 2.0;
+                const script = buildToolScript(`
+          var result = freezeFrame(${args.track_index}, ${args.clip_index}, ${args.time}, ${duration});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        detect_scene_edits: {
+            description: "Automatically detect scene changes in a clip and create cut points. Useful for splitting footage recorded continuously.",
+            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)" },
+                    sensitivity: { type: "number", description: "Detection sensitivity 0-100. Higher = more sensitive, detects more cuts. Default: 50." },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const sensitivity = args.sensitivity ?? 50;
+                const script = buildToolScript(`
+          var result = detectSceneEdits(${args.track_index}, ${args.clip_index}, ${sensitivity});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+    };
+}
+//# sourceMappingURL=transitions-motion.js.map