editmamei 1.7.0 → 1.8.0

package/dist/tools/gimp-transform-layer-tools.js

@@ -0,0 +1,215 @@
+import { validateArgs } from '../utils/validate.js';
+import { toolGimpErrorResult, unknownDiscriminator } from '../utils/tool-helpers.js';
+import { GIMP_IMAGE_PROP, GIMP_LAYER_PROP, GIMP_LAYER_ID_PROP, pickSchemaDeclaredKeys, } from './gimp-shared.js';
+import { EFFECT_UPDATE_FAILURES_PROP, effectUpdateFailuresNote } from './gimp-geometry-tools.js';
+const TRANSFORM_LAYER_OPS = ['fit', 'scale', 'move', 'rotate', 'flip', 'skew', 'free'];
+const xyProp = (what) => ({
+    type: 'object',
+    description: `A document-pixel point: {x, y}. ${what}`,
+    properties: { x: { type: 'number' }, y: { type: 'number' } },
+    required: ['x', 'y'],
+});
+const transformLayerSchema = {
+    type: 'object',
+    properties: {
+        image: GIMP_IMAGE_PROP,
+        layer: {
+            ...GIMP_LAYER_PROP,
+            description: (GIMP_LAYER_PROP.description ?? '') + ' Ignored when layer_id is given.',
+        },
+        layer_id: GIMP_LAYER_ID_PROP,
+        op: {
+            type: 'string',
+            enum: [...TRANSFORM_LAYER_OPS],
+            description: "'fit' scales the layer to fit (letterbox) or fill (cover) the canvas, preserving " +
+                "aspect, and centers it (mode fit|fill, idempotent). 'scale' is uniform (scale_percent) " +
+                'or non-uniform (scale_x_percent/scale_y_percent) — multiplicative, anchored at the ' +
+                "layer's own center; a NON-uniform scale is refused while an unmasked position/" +
+                'direction-dependent effect filter (vignette/motion_blur/drop_shadow) is present. ' +
+                "'move' translates — pass exactly ONE of delta (relative), absolute (top-left target), " +
+                'or center_on (center target), each a {x, y} object (flat delta_x/absolute_x fields are ' +
+                "not accepted); mixing modes is refused. 'rotate' rotates by relative degrees (positive " +
+                "clockwise) around the layer's own center; the layer GROWS to fit the rotated content " +
+                '— nothing is clipped; an arbitrary (non-90°-multiple) angle is refused while such an ' +
+                "effect is present. 'flip' mirrors horizontal|vertical in place (axis). 'skew' slants " +
+                "the layer (skew_h_degrees/skew_v_degrees) around its own center. 'free' is a numeric " +
+                'free transform in one matrix: scale_x_percent/scale_y_percent + degrees + offset_x/' +
+                'offset_y. skew and free are always refused while such an effect is present (no angle ' +
+                'is safe for either). A text layer stays a text layer through every op, never ' +
+                'rasterized.',
+        },
+        mode: {
+            type: 'string',
+            enum: ['fit', 'fill'],
+            description: "fit only. 'fit' letterboxes inside the canvas (shorter edge touches); 'fill' covers it " +
+                '(longer edge touches, overflow is left outside the canvas, not cropped). Defaults to ' +
+                "'fit'.",
+        },
+        scale_percent: {
+            type: 'number',
+            minimum: 1,
+            maximum: 10000,
+            description: 'scale only. Uniform scale percentage (100 = unchanged). 1..10000.',
+        },
+        scale_x_percent: {
+            type: 'number',
+            minimum: 1,
+            maximum: 10000,
+            description: 'scale/free: horizontal scale percentage (100 = unchanged), 1..10000. scale: pair with ' +
+                'scale_y_percent for non-uniform stretch/squash; the other axis defaults to ' +
+                'scale_percent, or 100 if that is absent too.',
+        },
+        scale_y_percent: {
+            type: 'number',
+            minimum: 1,
+            maximum: 10000,
+            description: 'scale/free: vertical scale percentage. See scale_x_percent.',
+        },
+        delta: xyProp("move, RELATIVE mode: offset from the layer's current top-left. Mutually exclusive with absolute/center_on."),
+        absolute: xyProp("move, ABSOLUTE mode: target for the layer's top-left corner. Mutually exclusive with delta/center_on."),
+        center_on: xyProp("move, CENTER mode: target for the layer's center point. Mutually exclusive with delta/absolute."),
+        degrees: {
+            type: 'number',
+            description: "rotate: relative rotation angle, positive clockwise, around the layer's own center. " +
+                'free: relative rotation angle (default 0), applied in the same combined matrix as the ' +
+                'scale and offset.',
+        },
+        axis: {
+            type: 'string',
+            enum: ['horizontal', 'vertical'],
+            description: "flip only. 'horizontal' mirrors left-right; 'vertical' mirrors top-bottom.",
+        },
+        skew_h_degrees: {
+            type: 'number',
+            description: 'skew only. Horizontal slant angle in degrees — positive slants the top edge right. At ' +
+                'least one of skew_h_degrees/skew_v_degrees is required.',
+        },
+        skew_v_degrees: {
+            type: 'number',
+            description: 'skew only. Vertical slant angle in degrees — positive slants the left edge down.',
+        },
+        offset_x: {
+            type: 'number',
+            minimum: -100000,
+            maximum: 100000,
+            description: 'free only. Horizontal translation in document pixels, applied last. Defaults to 0.',
+        },
+        offset_y: {
+            type: 'number',
+            minimum: -100000,
+            maximum: 100000,
+            description: 'free only. Vertical translation in document pixels, applied last. Defaults to 0.',
+        },
+        interpolation: {
+            type: 'string',
+            enum: ['none', 'linear', 'cubic', 'nohalo', 'lohalo'],
+            default: 'cubic',
+            description: 'Resampling filter for this call, every op. Always set explicitly here — never carried ' +
+                'over from a previous gimp_transform_layer call.',
+        },
+    },
+    required: ['image', 'op'],
+};
+function boundsText(result) {
+    const b = result.bounds;
+    return b ? `bounds now (${b.x}, ${b.y}) ${b.width}x${b.height}` : '';
+}
+function alphaNote(result) {
+    return result.alpha_added ? ' (alpha channel added)' : '';
+}
+function effectNote(result) {
+    return effectUpdateFailuresNote(result.effect_update_failures);
+}
+function transformLayerSuccessText(op, result, args) {
+    switch (op) {
+        case 'fit':
+            return (`Layer ${result.mode === 'fill' ? 'filled' : 'fitted'} to the canvas and centered ` +
+                `(${result.scale_percent}%), ${boundsText(result)}${alphaNote(result)}.` +
+                effectNote(result));
+        case 'scale':
+            return (`Layer scaled to ${result.scale_x_percent}% x ${result.scale_y_percent}%, ` +
+                `${boundsText(result)}${alphaNote(result)}.${effectNote(result)}`);
+        case 'move':
+            return `Layer moved, ${boundsText(result)}${alphaNote(result)}.`;
+        case 'rotate':
+            return (`Layer rotated ${result.degrees}°, ${boundsText(result)}${alphaNote(result)}.` +
+                effectNote(result));
+        case 'flip':
+            return (`Layer flipped ${args.axis}, ${boundsText(result)}${alphaNote(result)}.` +
+                effectNote(result));
+        case 'skew':
+            return (`Layer skewed (h=${result.skew_h_degrees ?? 0}°, v=` +
+                `${result.skew_v_degrees ?? 0}°), ${boundsText(result)}${alphaNote(result)}.`);
+        default:
+            return `Layer free-transformed, ${boundsText(result)}${alphaNote(result)}.`;
+    }
+}
+async function gimpTransformLayer(gimp, rawArgs) {
+    try {
+        const args = validateArgs(transformLayerSchema, rawArgs);
+        const op = args.op;
+        if (!TRANSFORM_LAYER_OPS.includes(op)) {
+            return unknownDiscriminator('op', op, TRANSFORM_LAYER_OPS);
+        }
+        const result = await gimp.call('transform_layer', pickSchemaDeclaredKeys(transformLayerSchema, args));
+        return {
+            content: [{ type: 'text', text: transformLayerSuccessText(op, result, args) }],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return toolGimpErrorResult('Error transforming GIMP layer', error);
+    }
+}
+export function createGimpTransformLayerTools(gimp) {
+    return [
+        {
+            tool: {
+                name: 'gimp_transform_layer',
+                description: 'Headless GIMP: transform the active layer (layer/layer_id) — op selects ' +
+                    'fit|scale|move|rotate|flip|skew|free, each documented on op. Rotate/skew/free grow ' +
+                    'the layer so nothing clips; a layer with no alpha gets one (alpha_added). REFUSES ' +
+                    "when the layer, or a group target's descendants, carries a masked filter, or an " +
+                    'unmasked effect this transform cannot keep locked to the content.',
+                inputSchema: transformLayerSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        layer_id: { type: 'number' },
+                        bounds: {
+                            type: 'object',
+                            properties: {
+                                x: { type: ['number', 'null'] },
+                                y: { type: ['number', 'null'] },
+                                width: { type: 'number' },
+                                height: { type: 'number' },
+                            },
+                        },
+                        alpha_added: { type: 'boolean' },
+                        interpolation: { type: 'string' },
+                        text_layer: { type: 'boolean' },
+                        effect_update_failures: EFFECT_UPDATE_FAILURES_PROP,
+                        mode: { type: 'string' },
+                        scale_percent: { type: 'number' },
+                        scale_x_percent: { type: 'number' },
+                        scale_y_percent: { type: 'number' },
+                        degrees: { type: 'number' },
+                        axis: { type: 'string' },
+                        skew_h_degrees: { type: 'number' },
+                        skew_v_degrees: { type: 'number' },
+                        offset_x: { type: 'number' },
+                        offset_y: { type: 'number' },
+                    },
+                },
+                annotations: {
+                    title: 'Transform GIMP Layer',
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    idempotentHint: false,
+                    openWorldHint: true,
+                },
+            },
+            handler: async (args) => gimpTransformLayer(gimp, args),
+        },
+    ];
+}

