editmamei 0.17.4 → 0.18.0

package/dist/tools/filter-tools.js

@@ -352,6 +352,294 @@ const highPassSchema = {
     },
     required: ['radius'],
 };
+const radialBlurSchema = {
+    type: 'object',
+    properties: {
+        amount: {
+            type: 'integer',
+            description: 'Blur strength (1-100). PS default 10.',
+            minimum: 1,
+            maximum: 100,
+            default: 10,
+        },
+        method: {
+            type: 'string',
+            description: 'spin = rotational blur around the center (turntable motion); zoom = radial streaks toward/from the center (the classic "god rays" / speed-zoom look).',
+            enum: ['spin', 'zoom'],
+            default: 'spin',
+        },
+        quality: {
+            type: 'string',
+            description: 'Render quality. best is smoothest but slowest.',
+            enum: ['draft', 'good', 'best'],
+            default: 'good',
+        },
+        center_x: {
+            type: 'number',
+            description: 'Horizontal blur center, normalized 0-1 (0.5 = middle). Resolution-independent.',
+            minimum: 0,
+            maximum: 1,
+            default: 0.5,
+        },
+        center_y: {
+            type: 'number',
+            description: 'Vertical blur center, normalized 0-1 (0.5 = middle). Resolution-independent.',
+            minimum: 0,
+            maximum: 1,
+            default: 0.5,
+        },
+        apply_to_active_layer: APPLY_TO_ACTIVE_LAYER_PROP,
+    },
+};
+const pixelateSchema = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['color_halftone', 'mosaic'],
+            description: 'color_halftone = simulated CMYK halftone dot screen (retro comic / print-dot look); mosaic = blocky square cells (pixelation / censor look).',
+        },
+        max_radius: {
+            type: 'integer',
+            description: 'color_halftone only: maximum dot radius in pixels (4-127). PS default 8.',
+            minimum: 4,
+            maximum: 127,
+            default: 8,
+        },
+        angle_1: {
+            type: 'integer',
+            description: 'color_halftone only: screen angle for channel 1 in degrees. PS default 108.',
+            minimum: -360,
+            maximum: 360,
+            default: 108,
+        },
+        angle_2: {
+            type: 'integer',
+            description: 'color_halftone only: screen angle for channel 2. PS default 162.',
+            minimum: -360,
+            maximum: 360,
+            default: 162,
+        },
+        angle_3: {
+            type: 'integer',
+            description: 'color_halftone only: screen angle for channel 3. PS default 90.',
+            minimum: -360,
+            maximum: 360,
+            default: 90,
+        },
+        angle_4: {
+            type: 'integer',
+            description: 'color_halftone only: screen angle for channel 4. PS default 45.',
+            minimum: -360,
+            maximum: 360,
+            default: 45,
+        },
+        cell_size: {
+            type: 'integer',
+            description: 'mosaic only: cell size in pixels (2-300). PS default 10.',
+            minimum: 2,
+            maximum: 300,
+            default: 10,
+        },
+        apply_to_active_layer: APPLY_TO_ACTIVE_LAYER_PROP,
+    },
+    required: ['mode'],
+};
+const distortSchema = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['twirl', 'ripple', 'polar', 'wave'],
+            description: 'twirl = rotational swirl; ripple = fixed-size wavy displacement; polar = rectangular<->polar coordinate warp (wrap a strip into a circle / "tiny planet", or unwrap a panorama); wave = multi-generator sine/triangle/square waves.',
+        },
+        angle: {
+            type: 'integer',
+            description: 'twirl only: swirl angle in degrees (-999 to 999; positive = clockwise).',
+            minimum: -999,
+            maximum: 999,
+            default: 90,
+        },
+        amount: {
+            type: 'integer',
+            description: 'ripple only: ripple amount (-999 to 999).',
+            minimum: -999,
+            maximum: 999,
+            default: 100,
+        },
+        size: {
+            type: 'string',
+            enum: ['small', 'medium', 'large'],
+            description: 'ripple only: ripple wavelength size.',
+            default: 'medium',
+        },
+        conversion: {
+            type: 'string',
+            enum: ['rect_to_polar', 'polar_to_rect'],
+            description: 'polar only: rect_to_polar wraps the image into a circle; polar_to_rect unwraps it.',
+            default: 'rect_to_polar',
+        },
+        wave_type: {
+            type: 'string',
+            enum: ['sine', 'triangle', 'square'],
+            description: 'wave only: waveform shape.',
+            default: 'sine',
+        },
+        generators: {
+            type: 'integer',
+            description: 'wave only: number of wave generators (1-999).',
+            minimum: 1,
+            maximum: 999,
+            default: 5,
+        },
+        wavelength_min: {
+            type: 'integer',
+            description: 'wave only: minimum wavelength (1-998; must be <= wavelength_max).',
+            minimum: 1,
+            maximum: 998,
+            default: 10,
+        },
+        wavelength_max: {
+            type: 'integer',
+            description: 'wave only: maximum wavelength (1-999).',
+            minimum: 1,
+            maximum: 999,
+            default: 120,
+        },
+        amplitude_min: {
+            type: 'integer',
+            description: 'wave only: minimum amplitude (1-998; must be <= amplitude_max).',
+            minimum: 1,
+            maximum: 998,
+            default: 5,
+        },
+        amplitude_max: {
+            type: 'integer',
+            description: 'wave only: maximum amplitude (1-999).',
+            minimum: 1,
+            maximum: 999,
+            default: 35,
+        },
+        scale_horizontal: {
+            type: 'integer',
+            description: 'wave only: horizontal scale percent (1-100).',
+            minimum: 1,
+            maximum: 100,
+            default: 100,
+        },
+        scale_vertical: {
+            type: 'integer',
+            description: 'wave only: vertical scale percent (1-100).',
+            minimum: 1,
+            maximum: 100,
+            default: 100,
+        },
+        undefined_areas: {
+            type: 'string',
+            enum: ['repeat_edge', 'wrap_around'],
+            description: 'wave only: how to fill areas pushed outside the layer.',
+            default: 'repeat_edge',
+        },
+        random_seed: {
+            type: 'integer',
+            description: 'wave only: random seed for the wave pattern (change for a different pattern).',
+            minimum: 0,
+            default: 12345,
+        },
+        apply_to_active_layer: APPLY_TO_ACTIVE_LAYER_PROP,
+    },
+    required: ['mode'],
+};
+const oilPaintSchema = {
+    type: 'object',
+    properties: {
+        stylization: {
+            type: 'number',
+            description: 'Brush-stroke stylization (0.1-10).',
+            minimum: 0.1,
+            maximum: 10,
+            default: 4,
+        },
+        cleanliness: {
+            type: 'number',
+            description: 'Stroke cleanliness / smoothness (0-10).',
+            minimum: 0,
+            maximum: 10,
+            default: 2.3,
+        },
+        brush_scale: {
+            type: 'number',
+            description: 'Brush scale (0.1-2).',
+            minimum: 0.1,
+            maximum: 2,
+            default: 0.8,
+        },
+        bristle_detail: {
+            type: 'number',
+            description: 'Bristle detail (0-10).',
+            minimum: 0,
+            maximum: 10,
+            default: 10,
+        },
+        light_direction: {
+            type: 'integer',
+            description: 'Lighting angle in degrees (-180 to 180).',
+            minimum: -180,
+            maximum: 180,
+            default: -60,
+        },
+        shine: {
+            type: 'number',
+            description: 'Specular shine (0-10).',
+            minimum: 0,
+            maximum: 10,
+            default: 1.3,
+        },
+        lighting_on: {
+            type: 'boolean',
+            description: 'Whether the lighting/shine relief is applied.',
+            default: true,
+        },
+        apply_to_active_layer: APPLY_TO_ACTIVE_LAYER_PROP,
+    },
+};
+const displaceSchema = {
+    type: 'object',
+    properties: {
+        map_path: {
+            type: 'string',
+            description: "Absolute path to the displacement-map .psd file (required). The map's brightness drives the per-pixel warp — mid-gray = no shift, lighter/darker push in opposite directions.",
+        },
+        horizontal_scale: {
+            type: 'integer',
+            description: 'Horizontal displacement scale (-999 to 999). PS default 10.',
+            minimum: -999,
+            maximum: 999,
+            default: 10,
+        },
+        vertical_scale: {
+            type: 'integer',
+            description: 'Vertical displacement scale (-999 to 999). PS default 10.',
+            minimum: -999,
+            maximum: 999,
+            default: 10,
+        },
+        displacement_map: {
+            type: 'string',
+            enum: ['stretch_to_fit', 'tile'],
+            description: 'How the map fits the layer: stretch_to_fit (resize the map) or tile (repeat it).',
+            default: 'stretch_to_fit',
+        },
+        undefined_areas: {
+            type: 'string',
+            enum: ['repeat_edge', 'wrap_around'],
+            description: 'How to fill areas pushed outside the layer.',
+            default: 'repeat_edge',
+        },
+        apply_to_active_layer: APPLY_TO_ACTIVE_LAYER_PROP,
+    },
+    required: ['map_path'],
+};
 const FILTER_OUTPUT_SCHEMA = {
     type: 'object',
     properties: {
@@ -363,122 +651,125 @@ const FILTER_OUTPUT_SCHEMA = {
         context: { type: 'object' },
     },
 };
-export function createFilterTools(connection, snippetClient) {
-    return [
-        {
-            tool: {
-                name: 'photoshop_apply_gaussian_blur',
-                description: 'Apply Gaussian Blur to a DUPLICATE of the active layer by default (auto-duplicate-first per Bundle O 2026-06-01). The original layer is preserved — the LLM can undo by deleting the copy. Pass `apply_to_active_layer: true` to bake directly into the original (the historical destructive behavior). Auto-rasterizes text/smart-object layers in the path that runs the filter.',
-                inputSchema: gaussianBlurSchema,
-                outputSchema: FILTER_OUTPUT_SCHEMA,
-                annotations: {
-                    title: 'Gaussian Blur',
-                    destructiveHint: true,
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => applyGaussianBlur(connection, snippetClient, args),
-        },
-        {
-            tool: {
-                name: 'photoshop_apply_sharpen',
-                description: 'Apply Unsharp Mask sharpening to a DUPLICATE of the active layer by default (auto-duplicate-first per Bundle O 2026-06-01). The original layer is preserved. Pass `apply_to_active_layer: true` to bake into the original. Auto-rasterizes text/smart-object layers.',
-                inputSchema: sharpenSchema,
-                outputSchema: FILTER_OUTPUT_SCHEMA,
-                annotations: {
-                    title: 'Unsharp Mask',
-                    destructiveHint: true,
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => applySharpen(connection, snippetClient, args),
-        },
-        {
-            tool: {
-                name: 'photoshop_apply_noise',
-                description: 'Apply Add Noise filter to a DUPLICATE of the active layer by default (auto-duplicate-first per Bundle O 2026-06-01). The original is preserved. Pass `apply_to_active_layer: true` to bake into the original. Auto-rasterizes text/smart-object layers.',
-                inputSchema: noiseSchema,
-                outputSchema: FILTER_OUTPUT_SCHEMA,
-                annotations: {
-                    title: 'Add Noise',
-                    destructiveHint: true,
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => applyNoise(connection, snippetClient, args),
-        },
-        {
-            tool: {
-                name: 'photoshop_apply_motion_blur',
-                description: 'Apply Motion Blur to a DUPLICATE of the active layer by default (auto-duplicate-first per Bundle O 2026-06-01). The original is preserved. Pass `apply_to_active_layer: true` to bake into the original. Auto-rasterizes text/smart-object layers.',
-                inputSchema: motionBlurSchema,
-                outputSchema: FILTER_OUTPUT_SCHEMA,
-                annotations: {
-                    title: 'Motion Blur',
-                    destructiveHint: true,
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => applyMotionBlur(connection, snippetClient, args),
+const FILTER_TYPES = [
+    'gaussian_blur',
+    'motion_blur',
+    'lens_blur',
+    'radial_blur',
+    'sharpen',
+    'smart_sharpen',
+    'noise',
+    'reduce_noise',
+    'high_pass',
+    'pixelate',
+    'distort',
+    'displace',
+    'oil_paint',
+];
+const FILTER_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        type: {
+            type: 'string',
+            enum: [...FILTER_TYPES],
+            description: 'Which filter to apply. Each type uses its own parameters: ' +
+                'gaussian_blur(radius); motion_blur(angle, radius); lens_blur(radius, iris_shape, …); ' +
+                'radial_blur(amount, method spin|zoom, quality, center_x, center_y); ' +
+                'sharpen=Unsharp Mask(amount, radius, threshold); smart_sharpen(amount, radius, remove_mode, …); ' +
+                'noise=Add Noise(amount, distribution, monochromatic); ' +
+                'reduce_noise(strength, preserve_details, color_noise, …); high_pass(radius); ' +
+                'pixelate(mode color_halftone|mosaic, …); distort(mode twirl|ripple|polar|wave, …); ' +
+                'displace(map_path, horizontal_scale, vertical_scale, …); oil_paint(stylization, cleanliness, …).',
         },
-        {
-            tool: {
-                name: 'photoshop_apply_lens_blur',
-                description: "Apply Lens Blur (realistic depth-of-field) to a DUPLICATE of the active layer by default. Photographically authentic blur — supports iris-shape control (3-8 blades), blade curvature, rotation, specular highlight boost (for bokeh balls), and noise restoration. Use this instead of Gaussian Blur when the goal is *photographic* DOF — backgrounds in portraits, miniature/tilt-shift effects. Auto-rasterizes text/smart-object layers. Note: the depth_source / focal_distance / invert_depth parameters are currently captured in the result payload but DO NOT influence the emitted Photoshop descriptor — Lens Blur runs against the layer's full alpha. Depth-map-driven blur is pending a second ScriptListener capture; until then, use the iris/specular params for the bokeh effect and apply masking via a separate mask layer.",
-                inputSchema: lensBlurSchema,
-                outputSchema: FILTER_OUTPUT_SCHEMA,
-                annotations: {
-                    title: 'Lens Blur',
-                    destructiveHint: true,
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => applyLensBlur(connection, snippetClient, args),
+        ...gaussianBlurSchema.properties,
+        ...motionBlurSchema.properties,
+        ...lensBlurSchema.properties,
+        ...radialBlurSchema.properties,
+        ...sharpenSchema.properties,
+        ...smartSharpenSchema.properties,
+        ...noiseSchema.properties,
+        ...reduceNoiseSchema.properties,
+        ...highPassSchema.properties,
+        ...pixelateSchema.properties,
+        ...distortSchema.properties,
+        ...displaceSchema.properties,
+        ...oilPaintSchema.properties,
+        radius: {
+            type: 'number',
+            description: 'Radius/distance in px. Range depends on type — gaussian_blur 0.1–250, motion_blur 1–999, lens_blur 0–100, smart_sharpen 0.1–64, high_pass 0.1–1000.',
         },
-        {
-            tool: {
-                name: 'photoshop_apply_smart_sharpen',
-                description: 'Apply Smart Sharpen (modern detail-aware sharpening) to a DUPLICATE of the active layer by default. Prefer this over Unsharp Mask for photo workflows — it has noise-aware sharpening, three blur-removal models (Gaussian/Lens/Motion), and per-tonal-region fade (Shadows/Highlights tabs) to keep shadow noise from amplifying. Default remove_mode is lensBlur which gives the best results for general photo sharpening. Auto-rasterizes text/smart-object layers.',
-                inputSchema: smartSharpenSchema,
-                outputSchema: FILTER_OUTPUT_SCHEMA,
-                annotations: {
-                    title: 'Smart Sharpen',
-                    destructiveHint: true,
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => applySmartSharpen(connection, snippetClient, args),
+        amount: {
+            type: 'number',
+            description: 'Filter strength. Range depends on type — sharpen 1–500, noise 0.1–400, radial_blur 1–100, distort/ripple −999–999.',
         },
-        {
-            tool: {
-                name: 'photoshop_apply_reduce_noise',
-                description: "Apply Reduce Noise to a DUPLICATE of the active layer by default. Photoshop's general-purpose noise reduction for high-ISO / low-light photos. Handles luminance noise (strength) and color noise separately. Optional per-channel mode (per_channel=true) lets you target one RGB channel more aggressively — typically the blue channel in low-light shots. Optional JPEG-artifact removal cleans up 8x8 block boundaries from compressed sources. Auto-rasterizes text/smart-object layers.",
-                inputSchema: reduceNoiseSchema,
-                outputSchema: FILTER_OUTPUT_SCHEMA,
-                annotations: {
-                    title: 'Reduce Noise',
-                    destructiveHint: true,
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => applyReduceNoise(connection, snippetClient, args),
+        angle: {
+            type: 'number',
+            description: 'Angle in degrees. Used by motion_blur (−360–360) and distort/twirl (−999–999).',
         },
+        apply_to_active_layer: APPLY_TO_ACTIVE_LAYER_PROP,
+    },
+    required: ['type'],
+};
+export function createFilterTools(connection, snippetClient) {
+    return [
         {
             tool: {
-                name: 'photoshop_apply_high_pass',
-                description: "Apply High Pass filter (edge-detail extraction) to a DUPLICATE of the active layer by default. The classic creative-sharpening workflow: apply High Pass with a small radius (1-5) to a duplicate, then set the duplicate's blend mode to Overlay or Soft Light — produces detail-preserving sharpening without halos. Also useful for dodge-and-burn masks (larger radius 50-100) and frequency-separation retouching. Auto-rasterizes text/smart-object layers.",
-                inputSchema: highPassSchema,
+                name: 'photoshop_apply_filter',
+                description: 'Apply a Photoshop filter to a DUPLICATE of the active layer by default (auto-duplicate-first per Bundle O — the original is preserved, undo by deleting the copy). Pass `apply_to_active_layer: true` to bake into the original. Auto-rasterizes text/smart-object layers. Choose the filter with `type`; each type takes its own parameters (see the `type` field). Covers blur (gaussian_blur/motion_blur/lens_blur/radial_blur), sharpen (`sharpen`=Unsharp Mask, `smart_sharpen`), noise (`noise`=Add Noise, `reduce_noise`), high_pass, pixelate, distort, displace, and oil_paint.',
+                inputSchema: FILTER_INPUT_SCHEMA,
                 outputSchema: FILTER_OUTPUT_SCHEMA,
                 annotations: {
-                    title: 'High Pass',
+                    title: 'Apply Filter',
                     destructiveHint: true,
                     idempotentHint: false,
                 },
             },
-            handler: async (args) => applyHighPass(connection, snippetClient, args),
+            handler: async (args) => applyFilter(connection, snippetClient, args),
         },
     ];
 }
+async function applyFilter(connection, snippetClient, rawArgs) {
+    const type = rawArgs.type;
+    const { type: _omit, ...rest } = rawArgs;
+    switch (type) {
+        case 'gaussian_blur':
+            return applyGaussianBlur(connection, snippetClient, rest);
+        case 'motion_blur':
+            return applyMotionBlur(connection, snippetClient, rest);
+        case 'lens_blur':
+            return applyLensBlur(connection, snippetClient, rest);
+        case 'radial_blur':
+            return applyRadialBlur(connection, snippetClient, rest);
+        case 'sharpen':
+            return applySharpen(connection, snippetClient, rest);
+        case 'smart_sharpen':
+            return applySmartSharpen(connection, snippetClient, rest);
+        case 'noise':
+            return applyNoise(connection, snippetClient, rest);
+        case 'reduce_noise':
+            return applyReduceNoise(connection, snippetClient, rest);
+        case 'high_pass':
+            return applyHighPass(connection, snippetClient, rest);
+        case 'pixelate':
+            return applyPixelate(connection, snippetClient, rest);
+        case 'distort':
+            return applyDistort(connection, snippetClient, rest);
+        case 'displace':
+            return applyDisplace(connection, snippetClient, rest);
+        case 'oil_paint':
+            return applyOilPaint(connection, snippetClient, rest);
+        default:
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: unknown filter type "${String(type)}". Allowed: ${FILTER_TYPES.join(', ')}.`,
+                    },
+                ],
+                isError: true,
+            };
+    }
+}
 async function applyGaussianBlur(connection, snippetClient, rawArgs) {
     try {
         const args = validateArgs(gaussianBlurSchema, rawArgs);
@@ -835,3 +1126,227 @@ async function applyHighPass(connection, snippetClient, rawArgs) {
         };
     }
 }
+async function applyRadialBlur(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(radialBlurSchema, rawArgs);
+        const amount = args.amount ?? 10;
+        const method = args.method ?? 'spin';
+        const quality = args.quality ?? 'good';
+        const centerX = args.center_x ?? 0.5;
+        const centerY = args.center_y ?? 0.5;
+        const applyToActiveLayer = args.apply_to_active_layer ?? false;
+        const script = await snippetClient.build('applyRadialBlur', {
+            amount,
+            method,
+            quality,
+            centerX,
+            centerY,
+            applyToActiveLayer,
+        });
+        const result = await runScript(connection, script);
+        const r = result;
+        const target = r.target_was_copy
+            ? `new copy "${r.target_layer_name ?? '?'}"`
+            : 'active layer (in place)';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Radial Blur (${method}, amount ${amount}) applied to ${target}.`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error applying Radial Blur: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+async function applyPixelate(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(pixelateSchema, rawArgs);
+        const mode = args.mode;
+        const applyToActiveLayer = args.apply_to_active_layer ?? false;
+        const params = { mode, applyToActiveLayer };
+        if (mode === 'mosaic') {
+            params.cellSize = args.cell_size ?? 10;
+        }
+        else {
+            params.maxRadius = args.max_radius ?? 8;
+            params.angle1 = args.angle_1 ?? 108;
+            params.angle2 = args.angle_2 ?? 162;
+            params.angle3 = args.angle_3 ?? 90;
+            params.angle4 = args.angle_4 ?? 45;
+        }
+        const script = await snippetClient.build('applyPixelate', params);
+        const result = await runScript(connection, script);
+        const r = result;
+        const target = r.target_was_copy
+            ? `new copy "${r.target_layer_name ?? '?'}"`
+            : 'active layer (in place)';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Pixelate (${mode}) applied to ${target}.`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error applying Pixelate: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+async function applyDistort(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(distortSchema, rawArgs);
+        const mode = args.mode;
+        const applyToActiveLayer = args.apply_to_active_layer ?? false;
+        const params = { mode, applyToActiveLayer };
+        if (mode === 'twirl') {
+            params.angle = args.angle ?? 90;
+        }
+        else if (mode === 'ripple') {
+            params.amount = args.amount ?? 100;
+            params.size = args.size ?? 'medium';
+        }
+        else if (mode === 'polar') {
+            params.conversion = args.conversion ?? 'rect_to_polar';
+        }
+        else if (mode === 'wave') {
+            params.waveType = args.wave_type ?? 'sine';
+            params.generators = args.generators ?? 5;
+            params.wavelengthMin = args.wavelength_min ?? 10;
+            params.wavelengthMax = args.wavelength_max ?? 120;
+            params.amplitudeMin = args.amplitude_min ?? 5;
+            params.amplitudeMax = args.amplitude_max ?? 35;
+            params.scaleHorizontal = args.scale_horizontal ?? 100;
+            params.scaleVertical = args.scale_vertical ?? 100;
+            params.undefinedAreas = args.undefined_areas ?? 'repeat_edge';
+            params.randomSeed = args.random_seed ?? 12345;
+        }
+        const script = await snippetClient.build('applyDistort', params);
+        const result = await runScript(connection, script);
+        const r = result;
+        const target = r.target_was_copy
+            ? `new copy "${r.target_layer_name ?? '?'}"`
+            : 'active layer (in place)';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Distort (${mode}) applied to ${target}.`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error applying Distort: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+async function applyOilPaint(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(oilPaintSchema, rawArgs);
+        const params = {
+            stylization: args.stylization ?? 4,
+            cleanliness: args.cleanliness ?? 2.3,
+            brushScale: args.brush_scale ?? 0.8,
+            bristleDetail: args.bristle_detail ?? 10,
+            lightDirection: args.light_direction ?? -60,
+            shine: args.shine ?? 1.3,
+            lightingOn: args.lighting_on ?? true,
+            applyToActiveLayer: args.apply_to_active_layer ?? false,
+        };
+        const script = await snippetClient.build('applyOilPaint', params);
+        const result = await runScript(connection, script);
+        const r = result;
+        const target = r.target_was_copy
+            ? `new copy "${r.target_layer_name ?? '?'}"`
+            : 'active layer (in place)';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Oil Paint applied to ${target}.`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error applying Oil Paint: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+async function applyDisplace(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(displaceSchema, rawArgs);
+        const params = {
+            mapPath: args.map_path,
+            horizontalScale: args.horizontal_scale ?? 10,
+            verticalScale: args.vertical_scale ?? 10,
+            displacementMap: args.displacement_map ?? 'stretch_to_fit',
+            undefinedAreas: args.undefined_areas ?? 'repeat_edge',
+            applyToActiveLayer: args.apply_to_active_layer ?? false,
+        };
+        const script = await snippetClient.build('applyDisplace', params);
+        const result = await runScript(connection, script);
+        const r = result;
+        const target = r.target_was_copy
+            ? `new copy "${r.target_layer_name ?? '?'}"`
+            : 'active layer (in place)';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Displace applied to ${target} using map ${params.mapPath}.`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error applying Displace: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}