editmamei 1.6.0 → 1.7.1

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

@@ -0,0 +1,385 @@
+import { validateArgs } from '../utils/validate.js';
+import { toolGimpErrorResult, unknownDiscriminator } from '../utils/tool-helpers.js';
+import { GIMP_IMAGE_PROP, GIMP_LAYER_PROP, pickSchemaDeclaredKeys } from './gimp-shared.js';
+const LAYER_OPS = [
+    'create',
+    'create_group',
+    'delete',
+    'duplicate',
+    'select',
+    'set',
+    'move',
+    'reorder',
+    'merge_down',
+    'flatten',
+];
+const layerSchema = {
+    type: 'object',
+    properties: {
+        image: GIMP_IMAGE_PROP,
+        op: {
+            type: 'string',
+            enum: [...LAYER_OPS],
+            description: "'create' adds a new, empty layer (width/height default to the image size, capped the " +
+                "same way gimp_resize_image's target is; fill white/black/transparent, default " +
+                "transparent). 'create_group' adds a group layer (a folder for other layers). 'delete' " +
+                'removes a layer (a group takes its children with it) and prunes any of its filters from ' +
+                "the ledger — REFUSED if it is or contains the image's only remaining layer. 'duplicate' " +
+                'copies a layer, inserted directly above the source — REFUSED when the layer (or, for a ' +
+                "group, any descendant) carries an Editmamei filter, since the copy's filter would collide " +
+                "with the original's own ledger record. 'select' sets the active layer (the default " +
+                'target for gimp_add_adjustment and friends when no layer is named) and is the one sub-op ' +
+                "that changes nothing else. 'set' changes opacity, mode, visible, and/or name (at least " +
+                'one required, name may not be empty) — mode is a blend mode from a fixed list, not a raw ' +
+                "GEGL/GIMP name. 'move' repositions a layer to an ABSOLUTE x/y (not a delta), bounded to " +
+                'stay near the canvas — REFUSED when the layer, or a group containing it, carries a ' +
+                "masked or unverifiable adjustment filter, since a filter's mask does not travel with " +
+                "content that moves beneath it. 'reorder' " +
+                "changes a layer's stack position and/or moves it into a group (parent_group) or out to " +
+                'top-level (to_top_level: true) — neither given keeps the layer in its current group and ' +
+                'only changes `position`; REFUSED if parent_group would nest a group inside itself or one ' +
+                "of its own descendants. 'merge_down' bakes ONE layer's live filters (masked ones " +
+                'included) into pixels and merges it into the first VISIBLE layer below it in the same ' +
+                'group/level — REFUSED if the SOURCE layer itself is hidden (GIMP cannot merge a hidden ' +
+                'layer down), if that target would be a group, if there is no visible layer below (a ' +
+                'hidden one in between is skipped, not merged), or if the merged result would exceed the ' +
+                'same size cap gimp_resize_image enforces; a visible text layer involved is ' +
+                "rasterized (reported as rasterized_text). 'flatten' collapses the WHOLE image into a " +
+                'single layer the same way, always drops alpha (reported as has_alpha: false), and ' +
+                'REFUSES by default when any layer is hidden, INCLUDING a layer whose own visibility is ' +
+                'on but sits inside a hidden group (GIMP discards a hidden layer outright rather than ' +
+                'compositing it in) unless discard_hidden: true is given.',
+        },
+        layer: {
+            ...GIMP_LAYER_PROP,
+            description: (GIMP_LAYER_PROP.description ?? '') +
+                ' Ignored when layer_id is given. Not used by create, create_group, or flatten.',
+        },
+        layer_id: {
+            type: 'integer',
+            description: 'Canonical layer id (from gimp_inspect or a prior gimp_layer/gimp_bake result) — takes ' +
+                'priority over `layer` (name) when both are given, and is the only way to address two ' +
+                'layers that happen to share a name. Not used by create, create_group, or flatten.',
+        },
+        name: {
+            type: 'string',
+            description: "create/create_group: the new layer's name (default 'Layer'/'Group'). set: renames the " +
+                'target layer; may not be empty. Every case enforces a unique name, suffixing " 2", " 3", ' +
+                '... if the name is already taken (GIMP itself allows duplicates; this tool does not).',
+        },
+        width: {
+            type: 'integer',
+            minimum: 1,
+            description: 'create only. Defaults to the image width.',
+        },
+        height: {
+            type: 'integer',
+            minimum: 1,
+            description: 'create only. Defaults to the image height.',
+        },
+        fill: {
+            type: 'string',
+            enum: ['white', 'black', 'transparent'],
+            default: 'transparent',
+            description: "create only. The new layer's initial content.",
+        },
+        parent_group: {
+            type: 'integer',
+            description: 'create/create_group: the group layer_id to insert the new layer into (omit for ' +
+                'top-level). reorder: the group layer_id to move the layer into. Must itself be a group, ' +
+                'and cannot be the layer being moved or one of its own descendants. Omit (leaving the ' +
+                'layer in its current group) or use to_top_level instead to move it OUT of a group — ' +
+                'there is no way to pass "no group" through this field itself.',
+        },
+        to_top_level: {
+            type: 'boolean',
+            default: false,
+            description: 'reorder only. Moves the layer to the top level, out of whatever group (if any) it is ' +
+                'currently in. Takes priority over parent_group if both are given.',
+        },
+        position: {
+            type: 'integer',
+            minimum: 0,
+            default: 0,
+            description: "create/create_group/reorder: index within the target parent's (or top-level) stack, " +
+                '0 = topmost.',
+        },
+        opacity: {
+            type: 'number',
+            minimum: 0,
+            maximum: 100,
+            description: 'set only.',
+        },
+        mode: {
+            type: 'string',
+            enum: [
+                'normal',
+                'multiply',
+                'screen',
+                'overlay',
+                'soft_light',
+                'hard_light',
+                'darken',
+                'lighten',
+                'difference',
+                'exclusion',
+                'addition',
+                'subtract',
+                'divide',
+                'dodge',
+                'burn',
+                'hue',
+                'saturation',
+                'color',
+                'luminosity',
+            ],
+            description: 'set only. A fixed blend-mode list, not a raw GEGL/GIMP mode name.',
+        },
+        visible: {
+            type: 'boolean',
+            description: 'set only.',
+        },
+        x: {
+            type: 'integer',
+            description: "move only. The layer's new ABSOLUTE horizontal offset in document pixels (not a delta).",
+        },
+        y: {
+            type: 'integer',
+            description: "move only. The layer's new ABSOLUTE vertical offset in document pixels (not a delta).",
+        },
+        discard_hidden: {
+            type: 'boolean',
+            default: false,
+            description: 'flatten only. Without it, flatten REFUSES when any layer is hidden (naming them) rather ' +
+                'than silently discarding them — pass true to proceed; the discarded layers are reported ' +
+                'back as discarded_hidden_layers.',
+        },
+    },
+    required: ['image', 'op'],
+};
+function layerSuccessText(op, result, args) {
+    switch (op) {
+        case 'create':
+            return `Created layer ${result.layer_id} ("${result.name}").`;
+        case 'create_group':
+            return `Created group ${result.layer_id} ("${result.name}").`;
+        case 'delete':
+            return `Deleted layer ${result.layer_id} ("${result.name}").`;
+        case 'duplicate':
+            return `Duplicated as layer ${result.layer_id} ("${result.name}").`;
+        case 'select':
+            return `Selected layer ${result.layer_id} ("${result.name}").`;
+        case 'move':
+            return `Moved layer ${result.layer_id} to (${result.x}, ${result.y}).`;
+        case 'reorder':
+            return (`Reordered layer ${result.layer_id}` +
+                (result.parent_group != null
+                    ? ` into group ${result.parent_group}.`
+                    : ' to top-level.'));
+        case 'merge_down':
+            return (`Merged down into layer ${result.layer_id} ("${result.name}").` +
+                (result.rasterized_text ? ' A visible text layer was rasterized in the process.' : ''));
+        case 'flatten': {
+            const discarded = result.discarded_hidden_layers ?? [];
+            return (`Flattened to a single layer ${result.layer_id} ("${result.name}"), alpha dropped.` +
+                (result.rasterized_text ? ' A visible text layer was rasterized in the process.' : '') +
+                (discarded.length > 0
+                    ? ` Discarded ${discarded.length} hidden layer(s): ${discarded.map((l) => l.name).join(', ')}.`
+                    : ''));
+        }
+        default: {
+            const changed = ['opacity', 'mode', 'visible', 'name'].filter((k) => k in args);
+            return `Layer ${result.layer_id} ("${result.name}") updated: ${changed.join(', ')}.`;
+        }
+    }
+}
+function layerBridgeArgs(args) {
+    const picked = pickSchemaDeclaredKeys(layerSchema, args);
+    if (args.op === 'reorder' && args.to_top_level === true) {
+        picked.parent_group = null;
+    }
+    delete picked.to_top_level;
+    return picked;
+}
+async function gimpLayer(gimp, rawArgs) {
+    try {
+        const args = validateArgs(layerSchema, rawArgs);
+        const op = args.op;
+        if (!LAYER_OPS.includes(op)) {
+            return unknownDiscriminator('op', op, LAYER_OPS);
+        }
+        const result = await gimp.call('layer', layerBridgeArgs(args));
+        return {
+            content: [{ type: 'text', text: layerSuccessText(op, result, args) }],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return toolGimpErrorResult('Error managing GIMP layer', error);
+    }
+}
+const bakeSchema = {
+    type: 'object',
+    properties: {
+        image: GIMP_IMAGE_PROP,
+        layer: {
+            ...GIMP_LAYER_PROP,
+            description: (GIMP_LAYER_PROP.description ?? '') + ' Ignored when layer_id or all is given.',
+        },
+        layer_id: {
+            type: 'integer',
+            description: 'Canonical layer id. Takes priority over `layer`. Ignored when `all` is given.',
+        },
+        all: {
+            type: 'boolean',
+            default: false,
+            description: 'Bake every layer on the image that has any live filter, instead of just one. A group ' +
+                'layer is always skipped even when it carries its own filter (GIMP cannot merge filters ' +
+                'on a group item) — any such group is reported under skipped_groups_with_filters rather ' +
+                'than silently ignored.',
+        },
+    },
+    required: ['image'],
+};
+async function gimpBake(gimp, rawArgs) {
+    try {
+        const args = validateArgs(bakeSchema, rawArgs);
+        const result = await gimp.call('bake', pickSchemaDeclaredKeys(bakeSchema, args));
+        let text;
+        if (args.all) {
+            const baked = result.baked_layers ?? [];
+            const skipped = result.skipped_groups_with_filters ?? [];
+            text =
+                baked.length > 0
+                    ? `Baked ${baked.length} layer(s): ${baked.map((l) => l.name).join(', ')}.`
+                    : 'No layer had a live filter to bake.';
+            if (skipped.length > 0) {
+                text += ` Skipped ${skipped.length} group(s) that carry a filter GIMP cannot bake: ${skipped.map((l) => l.name).join(', ')}.`;
+            }
+        }
+        else {
+            text = result.baked
+                ? `Baked every filter on layer ${result.layer_id} ("${result.name}") into its pixels.`
+                : `Layer ${result.layer_id} ("${result.name}") had no live filter to bake.`;
+        }
+        return {
+            content: [{ type: 'text', text }],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return toolGimpErrorResult('Error baking GIMP filters', error);
+    }
+}
+export function createGimpLayerTools(gimp) {
+    return [
+        {
+            tool: {
+                name: 'gimp_layer',
+                description: 'Headless GIMP: layer management. op: create | create_group | delete | duplicate | ' +
+                    'select | set | move | reorder | merge_down | flatten (a group is created, addressed, ' +
+                    'and reordered the same as any other layer — there is no separate group tool). ' +
+                    'Addressed by layer_id (canonical — an id from gimp_inspect or a prior gimp_layer/' +
+                    'gimp_bake result) or layer (name; GIMP allows duplicate names, so layer_id is the only ' +
+                    'handle that always tells two apart). Every op except select changes pixels or layer ' +
+                    'structure, and there is no undo in this session: gimp_checkpoint or gimp_save_xcf ' +
+                    'first when in doubt. duplicate REFUSES outright when the layer (or, for a group, any ' +
+                    "descendant) carries an Editmamei filter, since the copy's filter would collide with " +
+                    "the original's own ledger record; bake it first (gimp_bake) or delete it, then " +
+                    'duplicate. move takes an ABSOLUTE x/y (not a delta) and REFUSES when the layer, or ' +
+                    'a group containing it, carries a masked or unverifiable adjustment filter — a ' +
+                    "filter's mask does not travel with content that moves beneath it, the same physics " +
+                    'gimp_transform_canvas refuses on. merge_down REFUSES outright when the SOURCE layer ' +
+                    'itself is hidden (GIMP cannot merge a hidden layer down); it and ' +
+                    'flatten both bake every live filter they touch into pixels first (masked filters ' +
+                    'included) and rasterize any VISIBLE text layer in the process (rasterized_text); ' +
+                    'flatten always drops alpha (has_alpha: false) and, by default, REFUSES outright when ' +
+                    'any layer is hidden — INCLUDING one whose own visibility is on but sits inside a ' +
+                    'hidden group — rather than silently discarding it (discard_hidden: true proceeds and ' +
+                    'reports what was discarded).',
+                inputSchema: layerSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        layer_id: { type: 'number' },
+                        name: { type: 'string' },
+                        is_group: { type: 'boolean' },
+                        deleted: { type: 'boolean' },
+                        opacity: { type: 'number' },
+                        mode: { type: 'string' },
+                        visible: { type: 'boolean' },
+                        x: { type: ['number', 'null'] },
+                        y: { type: ['number', 'null'] },
+                        parent_group: { type: ['number', 'null'] },
+                        rasterized_text: { type: 'boolean' },
+                        has_alpha: { type: 'boolean' },
+                        discarded_hidden_layers: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: { layer_id: { type: 'number' }, name: { type: 'string' } },
+                            },
+                        },
+                    },
+                },
+                annotations: {
+                    title: 'Manage GIMP Layer',
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    idempotentHint: false,
+                    openWorldHint: true,
+                },
+            },
+            handler: async (args) => gimpLayer(gimp, args),
+        },
+        {
+            tool: {
+                name: 'gimp_bake',
+                description: "Headless GIMP: bake a layer's live filters into its own pixels without merging it " +
+                    'into anything else — the layer survives as itself, just with no more re-editable ' +
+                    'filters; a text layer stays a text layer (baking never rasterizes one). A masked ' +
+                    "filter's confinement survives the bake exactly. Defaults to the selected layer, or the " +
+                    'topmost layer if none is selected, the same as any other gimp_layer addressing. Baking ' +
+                    'clears any masked-filter refusal (gimp_layer op=move, gimp_canvas, gimp_resize_image, ' +
+                    'gimp_transform_canvas) that filter would otherwise trigger — it is the sanctioned way ' +
+                    'to make a masked adjustment safe to move, resize, rotate, or flip around. all: true ' +
+                    'bakes every ordinary layer with a live filter at once; a group layer is always skipped, ' +
+                    'even one that carries its own filter (GIMP cannot merge filters on a group item) — ' +
+                    'reported under skipped_groups_with_filters rather than silently ignored. Targeting a ' +
+                    'group directly (layer/layer_id) is refused outright. IRREVERSIBLE in this session: ' +
+                    'there is no undo, so gimp_checkpoint or gimp_save_xcf first when in doubt.',
+                inputSchema: bakeSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        layer_id: { type: 'number' },
+                        name: { type: 'string' },
+                        baked: { type: 'boolean' },
+                        baked_layers: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: { layer_id: { type: 'number' }, name: { type: 'string' } },
+                            },
+                        },
+                        skipped_groups_with_filters: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: { layer_id: { type: 'number' }, name: { type: 'string' } },
+                            },
+                        },
+                    },
+                },
+                annotations: {
+                    title: 'Bake GIMP Layer Filters',
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    idempotentHint: true,
+                    openWorldHint: true,
+                },
+            },
+            handler: async (args) => gimpBake(gimp, args),
+        },
+    ];
+}