package/dist/tools/gimp-verify-tools.js

@@ -1,24 +1,13 @@
 import { randomUUID } from 'node:crypto';
-import { readFile, rm } from 'node:fs/promises';
+import { rm } from 'node:fs/promises';
 import { basename } from 'node:path';
 import { validateArgs } from '../utils/validate.js';
 import { toolGimpErrorResult, unknownDiscriminator } from '../utils/tool-helpers.js';
-import { loadSettings } from '../core/settings.js';
 import { Logger } from '../utils/logger.js';
-import { GimpError } from '../backends/gimp/errors.js';
-import { GIMP_IMAGE_PROP, GIMP_REGION_PROP, GIMP_MAX_PX_PROP, pickSchemaDeclaredKeys, } from './gimp-shared.js';
+import { GIMP_IMAGE_PROP, GIMP_REGION_PROP, GIMP_MAX_PX_PROP, pickSchemaDeclaredKeys, readRender, defaultPreviewsAllowed, } from './gimp-shared.js';
 const logger = new Logger('GimpVerifyTools');
 const CHANNELS = ['luminance', 'red', 'green', 'blue'];
-async function readRender(path) {
-    try {
-        return await readFile(path);
-    }
-    catch {
-        throw new GimpError('gimp_op_failed', 'GIMP reported success but the render was not written');
-    }
-}
 export const HISTOGRAM_BIN_COUNT = 256;
