editmamei 0.19.0 → 0.22.0

package/dist/tools/filter-tools.js

@@ -1,5 +1,7 @@
 import { runScript } from '../utils/run-script.js';
 import { validateArgs } from '../utils/validate.js';
+import { OnnxLandmarkDetectionClient } from '../detection/landmark-detection-client.js';
+import { resolveGatedPlacement, PLACEMENT_SCHEMA } from '../perception/grounding-locate.js';
 const APPLY_TO_ACTIVE_LAYER_PROP = {
     type: 'boolean',
     description: 'If false (default), the filter is applied to a duplicate of the active layer named "<FilterName> (<Original Name>)" — the original is preserved and the LLM can undo simply by deleting the copy. If true, the filter bakes directly into the active layer (the historical destructive behavior).',
@@ -388,6 +390,10 @@ const radialBlurSchema = {
             maximum: 1,
             default: 0.5,
         },
+        center_placement: {
+            ...PLACEMENT_SCHEMA,
+            description: 'Grounded alternative to center_x/center_y: NAME the blur center (a `placement` resolving to a POINT — an object centroid, an extremum, a grid intersection). The resolved document-pixel point is normalized to the 0-1 center for you and WINS over center_x/center_y. The blur runs ONLY if the objective gate PASSES.',
+        },
         apply_to_active_layer: APPLY_TO_ACTIVE_LAYER_PROP,
     },
 };
@@ -396,8 +402,8 @@ const pixelateSchema = {
     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).',