package/dist/tools/gimp-shared.js

@@ -8,6 +8,13 @@ export const GIMP_LAYER_PROP = {
     type: 'string',
     description: 'Layer name. Defaults to the selected layer, or the topmost layer if none is selected.',
 };
+export const GIMP_LAYER_ID_PROP = {
+    type: 'integer',
+    minimum: 1,
+    maximum: 2_147_483_647,
+    description: 'Layer id, as gimp_inspect (and any tool that creates a layer) reports it. Takes priority ' +
+        'over `layer`, and is the only way to address one of two layers that share a name.',
+};
 export const GIMP_REGION_PROP = {
     type: 'object',
     description: 'A rectangle in document pixels: {x, y, width, height}. Must lie entirely within the image ' +

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

@@ -62,6 +62,9 @@ async function gimpGetPreview(gimp, rawArgs, previewsAllowedFn) {
             const proxyNote = result.proxy
                 ? ' (downscaled proxy render — per-pixel filters exact, spatial filters approximate)'
                 : ' (full-resolution region render — exact)';
+            const unmirroredNote = result.unmirrored_filters && result.unmirrored_filters.length > 0
+                ? ` WARNING: ${result.unmirrored_filters.join(', ')} could not be rendered on this proxy and ${result.unmirrored_filters.length === 1 ? 'is' : 'are'} missing from it — check with gimp_get_preview at a full-resolution region, or gimp_export, before trusting this render.`
+                : '';
             const content = [];
             if (allowed) {
                 content.push({
@@ -75,7 +78,8 @@ async function gimpGetPreview(gimp, rawArgs, previewsAllowedFn) {
                 text: `Preview ${result.width}x${result.height}${proxyNote}. ` +
                     (allowed
                         ? `Also ${fileNote}.`
-                        : `privacy.send_previews_to_llm is false — image not returned to the model; ${fileNote}.`),
+                        : `privacy.send_previews_to_llm is false — image not returned to the model; ${fileNote}.`) +
+                    unmirroredNote,
             });
             return { content, structuredContent: { ...result, path: published ? latestName : null } };
         }
@@ -121,11 +125,14 @@ async function gimpGetHistogram(gimp, rawArgs) {
         const summary = Object.entries(result.channels)
             .map(([ch, s]) => `${ch}: mean=${s.mean.toFixed(1)} median=${s.median} p1=${s.p1} p5=${s.p5} p95=${s.p95} p99=${s.p99}`)
             .join(', ');
+        const unmirroredNote = result.unmirrored_filters && result.unmirrored_filters.length > 0
+            ? ` WARNING: ${result.unmirrored_filters.join(', ')} could not be rendered on this proxy — these stats are missing that filter's effect entirely. Pass exact: true for a trustworthy reading.`
+            : '';
         return {
             content: [
                 {
                     type: 'text',
-                    text: `Histogram (${result.exact ? 'exact' : 'proxy'}, ${result.pixels.toLocaleString()} px): ${summary}`,
+                    text: `Histogram (${result.exact ? 'exact' : 'proxy'}, ${result.pixels.toLocaleString()} px): ${summary}${unmirroredNote}`,
                 },
             ],
             structuredContent: result,
@@ -217,6 +224,9 @@ async function gimpCompare(gimp, rawArgs, previewsAllowedFn) {
             const deltaSummary = Object.entries(result.delta)
                 .map(([ch, d]) => `${ch} Δmean=${d.mean >= 0 ? '+' : ''}${d.mean}`)
                 .join(', ');
+            const unmirroredNote = result.unmirrored_filters && result.unmirrored_filters.length > 0
+                ? ` WARNING: ${result.unmirrored_filters.join(', ')} could not be rendered on the "after" proxy — this delta is missing that filter's effect entirely.`
+                : '';
             const { before_path: _beforePath, after_path: _afterPath, ...reported } = result;
             const content = [];
             const previewsWithheld = Boolean(args.include_previews) && !wantsPreviews;
@@ -241,7 +251,8 @@ async function gimpCompare(gimp, rawArgs, previewsAllowedFn) {
                 text: `Before/after deltas: ${deltaSummary}` +
                     (previewsWithheld
                         ? ' (include_previews was requested but privacy.send_previews_to_llm is false — no image returned.)'
-                        : ''),
+                        : '') +
+                    unmirroredNote,
             });
             return { content, structuredContent: reported };
         }
@@ -279,6 +290,14 @@ export function createGimpVerifyTools(gimp, deps = {}) {
                         height: { type: 'number' },
                         proxy: { type: 'boolean' },
                         path: { type: ['string', 'null'] },
+                        unmirrored_filters: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Names of live filters GIMP refused to re-attach non-destructively on this proxy ' +
+                                'render — missing from this render entirely, not just approximated. Empty on a ' +
+                                'normal render, and always absent on a full-resolution region render ' +
+                                '(proxy: false), which never mirrors filters at all.',
+                        },
                     },
                 },
                 annotations: {
@@ -329,6 +348,16 @@ export function createGimpVerifyTools(gimp, deps = {}) {
                                 },
                             },
                         },
