editmamei 1.0.2 → 1.1.0

package/dist/tools/selection-tools.js

@@ -2,7 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { runScript } from '../utils/run-script.js';
 import { TempDir } from '../utils/temp.js';
 import { validateArgs } from '../utils/validate.js';
-import { toolErrorResult, runSnippetTool } from '../utils/tool-helpers.js';
+import { toolErrorResult, runSnippetTool, unknownDiscriminator } from '../utils/tool-helpers.js';
 import { OnnxLandmarkDetectionClient } from '../detection/landmark-detection-client.js';
 import { resolveExpectedPlacement, PLACEMENT_SCHEMA } from '../perception/grounding-locate.js';
 import { SELECT_SUBJECT_TIMEOUT_MS, SELECT_SKY_TIMEOUT_MS } from '../utils/operation-timeouts.js';
@@ -450,8 +450,8 @@ const SELECT_INPUT_SCHEMA = {
                 'color_range: target red/green/blue (+fuzziness) — "select all the red / skin". ' +
                 'luminance_range: luminance highlights|shadows|midtones (+fuzziness, lower_limit, upper_limit) — glow/dodge-burn foundation. ' +
                 'magic_wand: click x/y (+tolerance, contiguous, anti_alias, sample_all_layers). ' +
-                'grow: expand the CURRENT selection to adjacent similar-colour pixels (+tolerance, anti_alias). ' +
-                'similar: expand the CURRENT selection to ALL similar-colour pixels document-wide (+tolerance, anti_alias). ' +
+                'grow: DEPRECATED here — use ps_modify_selection(op=grow) instead (kept for one release for backward compatibility, identical behaviour). Expands the CURRENT selection to adjacent similar-colour pixels (+tolerance, anti_alias). ' +
+                'similar: DEPRECATED here — use ps_modify_selection(op=similar) instead (kept for one release for backward compatibility, identical behaviour). Expands the CURRENT selection to ALL similar-colour pixels document-wide (+tolerance, anti_alias). ' +
                 'skin_tones: select skin-coloured pixels (+fuzziness; use_faces=true adds face-aware refinement). ' +
                 'out_of_gamut: select colours outside the printable CMYK gamut (no params). ' +
                 'polygon: points [{x,y},...] in ABSOLUTE document pixels (min 3, auto-closes) — covers polygonal/freehand lasso. Coordinate-driven: you must know the pixel positions (use ps_inspect / ps_get_preview to aim, or ps_path create_from_placement → load_as_selection for a grounded outline). ' +
@@ -479,6 +479,8 @@ const MODIFY_SELECTION_OPS = [
     'border',
     'smooth',
     'transform',
+    'grow',
+    'similar',
 ];
 const MODIFY_SELECTION_INPUT_SCHEMA = {
     type: 'object',
@@ -491,13 +493,16 @@ const MODIFY_SELECTION_INPUT_SCHEMA = {
                 'expand: grow the selection outward by `amount` px. contract: shrink it inward by `amount` px. ' +
                 'border: replace the selection with a `amount`-px-wide band straddling its edge. ' +
                 'smooth: round off the selection corners with a `amount`-px radius. ' +
+                'grow: expand the selection to adjacent similar-colour pixels (+tolerance, anti_alias). ' +
+                'similar: expand the selection to ALL similar-colour pixels document-wide (+tolerance, anti_alias). ' +
                 'transform: relatively scale (scale_x_percent / scale_y_percent), rotate (rotate_degrees) and/or translate (offset_x / offset_y) the marching ants — not pixels. ' +
-                'expand/contract/border/smooth all require an active selection and take `amount`; expand/contract/smooth also take at_canvas_bounds.',
+                'expand/contract/border/smooth all require an active selection and take `amount`; expand/contract/smooth also take at_canvas_bounds. grow/similar also require an active selection.',
         },
         ...featherSelectionSchema.properties,
         ...refineEdgeSchema.properties,
         ...modifyEdgeSchema.properties,
         ...transformSelectionSchema.properties,
+        ...growSelectionSchema.properties,
     },
     required: ['op'],
 };