-const defaultPreviewsAllowed = () => loadSettings().settings.privacy.send_previews_to_llm;
 const previewSchema = {
     type: 'object',
     properties: {

package/dist/tools/image-placement-tools.js

@@ -1,4 +1,5 @@
 import { runSnippetTool } from '../utils/tool-helpers.js';
+import { requireLocalPath } from '../utils/local-path.js';
 const PS_COORD_MAX_PX = 300_000;
 const placeImageSchema = {
     type: 'object',
@@ -72,7 +73,11 @@ async function placeImage(connection, snippetClient, rawArgs) {
         snippet: 'placeImage',
         errorPrefix: 'Error placing image',
         params: (args) => {
-            const params = { filePath: args.file_path, x: args.x, y: args.y };
+            const params = {
+                filePath: requireLocalPath('file_path', args.file_path),
+                x: args.x,
+                y: args.y,
+            };
             if (args.width_percent !== undefined)
                 params.widthPercent = args.width_percent;
             if (args.height_percent !== undefined)

package/dist/tools/sky-tools.js

@@ -1,4 +1,5 @@
 import { runSnippetTool } from '../utils/tool-helpers.js';
+import { requireLocalPath } from '../utils/local-path.js';
 import { SKY_REPLACEMENT_TIMEOUT_MS } from '../utils/operation-timeouts.js';
 const PLACEHOLDER_SKY_ID = '00000000-0000-0000-0000-000000000000';
 const replaceSkyInputSchema = {
@@ -75,7 +76,7 @@ async function replaceSky(connection, snippetClient, rawArgs) {
         errorPrefix: 'Error running Sky Replacement',
         timeoutMs: SKY_REPLACEMENT_TIMEOUT_MS,
         params: (args) => ({
-            skyPath: args.sky_file,
+            skyPath: requireLocalPath('sky_file', args.sky_file),
             skyName: args.sky_name ?? 'Custom Sky',
             skyId: PLACEHOLDER_SKY_ID,
             shiftEdge: args.shift_edge ?? 0,

package/dist/update/check.js

@@ -99,6 +99,8 @@ export function updateMessage(channel, latest) {
     switch (channel) {
         case 'mcpb':
             return `Download editmamei.mcpb (v${latest}) from ${RELEASES_URL} and reinstall the Claude Desktop extension.`;
+        case 'plugin':
+            return `Editmamei v${latest} is available. Update the Editmamei plugin in Claude, then restart.`;
         case 'dev':
             return `You're on a local dev build — pull the latest source and rebuild.`;
         case 'npx':

package/dist/utils/gimp-path.js

@@ -1,27 +1,23 @@
 import { win32 as pathWin32, posix as pathPosix } from 'node:path';
 import { GimpError } from '../backends/gimp/errors.js';
-const UNC_OR_DEVICE_PATH_RE = /^[\\/]{2}/;
-const WIN32_DRIVE_ROOTED_RE = /^[A-Za-z]:[\\/]/;
+import { localPathProblem } from './local-path.js';
 export function requireAbsoluteGimpPath(field, value, platform = process.platform) {
-    const pathImpl = platform === 'win32' ? pathWin32 : pathPosix;
-    if (typeof value !== 'string' || value.length === 0) {
-        throw new GimpError('invalid_argument', `"${field}" is required and must be a non-empty string`);
+    switch (localPathProblem(value, platform)) {
+        case undefined:
+            return value;
+        case 'not_string':
+            throw new GimpError('invalid_argument', `"${field}" is required and must be a non-empty string`);
+        case 'unc_or_device':
+            throw new GimpError('invalid_argument', `"${field}" must be a plain local path — UNC shares and \\\\?\\ / \\\\.\\ device paths are ` +
+                `refused, got "${value}". Pass a path on a local drive, e.g. C:/Users/you/photo.jpg.`);
+        case 'relative':
+            throw new GimpError('invalid_argument', `"${field}" must be an absolute path, got "${value}" — pass a full filesystem path, not one relative to a working directory the GIMP session doesn't share.`);
+        case 'no_drive':
+            throw new GimpError('invalid_argument', `"${field}" must include a drive letter, got "${value}" — a path rooted at "\\" alone is ` +
+                `ambiguous about which drive it resolves on. Pass e.g. C:/Users/you/photo.jpg.`);
+        case 'unstable': {
+            const resolved = (platform === 'win32' ? pathWin32 : pathPosix).resolve(value);
+            throw new GimpError('invalid_argument', `"${field}" does not resolve to a stable absolute path ("${value}" -> "${resolved}") — pass a plain, fully-qualified path.`);
+        }
     }
-    if (UNC_OR_DEVICE_PATH_RE.test(value)) {
-        throw new GimpError('invalid_argument', `"${field}" must be a plain local path — UNC shares and \\\\?\\ / \\\\.\\ device paths are ` +
-            `refused, got "${value}". Pass a path on a local drive, e.g. C:/Users/you/photo.jpg.`);
-    }
-    if (!pathImpl.isAbsolute(value)) {
-        throw new GimpError('invalid_argument', `"${field}" must be an absolute path, got "${value}" — pass a full filesystem path, not one relative to a working directory the GIMP session doesn't share.`);
-    }
-    if (platform === 'win32' && !WIN32_DRIVE_ROOTED_RE.test(value)) {
-        throw new GimpError('invalid_argument', `"${field}" must include a drive letter, got "${value}" — a path rooted at "\\" alone is ` +
-            `ambiguous about which drive it resolves on. Pass e.g. C:/Users/you/photo.jpg.`);
-    }
-    const normalizeRoot = (root) => root.replace(/\//g, '\\').toLowerCase();
-    const resolved = pathImpl.resolve(value);
-    if (normalizeRoot(pathImpl.parse(resolved).root) !== normalizeRoot(pathImpl.parse(value).root)) {
-        throw new GimpError('invalid_argument', `"${field}" does not resolve to a stable absolute path ("${value}" -> "${resolved}") — pass a plain, fully-qualified path.`);
-    }
-    return value;
 }

package/dist/utils/local-path.js

@@ -0,0 +1,99 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { win32 as pathWin32, posix as pathPosix } from 'node:path';
+const UNC_OR_DEVICE_PATH_RE = /^[\\/]{2}/;
+const WIN32_DRIVE_ROOTED_RE = /^[A-Za-z]:[\\/]/;
+const HOME_RELATIVE_RE = /^~[\\/]/;
+export function localPathProblem(value, platform = process.platform) {
+    const pathImpl = platform === 'win32' ? pathWin32 : pathPosix;
+    if (typeof value !== 'string' || value.length === 0)
+        return 'not_string';
+    if (UNC_OR_DEVICE_PATH_RE.test(value))
+        return 'unc_or_device';
+    if (!pathImpl.isAbsolute(value))
+        return 'relative';
+    if (platform === 'win32' && !WIN32_DRIVE_ROOTED_RE.test(value))
+        return 'no_drive';
+    const normalizeRoot = (root) => root.replace(/\//g, '\\').toLowerCase();
+    const resolved = pathImpl.resolve(value);
+    if (normalizeRoot(pathImpl.parse(resolved).root) !== normalizeRoot(pathImpl.parse(value).root))
+        return 'unstable';
+    return undefined;
+}
+export class PathArgumentError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PathArgumentError';
+    }
+}
+let platformOverride;
+export function setPathPlatformForTests(platform) {
+    platformOverride = platform;
+}
+export function requireLocalPath(field, value, opts = {}) {
+    const platform = opts.platform ?? platformOverride ?? process.platform;
+    const path = typeof value === 'string' && HOME_RELATIVE_RE.test(value)
+        ? (platform === 'win32' ? pathWin32 : pathPosix).join(opts.home ?? homedir(), value.slice(2))
+        : value;
+    switch (localPathProblem(path, platform)) {
+        case undefined:
+            return refuseExtendScriptAmbiguity(field, path, platform);
+        case 'not_string':
+            throw new PathArgumentError(`"${field}" is required and must be a non-empty string.`);
+        case 'unc_or_device':
+            throw new PathArgumentError(`"${field}" must be a file on this computer's own drives: network shares (\\\\server\\share), ` +
+                `WebDAV addresses and \\\\?\\ or \\\\.\\ device paths are refused, got "${String(value)}". ` +
+                'Copy the file to a local folder first.');
+        case 'relative':
+            throw new PathArgumentError(`"${field}" must be an absolute path, got "${String(value)}". Pass a full path, e.g. ` +
+                `${platform === 'win32' ? 'C:/Users/you/Pictures/photo.jpg' : '/Users/you/Pictures/photo.jpg'}.`);
+        case 'no_drive':
+            throw new PathArgumentError(`"${field}" must start with a drive letter, got "${String(value)}". Pass e.g. C:/Users/you/Pictures/photo.jpg.`);
+        case 'unstable':
+            throw new PathArgumentError(`"${field}" does not resolve to a stable absolute path ("${String(value)}"). Pass a plain, full path.`);
+    }
+}
+const PERCENT_ESCAPE_RE = /%[0-9A-Fa-f]{2}/;
+const WIN32_DEVICE_NAME_RE = /^(con|prn|aux|nul|conin\$|conout\$|com[0-9¹²³]|lpt[0-9¹²³])\s*(\..*)?$/i;
+function refuseExtendScriptAmbiguity(field, path, platform) {
+    if (PERCENT_ESCAPE_RE.test(path)) {
+        throw new PathArgumentError(`"${field}" must not contain a percent-escape such as %20 or %5F, got "${path}". Write the characters themselves.`);
+    }
+    if (platform === 'win32') {
+        if (path.indexOf(':', 2) !== -1) {
+            throw new PathArgumentError(`"${field}" must not contain ":" after the drive letter, got "${path}".`);
+        }
+        if (WIN32_DEVICE_NAME_RE.test(pathWin32.basename(path))) {
+            throw new PathArgumentError(`"${field}" names a Windows device (${pathWin32.basename(path)}), not a file.`);
+        }
+    }
+    return path;
+}
+export function looksLikePath(value) {
+    return /[\\/]/.test(value) || /^[A-Za-z]:/.test(value) || HOME_RELATIVE_RE.test(value);
+}
+const written = new Set();
+function outputKey(path, platform) {
+    const resolved = (platform === 'win32' ? pathWin32 : pathPosix).resolve(path);
+    return platform === 'win32' || platform === 'darwin' ? resolved.toLowerCase() : resolved;
+}
+export function checkOutputPath(field, value, opts) {
+    const platform = opts.platform ?? platformOverride ?? process.platform;
+    const path = requireLocalPath(field, value, opts);
+    const lower = path.toLowerCase();
+    if (!opts.extensions.some((ext) => lower.endsWith(ext))) {
+        throw new PathArgumentError(`"${field}" must end in ${opts.extensions.join(' or ')}, got "${path}".`);
+    }
+    const exists = opts.exists ?? existsSync;
+    if (opts.overwrite !== true && exists(path) && !written.has(outputKey(path, platform))) {
+        throw new PathArgumentError(`"${field}": a file already exists at "${path}" and was not written in this session. Choose a new ` +
+            'name, or pass overwrite: true only if the user asked to replace that file.');
+    }
+    return path;
+}
+export function recordOutputPath(path, platform = platformOverride ?? process.platform) {
+    written.add(outputKey(path, platform));
+}
+export function resetOutputPathsForTests() {
+    written.clear();
+}

package/dist/utils/operation-timeouts.js

@@ -86,7 +86,6 @@ export const TOOL_TIMEOUT_BUDGETS_MS = {
     gimp_crop_document: 20_000,
     gimp_resize_image: 45_000,
     gimp_transform_canvas: 60_000,
-    gimp_create_mask: 20_000,
     gimp_get_preview: 30_000,
     gimp_get_histogram: 90_000,
     gimp_compare: 45_000,
@@ -97,6 +96,13 @@ export const TOOL_TIMEOUT_BUDGETS_MS = {
     gimp_place_image: 30_000,
     gimp_canvas: 30_000,
     gimp_convert_image_mode: 30_000,
+    gimp_text: 30_000,
+    gimp_select: 20_000,
+    gimp_modify_selection: 90_000,
+    gimp_layer_mask: 15_000,
+    gimp_get_selection_preview: 30_000,
+    gimp_transform_layer: 30_000,
+    gimp_match_layer: 70_000,
 };
 export const TOOLS_WITHOUT_A_BUDGET = {
     ps_report_problem: 'n=3 measured calls',

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.7.0';
+export const VERSION = '1.8.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "editmamei",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Photoshop MCP server: natural-language AI photo editing in desktop Photoshop (Community Edition)",
   "mcpName": "io.github.editmamei/editmamei",
   "editmamei": {
@@ -68,7 +68,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.1",
+    "@modelcontextprotocol/sdk": "^1.32.1",
     "adm-zip": "^0.6.1",
     "jpeg-js": "^0.4.4",
     "onnxruntime-web": "1.30.0"

package/dist/tools/gimp-mask-tools.js

@@ -1,102 +0,0 @@
-import { GIMP_IMAGE_PROP, runGimpTool } from './gimp-shared.js';
-const createMaskSchema = {
-    type: 'object',
-    properties: {
-        image: GIMP_IMAGE_PROP,
-        type: {
-            type: 'string',
-            enum: ['rectangle', 'ellipse', 'gradient_linear', 'gradient_radial'],
-            description: 'rectangle/ellipse: geometric selection (needs x, y, width, height). gradient_linear: a ' +
-                'ramp from (x1,y1) to (x2,y2), default the full image width. gradient_radial: a ramp from ' +
-                'full effect at the center (cx,cy) fading to none at radius, default centered at the ' +
-                "image's own center with radius = half the shorter side.",
-        },
-        name: {
-            type: 'string',
-            default: 'Mask',
-            description: 'Channel name — replaces any existing channel of the same name (refused if that name is ' +
-                "already used as an existing filter's mask). Pass this name to gimp_add_adjustment's " +
-                '`mask` field to confine a new filter to it.',
-        },
-        invert: {
-            type: 'boolean',
-            default: false,
-            description: 'rectangle/ellipse: invert the selection. gradient_linear/gradient_radial: swap which end ' +
-                'is black vs white.',
-        },
-        feather_px: {
-            type: 'number',
-            minimum: 0,
-            maximum: 1000,
-            default: 0,
-            description: 'rectangle/ellipse only. Feather radius in pixels. No effect on a gradient (already continuous).',
-        },
-        x: { type: 'number', description: 'rectangle/ellipse: left edge, document pixels.' },
-        y: { type: 'number', description: 'rectangle/ellipse: top edge, document pixels.' },
-        width: { type: 'number', description: 'rectangle/ellipse: width, document pixels.' },
-        height: { type: 'number', description: 'rectangle/ellipse: height, document pixels.' },
-        x1: { type: 'number', description: 'gradient_linear: start point x. Default 0.' },
-        y1: { type: 'number', description: 'gradient_linear: start point y. Default 0.' },
-        x2: { type: 'number', description: "gradient_linear: end point x. Default the image's width." },
-        y2: { type: 'number', description: 'gradient_linear: end point y. Default 0.' },
-        cx: {
-            type: 'number',
-            description: "gradient_radial: center x. Default the image's own center.",
-        },
-        cy: {
-            type: 'number',
-            description: "gradient_radial: center y. Default the image's own center.",
-        },
-        radius: {
-            type: 'number',
-            description: 'gradient_radial: radius, document pixels. Default half the shorter image side.',
-        },
-    },
-    required: ['image', 'type'],
-};
-export function createGimpMaskTools(gimp) {
-    return [
-        {
-            tool: {
-                name: 'gimp_create_mask',
-                description: 'Headless GIMP: build a geometric mask (rectangle / ellipse / linear or radial gradient) ' +
-                    'into a NAMED channel. The active selection is CLEARED when this call returns — it does ' +
-                    'NOT leave the mask selected the way a Photoshop selection would. Pass the returned ' +
-                    "`channel` name to gimp_add_adjustment's `mask` field WHEN CREATING a new filter — that " +
-                    "is the ONLY way to apply it — a filter's mask is fixed at creation and cannot be " +
-                    'changed on a re-edit. Order matters: straighten / flip / resize the canvas FIRST (see ' +
-                    'gimp_transform_canvas, gimp_resize_image), then crop, then create masks and masked ' +
-                    'adjustments — rotate, flip, and resize all refuse outright once ANY masked adjustment ' +
-                    'filter exists on the image, or any filter not created by Editmamei (for example one ' +
-                    'added in the GIMP GUI).',
-                inputSchema: createMaskSchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        channel: { type: 'string' },
-                        selected_pixels: { type: 'number' },
-                        fraction: { type: 'number' },
-                    },
-                },
-                annotations: {
-                    title: 'Create GIMP Mask',
-                    readOnlyHint: false,
-                    destructiveHint: true,
-                    idempotentHint: false,
-                    openWorldHint: true,
-                },
-            },
-            handler: async (args) => runGimpTool({
-                gimp,
-                rawArgs: args,
-                schema: createMaskSchema,
-                op: 'create_mask',
-                errorPrefix: 'Error creating GIMP mask',
-                successText: (result) => {
-                    const r = result;
-                    return `Created mask channel "${r.channel}" — ${(r.fraction * 100).toFixed(1)}% of pixels selected.`;
-                },
-            }),
-        },
-    ];
-}