+                        unmirrored_filters: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Names of live filters GIMP refused to re-attach on this proxy render — absent ' +
+                                'from these stats entirely. Present whenever histogram actually used the ' +
+                                '(mirrored) preview proxy: the default whole-image path, OR a `region` large ' +
+                                'enough to be sampled from the proxy rather than falling back to a full-' +
+                                'resolution crop. Absent when exact: true, or when a region is too small and ' +
+                                'falls back to that full-resolution crop — neither path mirrors filters at all.',
+                        },
                     },
                 },
                 annotations: {
@@ -359,6 +388,12 @@ export function createGimpVerifyTools(gimp, deps = {}) {
                         region_a: { type: 'object' },
                         region_b: { type: 'object' },
                         proxy: { type: 'boolean' },
+                        unmirrored_filters: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'before_after only. Names of live filters GIMP refused to re-attach on the ' +
+                                '"after" proxy render — the delta above is missing that filter\'s effect entirely.',
+                        },
                     },
                 },
                 annotations: {

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/operation-timeouts.js

@@ -79,9 +79,10 @@ export const TOOL_TIMEOUT_BUDGETS_MS = {
     gimp_close_document: 15_000,
     gimp_save_xcf: 90_000,
     gimp_export: 90_000,
-    gimp_inspect: 15_000,
+    gimp_inspect: 30_000,
     gimp_add_adjustment: 20_000,
     gimp_filter: 15_000,
+    gimp_add_effect: 20_000,
     gimp_crop_document: 20_000,
     gimp_resize_image: 45_000,
     gimp_transform_canvas: 60_000,
@@ -89,6 +90,13 @@ export const TOOL_TIMEOUT_BUDGETS_MS = {
     gimp_get_preview: 30_000,
     gimp_get_histogram: 90_000,
     gimp_compare: 45_000,
+    gimp_checkpoint: 90_000,
+    gimp_layer: 90_000,
+    gimp_bake: 90_000,
+    gimp_create_document: 15_000,
+    gimp_place_image: 30_000,
+    gimp_canvas: 30_000,
+    gimp_convert_image_mode: 30_000,
 };
 export const TOOLS_WITHOUT_A_BUDGET = {
     ps_report_problem: 'n=3 measured calls',

package/dist/utils/validate.js

@@ -33,6 +33,14 @@ export function validateArgs(schema, args) {
     return out;
 }
 const POLLUTION_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function compilePattern(key, pattern) {
+    try {
+        return new RegExp(pattern);
+    }
+    catch (err) {
+        throw new Error(`Tool schema bug: "${key}" declares an invalid pattern ${JSON.stringify(pattern)} (${err instanceof Error ? err.message : String(err)})`, { cause: err });
+    }
+}
 function coerceAndCheck(key, value, schema) {
     switch (schema.type) {
         case 'string': {
@@ -42,6 +50,9 @@ function coerceAndCheck(key, value, schema) {
             if (schema.enum && !schema.enum.includes(value)) {
                 throw new ValidationError(`Invalid value for "${key}": ${JSON.stringify(value)}. Allowed: ${schema.enum.join(', ')}`);
             }
+            if (schema.pattern !== undefined && !compilePattern(key, schema.pattern).test(value)) {
+                throw new ValidationError(`Invalid value for "${key}": ${JSON.stringify(value)} does not match the required pattern`);
+            }
             return value;
         }
         case 'integer':

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.6.0';
+export const VERSION = '1.7.1';

package/package.json

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