@@ -575,7 +580,7 @@ export function createSelectionTools(connection, snippetClient, client = new Onn
         {
             tool: {
                 name: 'ps_select',
-                description: 'Create or modify a selection — choose with `mode`. `all` selects the canvas; `none` deselects; `inverse` inverts the current selection (e.g. select the subject, then inverse to act on the background). `rectangle` (left/top/right/bottom, optional feather_px to avoid hard block-edges in smooth sky). `ellipse` (left/top/right/bottom bounding box + anti_alias — circles/ovals). `color_range` (target red/green/blue + fuzziness — "select all the red / skin tones"). `luminance_range` (highlights/shadows/midtones — foundation for glow / dodge-burn). `magic_wand` (click x/y + tolerance, contiguous). `grow` / `similar` expand the CURRENT selection to similar-colour pixels (adjacent vs document-wide; both honour `tolerance`). rectangle/ellipse/magic_wand also accept a grounded `placement` (NAME a region/point instead of guessing pixels — resolved + gate-verified). The geometric/color/wand modes take selection_type (replace|add|subtract|intersect) to combine with an existing selection and return a rich selection_info bundle — verify it (or ps_get_selection_preview) before committing to a mask.',
+                description: 'Create a NEW selection — choose with `mode`. (To edit the CURRENT selection instead — including growing it by colour similarity — use ps_modify_selection.) `all` selects the canvas; `none` deselects; `inverse` inverts the current selection (e.g. select the subject, then inverse to act on the background). `rectangle` (left/top/right/bottom, optional feather_px to avoid hard block-edges in smooth sky). `ellipse` (left/top/right/bottom bounding box + anti_alias — circles/ovals). `color_range` (target red/green/blue + fuzziness — "select all the red / skin tones"). `luminance_range` (highlights/shadows/midtones — foundation for glow / dodge-burn). `magic_wand` (click x/y + tolerance, contiguous). `grow` / `similar` are DEPRECATED here (they act on the CURRENT selection, not a new one) — use ps_modify_selection(op=grow|similar) instead; kept for one release for backward compatibility, identical behaviour. rectangle/ellipse/magic_wand also accept a grounded `placement` (NAME a region/point instead of guessing pixels — resolved + gate-verified). The geometric/color/wand modes take selection_type (replace|add|subtract|intersect) to combine with an existing selection and return a rich selection_info bundle — verify it (or ps_get_selection_preview) before committing to a mask.',
                 inputSchema: SELECT_INPUT_SCHEMA,
                 outputSchema: {
                     type: 'object',
@@ -614,7 +619,7 @@ export function createSelectionTools(connection, snippetClient, client = new Onn
         {
             tool: {
                 name: 'ps_modify_selection',
-                description: "Modify the CURRENT selection — choose with `op`. `feather` softens by radius_px (use when a selection was made hard, e.g. after select all/inverse, before applying an adjustment). `refine_edge` runs Select-and-Mask's global sliders headlessly (smooth, feather, contrast, shift_edge, edge-detection radius, decontaminate) to clean halos and soft/fuzzy edges (hair) after a rough color-range / magic-wand / subject selection. `expand` / `contract` grow / shrink the selection by `amount` px. `border` replaces the selection with an `amount`-px band around its edge. `smooth` rounds the corners with an `amount`-px radius. `transform` relatively scales (scale_x_percent / scale_y_percent), rotates (rotate_degrees) and/or translates (offset_x / offset_y) the marching ants — pixels are untouched. All require an active selection and return selection_info.",
+                description: "Modify the CURRENT selection — choose with `op`. (To create a NEW selection instead, use ps_select.) `feather` softens by radius_px (use when a selection was made hard, e.g. after select all/inverse, before applying an adjustment). `refine_edge` runs Select-and-Mask's global sliders headlessly (smooth, feather, contrast, shift_edge, edge-detection radius, decontaminate) to clean halos and soft/fuzzy edges (hair) after a rough color-range / magic-wand / subject selection. `expand` / `contract` grow / shrink the selection by `amount` px. `border` replaces the selection with an `amount`-px band around its edge. `smooth` rounds the corners with an `amount`-px radius. `grow` / `similar` expand the selection to similar-colour pixels by `tolerance` (+anti_alias) — `grow` to adjacent pixels only, `similar` document-wide. `transform` relatively scales (scale_x_percent / scale_y_percent), rotates (rotate_degrees) and/or translates (offset_x / offset_y) the marching ants — pixels are untouched. All require an active selection and return selection_info.",
                 inputSchema: MODIFY_SELECTION_INPUT_SCHEMA,
                 outputSchema: {
                     type: 'object',
@@ -623,6 +628,8 @@ export function createSelectionTools(connection, snippetClient, client = new Onn
                         refined: { type: 'boolean' },
                         modified: { type: 'boolean' },
                         transformed: { type: 'boolean' },
+                        selected: { type: 'boolean', description: 'op=grow/similar: true on success.' },
+                        method: { type: 'string', description: 'op=grow/similar: "grow" or "similar".' },
                         mode: { type: 'string' },
                         amount_px: { type: 'number' },
                         scale_x_percent: { type: 'number' },
@@ -637,6 +644,8 @@ export function createSelectionTools(connection, snippetClient, client = new Onn
                         contrast: { type: 'number' },
                         shift_edge: { type: 'number' },
                         decontaminate: { type: 'boolean' },
+                        tolerance: { type: 'number', description: 'op=grow/similar: tolerance used.' },
+                        anti_alias: { type: 'boolean', description: 'op=grow/similar: anti_alias used.' },
                         output: { type: 'string' },
                         selection_info: selectionInfoFragment,
                     },
@@ -864,17 +873,6 @@ async function selectSky(connection, snippetClient, rawArgs) {
         successText: (_result, args) => `Select Sky (${normalizeSelectionType(args.selection_type)}) complete`,
     });
 }
-function unknownDiscriminator(kind, value, allowed) {
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `Error: unknown ${kind} "${String(value)}". Allowed: ${allowed.join(', ')}.`,
-            },
-        ],
-        isError: true,
-    };
-}
 async function select(connection, snippetClient, detClient, rawArgs) {
     const mode = rawArgs.mode;
     const { mode: _omit, ...rest } = rawArgs;
@@ -924,6 +922,10 @@ async function modifySelection(connection, snippetClient, rawArgs) {
             return modifySelectionEdge(connection, snippetClient, op, rest);
         case 'transform':
             return transformSelection(connection, snippetClient, rest);
+        case 'grow':
+            return growSelection(connection, snippetClient, 'grow', rest);
+        case 'similar':
+            return growSelection(connection, snippetClient, 'similar', rest);
         default:
             return unknownDiscriminator('modify_selection op', op, MODIFY_SELECTION_OPS);
     }

package/dist/tools/smart-object-tools.js

@@ -0,0 +1,163 @@
+import { validateArgs } from '../utils/validate.js';
+import { runSnippetTool, toolErrorResult } from '../utils/tool-helpers.js';
+import { LAYER_BLEND_MODES } from '../utils/blend-modes.js';
+const SMART_FILTER_OPS = ['list', 'set_visibility', 'set_blend', 'remove'];
+const smartFilterInputSchema = {
+    type: 'object',
+    properties: {
+        op: {
+            type: 'string',
+            enum: [...SMART_FILTER_OPS],
+            description: 'list: read every Smart Filter on the active layer (index, name, type, enabled, opacity, blend mode). Read-only — call it first to get the indices the other ops take. ' +
+                'set_visibility: turn one filter on or off without removing it (needs `index` + `enabled`). ' +
+                "set_blend: change one filter's `opacity` and/or `blend_mode` (needs `index` + at least one of them). " +
+                'remove: delete one filter from the stack (needs `index`). Removing a filter renumbers every index above it — re-run op=list before the next index-taking call.',
+        },
+        index: {
+            type: 'integer',
+            description: "1-based index of the filter to act on, as reported by op=list. 1 is the FIRST-APPLIED filter (bottom of the Smart Filters stack in the Layers panel). Required for every op except 'list'.",
+            minimum: 1,
+            maximum: 1000,
+        },
+        enabled: {
+            type: 'boolean',
+            description: 'set_visibility only: true shows the filter, false hides it. The filter stays in the stack either way and keeps all its settings.',
+        },
+        opacity: {
+            type: 'number',
+            description: 'set_blend only: filter opacity 0-100. Omit to leave the current opacity untouched.',
+            minimum: 0,
+            maximum: 100,
+        },
+        blend_mode: {
+            type: 'string',
+            enum: [...LAYER_BLEND_MODES],
+            description: 'set_blend only: how the filter result composites against the unfiltered layer. Same names as ps_set_layer. Omit to leave the current mode untouched.',
+        },
+    },
+    required: ['op'],
+};
+export async function runSmartFilterOp(connection, snippetClient, rawArgs) {
+    let args;
+    try {
+        args = validateArgs(smartFilterInputSchema, rawArgs);
+    }
+    catch (error) {
+        return toolErrorResult('Error in ps_filter', error);
+    }
+    const op = args.op;
+    if (op !== 'list' && args.index === undefined) {
+        return toolErrorResult('Error in ps_filter', new Error(`op=${op} needs an \`index\`. Call op=list first to see the filters and their indices.`));
+    }
+    switch (op) {
+        case 'list':
+            return runSnippetTool({
+                connection,
+                snippetClient,
+                rawArgs: args,
+                schema: smartFilterInputSchema,
+                snippet: 'listSmartFilters',
+                errorPrefix: 'Error listing Smart Filters',
+                successText: (result) => summarizeList(result),
+            });
+        case 'set_visibility': {
+            if (args.enabled === undefined) {
+                return toolErrorResult('Error in ps_filter', new Error('op=set_visibility needs `enabled` (true to show the filter, false to hide it).'));
+            }
+            return runSnippetTool({
+                connection,
+                snippetClient,
+                rawArgs: args,
+                schema: smartFilterInputSchema,
+                snippet: 'setSmartFilterVisibility',
+                errorPrefix: 'Error setting Smart Filter visibility',
+                params: (a) => ({ index: a.index, enabled: a.enabled }),
+                successText: (result) => {
+                    const r = result;
+                    return `${r.enabled ? 'Showed' : 'Hid'} Smart Filter ${String(r.index)} (${String(r.filter_name)}) on "${String(r.layer_name)}".`;
+                },
+            });
+        }
+        case 'set_blend': {
+            if (args.opacity === undefined && args.blend_mode === undefined) {
+                return toolErrorResult('Error in ps_filter', new Error('op=set_blend needs at least one of `opacity` or `blend_mode`.'));
+            }
+            return runSnippetTool({
+                connection,
+                snippetClient,
+                rawArgs: args,
+                schema: smartFilterInputSchema,
+                snippet: 'setSmartFilterBlend',
+                errorPrefix: 'Error setting Smart Filter blend',
+                params: (a) => {
+                    const p = { index: a.index };
+                    if (a.opacity !== undefined)
+                        p.opacity = a.opacity;
+                    if (a.blend_mode !== undefined)
+                        p.blendMode = a.blend_mode;
+                    return p;
+                },
+                successText: (result) => {
+                    const r = result;
+                    const opacity = Number(r.opacity);
+                    const opacityText = Number.isFinite(opacity) ? opacity.toFixed(1) : String(r.opacity);
+                    return `Smart Filter ${String(r.index)} (${String(r.filter_name)}) is now ${String(r.blend_mode)} at ${opacityText}% opacity on "${String(r.layer_name)}".`;
+                },
+            });
+        }
+        case 'remove':
+            return runSnippetTool({
+                connection,
+                snippetClient,
+                rawArgs: args,
+                schema: smartFilterInputSchema,
+                snippet: 'removeSmartFilter',
+                errorPrefix: 'Error removing Smart Filter',
+                params: (a) => ({ index: a.index }),
+                successText: (result) => {
+                    const r = result;
+                    return `Removed Smart Filter ${String(r.index)} (${String(r.removed_filter_name)}) from "${String(r.layer_name)}". ${String(r.remaining_count)} remaining. Indices renumbered — re-run op=list before the next index-taking call.`;
+                },
+            });
+        default:
+            return toolErrorResult('Error in ps_filter', new Error(`Unknown smart-filter op: ${String(op)}. Allowed: ${SMART_FILTER_OPS.join(', ')}.`));
+    }
+}
+function summarizeList(r) {
+    const layer = String(r.layer_name ?? '');
+    if (r.is_smart_object !== true) {
+        return `"${layer}" is not a Smart Object, so it has no Smart Filters. Convert it with ps_convert_to_smart_object to make filters re-editable.`;
+    }
+    const filters = Array.isArray(r.filters) ? r.filters : [];
+    if (filters.length === 0) {
+        return `"${layer}" is a Smart Object with no Smart Filters yet. Add one with ps_filter as_smart_filter=true.`;
+    }
+    const lines = filters.map((f) => {
+        const state = f.enabled === false ? ' [hidden]' : '';
+        const blend = f.blend_mode === 'NORMAL' && f.opacity === 100
+            ? ''
+            : ` — ${String(f.blend_mode)} @ ${String(f.opacity)}%`;
+        return `  ${String(f.index)}. ${String(f.name)} (${String(f.type)})${blend}${state}`;
+    });
+    return `"${layer}" has ${filters.length} Smart Filter${filters.length === 1 ? '' : 's'} (1 = first applied, bottom of the stack):\n${lines.join('\n')}`;
+}
+export async function getSmartObjectInfoHandler(connection, snippetClient) {
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs: {},
+        schema: { type: 'object', properties: {} },
+        snippet: 'getSmartObjectInfo',
+        errorPrefix: 'Error reading Smart Object info',
+        successText: (result) => {
+            const r = result;
+            const layer = String(r.layer_name ?? '');
+            if (r.is_smart_object !== true) {
+                return `"${layer}" is not a Smart Object (kind: ${String(r.layer_kind)}).`;
+            }
+            const storage = r.linked === true ? `linked to ${String(r.file_reference)}` : 'embedded';
+            const n = Number(r.smart_filter_count ?? 0);
+            return `"${layer}" is a ${storage} Smart Object with ${n} Smart Filter${n === 1 ? '' : 's'}.`;
+        },
+    });
+}

package/dist/tools/text-tools.js

@@ -1,6 +1,7 @@
 import { runScript } from '../utils/run-script.js';
 import { validateArgs } from '../utils/validate.js';
-import { toolErrorResult, runSnippetTool } from '../utils/tool-helpers.js';
+import { toolErrorResult, runSnippetTool, unknownDiscriminator } from '../utils/tool-helpers.js';
+import { createTextLayer, createTextLayerSchema } from './layer-tools.js';
 const setTextFontSchema = {
     type: 'object',
     properties: {
@@ -87,12 +88,83 @@ const SET_TEXT_INPUT_SCHEMA = {
     },
     required: ['property'],
 };
+const TEXT_OPS = ['create', 'set_content', 'set_font', 'set_color', 'set_alignment'];
+export const TEXT_OP_SCHEMAS = {
+    create: createTextLayerSchema,
+    set_content: updateTextContentSchema,
+    set_font: setTextFontSchema,
+    set_color: setTextColorSchema,
+    set_alignment: setTextAlignmentSchema,
+};
+const TEXT_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        op: {
+            type: 'string',
+            enum: [...TEXT_OPS],
+            description: 'create: new text layer with `text` at `x`/`y` (default 100,100) and `font_size` (default 24). ' +
+                "set_content: replace the active text layer's content with `text`. " +
+                "set_font: set the active text layer's font to `font_name` (optionally `font_size`). " +
+                "set_color: set the active text layer's color to `red`/`green`/`blue`. " +
+                "set_alignment: set the active text layer's `alignment`.",
+        },
+        ...createTextLayerSchema.properties,
+        ...setTextColorSchema.properties,
+        ...setTextAlignmentSchema.properties,
+        font_name: setTextFontSchema.properties.font_name,
+        text: {
+            type: 'string',
+            description: 'create: initial text content. set_content: new text content, replacing the existing text.',
+        },
+        font_size: {
+            type: 'number',
+            description: "Font size in points, up to 1296 — Photoshop's own ceiling for the Character panel. create: initial size (default 24). set_font: new size (optional — omit to leave the current size unchanged).",
+            default: 24,
+            minimum: 1,
+            maximum: 1296,
+        },
+    },
+    required: ['op'],
+};
 export function createTextTools(connection, snippetClient) {
     return [
+        {
+            tool: {
+                name: 'ps_text',
+                description: 'Text layer — create it or style it, chosen with `op`. create: a new text layer with `text` at `x`/`y` and `font_size`. set_content/set_font/set_color/set_alignment act on the currently active text layer (throws if it isn\'t one). Font names accept either the PostScript name ("ArialMT") or family name ("Arial", resolved to its Regular/first variant); throws clearly if no installed font matches. The set_* ops are idempotent.',
+                inputSchema: TEXT_INPUT_SCHEMA,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        created: { type: 'boolean', description: 'op=create: true on success.' },
+                        layerName: { type: 'string', description: 'op=create: the new layer name.' },
+                        position: { type: 'object', description: 'op=create: {x, y}.' },
+                        fontSize: { type: 'number', description: 'op=create: the size applied.' },
+                        requested: { type: 'string', description: 'op=set_font: the font requested.' },
+                        font: { type: 'string', description: 'op=set_font: the font actually matched.' },
+                        size: { type: 'number', description: 'op=set_font: the size applied, if given.' },
+                        matched_by: {
+                            type: 'string',
+                            enum: ['postScriptName', 'family+regular', 'family', 'name'],
+                            description: 'op=set_font: how `font_name` was resolved.',
+                        },
+                        color: { type: 'string', description: 'op=set_color: the RGB() string applied.' },
+                        alignment: { type: 'string', description: 'op=set_alignment: the alignment applied.' },
+                        text: { type: 'string', description: 'op=create/set_content: the text content.' },
+                        context: { type: 'object' },
+                    },
+                },
+                annotations: {
+                    title: 'Text',
+                    idempotentHint: false,
+                },
+            },
+            handler: async (args) => textDispatch(connection, snippetClient, args),
+        },
         {
             tool: {
                 name: 'ps_set_text',
-                description: 'Set an attribute of the currently active text layer — font (family or PostScript name, optionally size), color (RGB), alignment, or text content — selected via `property`. Idempotent. Throws if the active layer is not a text layer. Font names accept either the PostScript name ("ArialMT") or family name ("Arial", resolved to its Regular/first variant); throws clearly if no installed font matches.',
+                description: 'DEPRECATED — use ps_text(op=set_font / set_color / set_alignment / set_content) instead (kept for one release for backward compatibility, identical behaviour). Set an attribute of the currently active text layer — font (family or PostScript name, optionally size), color (RGB), alignment, or text content — selected via `property`. Idempotent. Throws if the active layer is not a text layer. Font names accept either the PostScript name ("ArialMT") or family name ("Arial", resolved to its Regular/first variant); throws clearly if no installed font matches.',
                 inputSchema: SET_TEXT_INPUT_SCHEMA,
                 outputSchema: {
                     type: 'object',
@@ -118,6 +190,24 @@ export function createTextTools(connection, snippetClient) {
         },
     ];
 }
+async function textDispatch(connection, snippetClient, rawArgs) {
+    const op = rawArgs.op;
+    const { op: _omit, ...rest } = rawArgs;
+    switch (op) {
+        case 'create':
+            return createTextLayer(connection, snippetClient, rest);
+        case 'set_content':
+            return updateTextContent(connection, snippetClient, rest);
+        case 'set_font':
+            return setTextFont(connection, snippetClient, rest);
+        case 'set_color':
+            return setTextColor(connection, snippetClient, rest);
+        case 'set_alignment':
+            return setTextAlignment(connection, snippetClient, rest);
+        default:
+            return unknownDiscriminator('text op', op, TEXT_OPS);
+    }
+}
 async function setText(connection, snippetClient, rawArgs) {
     const property = rawArgs.property;
     const { property: _omit, ...rest } = rawArgs;

package/dist/utils/session-log.js

@@ -23,21 +23,57 @@ export function generateSessionId(now = new Date()) {
     return `${iso}-${suffix}`;
 }
 export const ERROR_CLASS_TABLE = [
+    { errorClass: 'ps_empty_error', pattern: /returned an empty error|failed with no message/i },
+    {
+        errorClass: 'layer_not_found',
+        pattern: /\blayer not found|no layer named|(?:layer_to_move|target_layer_name) not found|layer "[^"]*" not found/i,
+    },
+    { errorClass: 'group_not_found', pattern: /group not found/i },
+    { errorClass: 'channel_not_found', pattern: /channel not found|channel named/i },
+    { errorClass: 'path_not_found', pattern: /no path named|no paths to|no work path/i },
+    { errorClass: 'font_not_found', pattern: /font not found/i },
+    {
+        errorClass: 'file_not_found',
+        pattern: /file not found|map not found|lut not found|could not open lut/i,
+    },
+    { errorClass: 'face_not_found', pattern: /no face mesh|no face detected/i },
     {
         errorClass: 'schema_validation',
-        pattern: /\bvalidat|required.*field|must be.*type|invalid (input|argument)/i,
+        pattern: /\bvalidat|required.*field|missing required argument|must be.*type|invalid (input|argument)/i,
     },
-    { errorClass: 'layer_not_found', pattern: /layer .* not found|no layer named/i },
-    { errorClass: 'ps_command_unavailable', pattern: /not currently available/i },
-    { errorClass: 'timeout', pattern: /timed? ?out|Script execution timeout|exceeded.*bytes/i },
     {
-        errorClass: 'ps_modal_blocking',
-        pattern: /modal.*dialog|dialog.*blocking|blocked.*modal|photoshop.*modal/i,
+        errorClass: 'invalid_argument',
+        pattern: /unknown [^:]{1,30}:|invalid |illegal argument|must be |out of bounds|unsupported/i,
     },
+    { errorClass: 'ps_not_detected', pattern: /photoshop info not available/i },
     {
         errorClass: 'ps_not_running',
         pattern: /CreateObject|photoshop.*not.*running|cannot connect.*photoshop|connection.*failed/i,
     },
+    { errorClass: 'no_document', pattern: /no active document|no document is open/i },
+    { errorClass: 'no_active_layer', pattern: /no active layer|document has no layers/i },
+    {
+        errorClass: 'no_selection',
+        pattern: /no active selection|requires an active selection|make a selection/i,
+    },
+    { errorClass: 'background_layer', pattern: /background layer/i },
+    { errorClass: 'layer_locked', pattern: /is locked|fully locked|locked layer/i },
+    {
+        errorClass: 'wrong_layer_kind',
+        pattern: /pixel layer|text layer|smart object layer|layer kind|rasterize it first/i,
+    },
+    { errorClass: 'ps_command_unavailable', pattern: /not currently available/i },
+    { errorClass: 'timeout', pattern: /timed? ?out|Script execution timeout|exceeded.*bytes/i },
+    {
+        errorClass: 'ps_modal_blocking',
+        pattern: /modal.*dialog|dialog.*blocking|blocked.*modal|photoshop.*modal/i,
+    },
+    { errorClass: 'ai_selection_no_result', pattern: /returned no result/i },
+    { errorClass: 'ps_general_error', pattern: /general photoshop error/i },
+    { errorClass: 'ps_no_such_element', pattern: /no such element/i },
+    { errorClass: 'write_not_verified', pattern: /did not verify/i },
+    { errorClass: 'ps_empty_error', pattern: /:\s*$/ },
+    { errorClass: 'ps_op_failed', pattern: /failed[: (]/i },
 ];
 export function classifyError(error) {
     if (error === undefined)

package/dist/utils/temp.js

@@ -53,7 +53,7 @@ export class TempDir {
             const fbMsg = errorString(fbErr);
             throw new Error(`TempDir.create: tmpdir() at ${tmpdir()} was not writable (${primaryMsg}); ` +
                 `user-owned fallback ${fbRoot} also failed (${fbMsg}). ` +
-                `Most common cause: TMPDIR inherited from a sudo session — start a fresh shell.`);
+                `Most common cause: TMPDIR inherited from a sudo session — start a fresh shell.`, { cause: fbErr });
         }
     }
 }

package/dist/utils/tool-helpers.js

@@ -17,6 +17,17 @@ export function toolErrorResult(prefix, error) {
         isError: true,
     };
 }
+export function unknownDiscriminator(kind, value, allowed) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Error: unknown ${kind} "${String(value)}". Allowed: ${allowed.join(', ')}.`,
+            },
+        ],
+        isError: true,
+    };
+}
 export async function runSnippetTool(spec) {
     try {
         const args = validateArgs(spec.schema, spec.rawArgs);
@@ -41,3 +52,15 @@ export function applyToActiveLayerProp(op) {
         default: false,
     };
 }
+export function asSmartFilterProp() {
+    return {
+        type: 'boolean',
+        description: 'If true, apply the filter as a re-editable SMART FILTER riding the Smart Object ' +
+            'instead of baking it into pixels — nothing is rasterized, and the filter can later be ' +
+            'toggled, re-blended or removed instead of being permanent. Requires the target to be a ' +
+            'Smart Object (convert first with ps_convert_to_smart_object); errors rather than ' +
+            'converting silently. If false (default), the filter is baked and a smart-object layer ' +
+            'is rasterized first.',
+        default: false,
+    };
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.0.2';
+export const VERSION = '1.1.0';

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "editmamei",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Photoshop MCP server: natural-language AI photo editing with your own Photoshop (Community Edition)",
+  "mcpName": "io.github.editmamei/editmamei",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
@@ -44,7 +45,7 @@
     "url": "https://github.com/editmamei/editmamei/issues"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",