+            enum: ['color_halftone', 'mosaic', 'crystallize', 'pointillize', 'facet', 'fragment'],
+            description: 'color_halftone = simulated CMYK halftone dot screen (retro comic / print-dot look); mosaic = blocky square cells (pixelation / censor look); crystallize = irregular polygonal cells of solid color; pointillize = random dots over the background color (painterly stipple); facet = clumps similar-colored pixels into flat blocks (parameterless); fragment = four offset copies averaged for a shaken/blurry look (parameterless).',
         },
         max_radius: {
             type: 'integer',
@@ -436,7 +442,7 @@ const pixelateSchema = {
         },
         cell_size: {
             type: 'integer',
-            description: 'mosaic only: cell size in pixels (2-300). PS default 10.',
+            description: 'Cell size in pixels — used by mosaic (2-300, PS default 10), crystallize (3-300), and pointillize (3-300, PS default 5). Ignored by color_halftone/facet/fragment.',
             minimum: 2,
             maximum: 300,
             default: 10,
@@ -450,8 +456,8 @@ const distortSchema = {
     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.',
+            enum: ['twirl', 'ripple', 'polar', 'wave', 'pinch', 'spherize', 'zigzag'],
+            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; pinch = squeeze/bulge toward or away from center; spherize = wrap onto a sphere (bulge); zigzag = concentric ripples (pond-ripple style).',
         },
         angle: {
             type: 'integer',
@@ -462,11 +468,18 @@ const distortSchema = {
         },
         amount: {
             type: 'integer',
-            description: 'ripple only: ripple amount (-999 to 999).',
+            description: 'Displacement amount. ripple: -999 to 999 (default 100). pinch: -100 to 100 (positive pinches inward, negative bulges; default 50). spherize: -100 to 100 (positive bulges out; default 100). zigzag: -100 to 100 (default 10).',
             minimum: -999,
             maximum: 999,
             default: 100,
         },
+        ridges: {
+            type: 'integer',
+            description: 'zigzag only: number of concentric ridges (0-20). PS default 5.',
+            minimum: 0,
+            maximum: 20,
+            default: 5,
+        },
         size: {
             type: 'string',
             enum: ['small', 'medium', 'large'],
@@ -550,6 +563,197 @@ const distortSchema = {
     },
     required: ['mode'],
 };
+const stylizeSchema = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['emboss', 'find_edges', 'solarize', 'wind', 'trace_contour', 'tiles'],
+            description: 'emboss = grey relief with raised edges (angle/height/amount); find_edges = outline edges on a white field (parameterless); solarize = partial tonal inversion (parameterless); wind = fine directional streaks (wind_method + wind_direction); trace_contour = thin contour lines at a brightness level (level + edge); tiles = break the image into offset square tiles (number + offset).',
+        },
+        angle: {
+            type: 'integer',
+            description: 'emboss only: relief angle in degrees (-360 to 360). PS default 135.',
+            minimum: -360,
+            maximum: 360,
+            default: 135,
+        },
+        amount: {
+            type: 'integer',
+            description: 'emboss only: amount percent (1-500). PS default 100.',
+            minimum: 1,
+            maximum: 500,
+            default: 100,
+        },
+        height: {
+            type: 'integer',
+            description: 'emboss only: relief height in pixels (1-100). PS default 3.',
+            minimum: 1,
+            maximum: 100,
+            default: 3,
+        },
+        wind_method: {
+            type: 'string',
+            enum: ['wind', 'blast', 'stagger'],
+            description: 'wind only: streak intensity/style. PS default wind.',
+            default: 'wind',
+        },
+        wind_direction: {
+            type: 'string',
+            enum: ['left', 'right'],
+            description: 'wind only: streak direction. PS default left.',
+            default: 'left',
+        },
+        level: {
+            type: 'integer',
+            description: 'trace_contour only: brightness level the contour traces (0-255). PS default 128.',
+            minimum: 0,
+            maximum: 255,
+            default: 128,
+        },
+        edge: {
+            type: 'string',
+            enum: ['lower', 'upper'],
+            description: 'trace_contour only: trace the lower or upper edge of the level. PS default lower.',
+            default: 'lower',
+        },
+        number: {
+            type: 'integer',
+            description: 'tiles only: number of tiles across (1-99). PS default 10.',
+            minimum: 1,
+            maximum: 99,
+            default: 10,
+        },
+        offset: {
+            type: 'integer',
+            description: 'tiles only: maximum tile offset percent (1-99). PS default 10.',
+            minimum: 1,
+            maximum: 99,
+            default: 10,
+        },
+        apply_to_active_layer: APPLY_TO_ACTIVE_LAYER_PROP,
+    },
+    required: ['mode'],
+};
+const renderSchema = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['clouds', 'difference_clouds', 'fibers'],
+            description: 'clouds = soft random cloud texture from the current foreground/background colors (replaces the layer content); difference_clouds = clouds blended via Difference with the existing pixels (run repeatedly for marble/veining); fibers = woven fiber texture from the FG/BG colors. All three read the FG/BG colors — set them first for a specific palette.',
+        },
+        variance: {
+            type: 'integer',
+            description: 'fibers only: color variance / streak length (1-64). PS default 16.',
+            minimum: 1,
+            maximum: 64,
+            default: 16,
+        },
+        fiber_strength: {
+            type: 'integer',
+            description: 'fibers only: fiber strength / definition (1-64). PS default 4.',
+            minimum: 1,
+            maximum: 64,
+            default: 4,
+        },
+        seed: {
+            type: 'integer',
+            description: 'fibers only: randomize seed — change for a different fiber pattern. PS default 12345.',
+            minimum: 0,
+            default: 12345,
+        },
+        apply_to_active_layer: APPLY_TO_ACTIVE_LAYER_PROP,
+    },
+    required: ['mode'],
+};
+const otherSchema = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['maximum', 'minimum', 'offset'],
+            description: 'maximum = spread/grow bright areas (choke masks, radius + preserve); minimum = spread dark areas (radius + preserve); offset = shift the layer by horizontal/vertical pixels and wrap the edges (seamless-tile workflow).',
+        },
+        radius: {
+            type: 'number',
+            description: 'maximum/minimum only: radius in pixels (1-500). PS default 3.',
+            minimum: 1,
+            maximum: 500,
+            default: 3,
+        },
+        preserve: {
+            type: 'string',
+            enum: ['roundness', 'squareness'],
+            description: 'maximum/minimum only: edge-preservation shape. PS default roundness.',
+            default: 'roundness',
+        },
+        horizontal: {
+            type: 'integer',
+            description: 'offset only: horizontal shift in pixels (positive = right).',
+            default: 0,
+        },
+        vertical: {
+            type: 'integer',
+            description: 'offset only: vertical shift in pixels (positive = down).',
+            default: 0,
+        },
+        apply_to_active_layer: APPLY_TO_ACTIVE_LAYER_PROP,
+    },
+    required: ['mode'],
+};
+const denoiseSchema = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['median', 'dust_and_scratches', 'despeckle'],
+            description: 'median = replace each pixel with the median of its neighborhood (removes speckle, radius); dust_and_scratches = remove small defects above a threshold (radius + threshold); despeckle = light edge-preserving blur (parameterless).',
+        },
+        radius: {
+            type: 'number',
+            description: 'median/dust_and_scratches only: radius in pixels (1-100). PS default 4 (median) / 3 (dust).',
+            minimum: 1,
+            maximum: 100,
+            default: 4,
+        },
+        threshold: {
+            type: 'integer',
+            description: 'dust_and_scratches only: tonal threshold (0-255) below which differences are smoothed. PS default 10.',
+            minimum: 0,
+            maximum: 255,
+            default: 10,
+        },
+        apply_to_active_layer: APPLY_TO_ACTIVE_LAYER_PROP,
+    },
+    required: ['mode'],
+};
+const blurAdvSchema = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['surface_blur', 'box_blur', 'average'],
+            description: 'surface_blur = blur while preserving edges above a threshold (skin-smoothing; radius + threshold); box_blur = fast square-kernel blur (radius); average = fill the layer with its single average color (parameterless).',
+        },
+        radius: {
+            type: 'number',
+            description: 'surface_blur/box_blur only: radius in pixels (1-500). PS default 15 (surface) / 12 (box).',
+            minimum: 1,
+            maximum: 500,
+            default: 15,
+        },
+        threshold: {
+            type: 'integer',
+            description: 'surface_blur only: tonal threshold (0-255) — edges differing by more than this are preserved. PS default 20.',
+            minimum: 0,
+            maximum: 255,
+            default: 20,
+        },
+        apply_to_active_layer: APPLY_TO_ACTIVE_LAYER_PROP,
+    },
+    required: ['mode'],
+};
 const oilPaintSchema = {
     type: 'object',
     properties: {
@@ -663,6 +867,11 @@ const FILTER_TYPES = [
     'high_pass',
     'pixelate',
     'distort',
+    'stylize',
+    'render',
+    'other',
+    'denoise',
+    'blur',
     'displace',
     'oil_paint',
 ];
@@ -678,7 +887,10 @@ const FILTER_INPUT_SCHEMA = {
                 '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, …); ' +
+                'pixelate(mode color_halftone|mosaic|crystallize|pointillize|facet|fragment, …); distort(mode twirl|ripple|polar|wave|pinch|spherize|zigzag, …); ' +
+                'stylize(mode emboss|find_edges|solarize|wind|trace_contour|tiles, …); ' +
+                'render(mode clouds|difference_clouds|fibers, …); ' +
+                'other(mode maximum|minimum|offset, …); denoise(mode median|dust_and_scratches|despeckle, …); blur(mode surface_blur|box_blur|average, …); ' +
                 'displace(map_path, horizontal_scale, vertical_scale, …); oil_paint(stylization, cleanliness, …).',
         },
         ...gaussianBlurSchema.properties,
@@ -692,6 +904,11 @@ const FILTER_INPUT_SCHEMA = {
         ...highPassSchema.properties,
         ...pixelateSchema.properties,
         ...distortSchema.properties,
+        ...stylizeSchema.properties,
+        ...renderSchema.properties,
+        ...otherSchema.properties,
+        ...denoiseSchema.properties,
+        ...blurAdvSchema.properties,
         ...displaceSchema.properties,
         ...oilPaintSchema.properties,
         radius: {
@@ -710,11 +927,11 @@ const FILTER_INPUT_SCHEMA = {
     },
     required: ['type'],
 };
-export function createFilterTools(connection, snippetClient) {
+export function createFilterTools(connection, snippetClient, client = new OnnxLandmarkDetectionClient()) {
     return [
         {
             tool: {
-                name: 'photoshop_apply_filter',
+                name: 'ps_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,
@@ -724,11 +941,11 @@ export function createFilterTools(connection, snippetClient) {
                     idempotentHint: false,
                 },
             },
-            handler: async (args) => applyFilter(connection, snippetClient, args),
+            handler: async (args) => applyFilter(connection, snippetClient, client, args),
         },
     ];
 }
-async function applyFilter(connection, snippetClient, rawArgs) {
+async function applyFilter(connection, snippetClient, detClient, rawArgs) {
     const type = rawArgs.type;
     const { type: _omit, ...rest } = rawArgs;
     switch (type) {
@@ -739,7 +956,7 @@ async function applyFilter(connection, snippetClient, rawArgs) {
         case 'lens_blur':
             return applyLensBlur(connection, snippetClient, rest);
         case 'radial_blur':
-            return applyRadialBlur(connection, snippetClient, rest);
+            return applyRadialBlur(connection, snippetClient, detClient, rest);
         case 'sharpen':
             return applySharpen(connection, snippetClient, rest);
         case 'smart_sharpen':
@@ -754,6 +971,16 @@ async function applyFilter(connection, snippetClient, rawArgs) {
             return applyPixelate(connection, snippetClient, rest);
         case 'distort':
             return applyDistort(connection, snippetClient, rest);
+        case 'stylize':
+            return applyStylize(connection, snippetClient, rest);
+        case 'render':
+            return applyRender(connection, snippetClient, rest);
+        case 'other':
+            return applyOther(connection, snippetClient, rest);
+        case 'denoise':
+            return applyDenoise(connection, snippetClient, rest);
+        case 'blur':
+            return applyBlurAdv(connection, snippetClient, rest);
         case 'displace':
             return applyDisplace(connection, snippetClient, rest);
         case 'oil_paint':
@@ -1126,14 +1353,24 @@ async function applyHighPass(connection, snippetClient, rawArgs) {
         };
     }
 }
-async function applyRadialBlur(connection, snippetClient, rawArgs) {
+async function applyRadialBlur(connection, snippetClient, detClient, 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;
+        let centerX = args.center_x ?? 0.5;
+        let centerY = args.center_y ?? 0.5;
+        let grounded;
+        if (args.center_placement) {
+            const loc = await resolveGatedPlacement(connection, detClient, args.center_placement, {
+                expect: 'point',
+                label: 'radial-blur center',
+            });
+            centerX = loc.docW > 0 ? Math.min(1, Math.max(0, loc.geom.point.x / loc.docW)) : 0.5;
+            centerY = loc.docH > 0 ? Math.min(1, Math.max(0, loc.geom.point.y / loc.docH)) : 0.5;
+            grounded = { x: Math.round(loc.geom.point.x), y: Math.round(loc.geom.point.y) };
+        }
         const applyToActiveLayer = args.apply_to_active_layer ?? false;
         const script = await snippetClient.build('applyRadialBlur', {
             amount,
@@ -1148,14 +1385,25 @@ async function applyRadialBlur(connection, snippetClient, rawArgs) {
         const target = r.target_was_copy
             ? `new copy "${r.target_layer_name ?? '?'}"`
             : 'active layer (in place)';
+        const groundedNote = grounded
+            ? ` centered on (${grounded.x},${grounded.y}) via placement (gate PASS)`
+            : '';
+        const structured = result;
+        if (grounded) {
+            structured.center_placement = {
+                gate: { pass: true },
+                point: grounded,
+                center: { x: Number(centerX.toFixed(4)), y: Number(centerY.toFixed(4)) },
+            };
+        }
         return {
             content: [
                 {
                     type: 'text',
-                    text: `Radial Blur (${method}, amount ${amount}) applied to ${target}.`,
+                    text: `Radial Blur (${method}, amount ${amount}) applied to ${target}${groundedNote}.`,
                 },
             ],
-            structuredContent: result,
+            structuredContent: structured,
         };
     }
     catch (error) {
@@ -1176,10 +1424,10 @@ async function applyPixelate(connection, snippetClient, rawArgs) {
         const mode = args.mode;
         const applyToActiveLayer = args.apply_to_active_layer ?? false;
         const params = { mode, applyToActiveLayer };
-        if (mode === 'mosaic') {
+        if (mode === 'mosaic' || mode === 'crystallize' || mode === 'pointillize') {
             params.cellSize = args.cell_size ?? 10;
         }
-        else {
+        else if (mode === 'color_halftone') {
             params.maxRadius = args.max_radius ?? 8;
             params.angle1 = args.angle_1 ?? 108;
             params.angle2 = args.angle_2 ?? 162;
@@ -1223,6 +1471,16 @@ async function applyDistort(connection, snippetClient, rawArgs) {
         if (mode === 'twirl') {
             params.angle = args.angle ?? 90;
         }
+        else if (mode === 'pinch') {
+            params.amount = args.amount ?? 50;
+        }
+        else if (mode === 'spherize') {
+            params.amount = args.amount ?? 100;
+        }
+        else if (mode === 'zigzag') {
+            params.amount = args.amount ?? 10;
+            params.ridges = args.ridges ?? 5;
+        }
         else if (mode === 'ripple') {
             params.amount = args.amount ?? 100;
             params.size = args.size ?? 'medium';
@@ -1270,6 +1528,205 @@ async function applyDistort(connection, snippetClient, rawArgs) {
         };
     }
 }
+async function applyStylize(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(stylizeSchema, rawArgs);
+        const mode = args.mode;
+        const applyToActiveLayer = args.apply_to_active_layer ?? false;
+        const params = { mode, applyToActiveLayer };
+        if (mode === 'emboss') {
+            params.angle = args.angle ?? 135;
+            params.height = args.height ?? 3;
+            params.amount = args.amount ?? 100;
+        }
+        else if (mode === 'wind') {
+            params.method = args.wind_method ?? 'wind';
+            params.direction = args.wind_direction ?? 'left';
+        }
+        else if (mode === 'trace_contour') {
+            params.level = args.level ?? 128;
+            params.edge = args.edge ?? 'lower';
+        }
+        else if (mode === 'tiles') {
+            params.number = args.number ?? 10;
+            params.offset = args.offset ?? 10;
+        }
+        const script = await snippetClient.build('applyStylize', 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: `Stylize (${mode}) applied to ${target}.`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error applying Stylize: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+async function applyRender(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(renderSchema, rawArgs);
+        const mode = args.mode;
+        const applyToActiveLayer = args.apply_to_active_layer ?? false;
+        const params = { mode, applyToActiveLayer };
+        if (mode === 'fibers') {
+            params.variance = args.variance ?? 16;
+            params.strength = args.fiber_strength ?? 4;
+            params.seed = args.seed ?? 12345;
+        }
+        const script = await snippetClient.build('applyRender', 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: `Render (${mode}) applied to ${target}.`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error applying Render: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+async function applyOther(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(otherSchema, rawArgs);
+        const mode = args.mode;
+        const applyToActiveLayer = args.apply_to_active_layer ?? false;
+        const params = { mode, applyToActiveLayer };
+        if (mode === 'maximum' || mode === 'minimum') {
+            params.radius = args.radius ?? 3;
+            params.preserve = args.preserve ?? 'roundness';
+        }
+        else if (mode === 'offset') {
+            params.horizontal = args.horizontal ?? 0;
+            params.vertical = args.vertical ?? 0;
+        }
+        const script = await snippetClient.build('applyOther', 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: `Other filter (${mode}) applied to ${target}.` }],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error applying filter: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+async function applyDenoise(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(denoiseSchema, rawArgs);
+        const mode = args.mode;
+        const applyToActiveLayer = args.apply_to_active_layer ?? false;
+        const params = { mode, applyToActiveLayer };
+        if (mode === 'median') {
+            params.radius = args.radius ?? 4;
+        }
+        else if (mode === 'dust_and_scratches') {
+            params.radius = args.radius ?? 3;
+            params.threshold = args.threshold ?? 10;
+        }
+        const script = await snippetClient.build('applyDenoise', 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: `Noise reduction (${mode}) applied to ${target}.` }],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error applying noise reduction: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+async function applyBlurAdv(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(blurAdvSchema, rawArgs);
+        const mode = args.mode;
+        const applyToActiveLayer = args.apply_to_active_layer ?? false;
+        const params = { mode, applyToActiveLayer };
+        if (mode === 'surface_blur') {
+            params.radius = args.radius ?? 15;
+            params.threshold = args.threshold ?? 20;
+        }
+        else if (mode === 'box_blur') {
+            params.radius = args.radius ?? 12;
+        }
+        const script = await snippetClient.build('applyBlurAdv', 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: `Blur (${mode}) applied to ${target}.` }],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error applying blur: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
 async function applyOilPaint(connection, snippetClient, rawArgs) {
     try {
         const args = validateArgs(oilPaintSchema, rawArgs);