editmamei 1.7.1 → 1.9.0

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

@@ -55,7 +55,7 @@ const adjustSchema = {
         },
         mask: {
             type: 'string',
-            description: 'Name of a mask channel from gimp_create_mask, confining a NEW filter to it. Only valid ' +
+            description: 'Name of a saved selection channel, confining a NEW filter to it. Only valid ' +
                 "when creating (no filter_id) — a filter's mask is fixed at creation. ORDER MATTERS: " +
                 'straighten / flip / resize the canvas first (gimp_transform_canvas, gimp_resize_image), ' +
                 'then crop, THEN add masked adjustments — rotate, flip, and resize all refuse outright ' +
@@ -278,9 +278,10 @@ const adjustSchema = {
             maximum: 100,
             description: 'vibrance only. THE vibrance control — a vibrance adjustment must set this field, not ' +
                 '`saturation` (a separate, plain multiplier for this type that normally stays at its ' +
-                'default). Positive values boost muted/less-saturated colours more than already-saturated ' +
-                'ones (skin tones move less than a bright sky); negative desaturates the same way in ' +
-                'reverse. Default (when creating): 0.',
+                "default). The scale follows Photoshop's Vibrance: +10 to +30 is a natural boost, +50 a " +
+                "strong one; negative values desaturate. Unlike Photoshop's, it lifts already-saturated " +
+                'colors (a blue sky, a bright shirt) about as much as muted ones, so check those areas ' +
+                'with a histogram above about +50. Default (when creating): 0.',
         },
         amount: {
             type: 'number',
@@ -348,11 +349,11 @@ export function createGimpAdjustmentTools(gimp) {
                     'separate filters for red and blue rather than one filter for both; points are [input, ' +
                     'output] 0-255 pairs including the endpoints. hue_saturation and color_balance likewise ' +
                     'carry ONE `range` per filter. gaussian_blur: radius in pixels at full resolution; ' +
-                    'combine with a mask from gimp_create_mask for soft-focus or background-blur effects. A ' +
+                    'combine with a saved-selection mask for soft-focus or background-blur effects. A ' +
                     "re-edit (filter_id) MERGES: any field you omit keeps the filter's existing value, so " +
                     "re-editing {contrast: 50} on a brightness_contrast filter doesn't reset brightness. Only " +
                     'filters Editmamei created can be re-edited; one added in the GIMP GUI is refused (delete ' +
-                    'and re-create it). `mask` (a channel name from gimp_create_mask) confines a NEW filter ' +
+                    'and re-create it). `mask` (a saved selection channel name) confines a NEW filter ' +
                     '— fixed at creation, cannot change on a re-edit. ORDER MATTERS: straighten / flip / ' +
                     'resize the canvas first, then crop, THEN add any masked adjustment — rotate, flip, and ' +
                     'resize all refuse outright once a masked adjustment filter exists, or any filter not ' +

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

@@ -6,6 +6,7 @@ import { validateArgs } from '../utils/validate.js';
 import { toolGimpErrorResult, unknownDiscriminator } from '../utils/tool-helpers.js';
 import { GimpError } from '../backends/gimp/errors.js';
 import { GIMP_IMAGE_PROP } from './gimp-shared.js';
+import { capLines, quoted } from './gimp-result-text.js';
 export const MAX_CHECKPOINTS_PER_IMAGE = 5;
 export const MAX_CHECKPOINTS_TOTAL = 20;
 const checkpointSchema = {
@@ -303,7 +304,12 @@ async function checkpointList(gimp, args, store) {
         content: [
             {
                 type: 'text',
-                text: `${checkpoints.length} checkpoint(s)${scopedNote}.${goneNote}`,
+                text: `${checkpoints.length} checkpoint(s)${scopedNote}.${goneNote}` +
+                    capLines(checkpoints.map((c) => `- ${quoted(c.checkpoint_id)}: image ${c.image}` +
+                        `${c.open ? '' : ' (gone)'}${c.pending ? ', still being created' : ''}, ` +
+                        `${c.created_at}, ${c.bytes.toLocaleString('en-US')} bytes`))
+                        .map((line) => `\n${line}`)
+                        .join(''),
             },
         ],
         structuredContent: { checkpoints },

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

@@ -90,9 +90,9 @@ in the real GIMP GUI afterward to see it directly.
    stacking a second one for the same correction (see "Curve laws"
    below).
 6. **Finish** — \`gimp_save_xcf\` keeps every filter live and
-   re-editable; \`gimp_export\` writes a flattened deliverable. Do both
-   when the user wants to keep working on it later AND ship a JPEG/PNG
-   now.
+   re-editable; \`gimp_export\` writes a flattened deliverable, or a
+   layered .psd for finishing in Photoshop. Do both when the user wants
+   to keep working on it later AND ship a JPEG/PNG now.
 
 ## Curve laws (gimp_add_adjustment type=curves)
 
@@ -145,13 +145,12 @@ workflow avoids.
 
 ## Masks
 
-\`gimp_create_mask\` builds a geometric mask (rectangle / ellipse /
-gradient) into a NAMED channel. Pass that name as \`mask\` when you
-CREATE a filter with \`gimp_add_adjustment\` or \`gimp_add_effect\` to
-confine it. A filter's
-mask is fixed at creation — re-editing it by \`filter_id\` cannot
-change which mask it uses; delete and re-create it with a new mask
-instead.
+A selection can be saved into a NAMED channel. Pass the name of a
+channel saved in the image as \`mask\` when you CREATE a filter
+with \`gimp_add_adjustment\` or \`gimp_add_effect\` to confine it.
+A filter's mask is fixed at creation — re-editing it by
+\`filter_id\` cannot change which mask it uses; delete and
+re-create it with a new mask instead.
 
 ## Order matters: geometry before masked adjustments
 
@@ -169,7 +168,7 @@ every geometry op.
 ## Layers and composites
 
 A filter applies to ONE layer. \`gimp_layer\` creates, groups, reorders,
-moves and restyles layers and merges or flattens them;
+and restyles layers and merges or flattens them;
 \`gimp_place_image\` adds another file as a new layer;
 \`gimp_create_document\` starts a blank canvas. Address layers by the
 \`layer_id\` these tools and \`gimp_inspect\` report — names can repeat.

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

@@ -40,7 +40,10 @@ async function gimpOpenDocument(gimp, rawArgs) {
                     type: 'text',
                     text: `Opened ${basename(filePath)} as image ${result.image} ` +
                         `(${result.width}x${result.height}, ${result.base_type}, ${result.precision}). ` +
-                        `${result.layers.length} layer(s): ${result.layers.join(', ') || '(none)'}.`,
+                        `${result.layers.length} layer(s): ${result.layers.join(', ') || '(none)'}.` +
+                        (result.orientation_applied !== undefined
+                            ? ` Rotated upright for EXIF orientation ${result.orientation_applied}.`
+                            : ''),
                 },
             ],
             structuredContent: result,
@@ -63,7 +66,7 @@ const saveXcfSchema = {
             type: 'string',
             description: 'Absolute path ending in .xcf. Saves the LIVE GIMP document — every filter stays in ' +
                 "place and re-editable afterward (matches ps_save_psd's framing for .psd). For a " +
-                'flattened deliverable, use gimp_export instead.',
+                'deliverable (flattened, or a layered .psd), use gimp_export instead.',
         },
         overwrite: {
             type: 'boolean',
@@ -78,7 +81,7 @@ async function gimpSaveXcf(gimp, rawArgs) {
         const args = validateArgs(saveXcfSchema, rawArgs);
         const filePath = requireAbsoluteGimpPath('file_path', args.file_path);
         if (extname(filePath).toLowerCase() !== '.xcf') {
-            throw new GimpError('invalid_argument', `"file_path" must end in .xcf, got "${filePath}" — use gimp_export for a flattened deliverable.`);
+            throw new GimpError('invalid_argument', `"file_path" must end in .xcf, got "${filePath}" — use gimp_export for a deliverable.`);
         }
         refuseExistingGimpFile(filePath, args.overwrite, existsSync);
         const result = await gimp.call('export', {
@@ -99,16 +102,22 @@ async function gimpSaveXcf(gimp, rawArgs) {
         return toolGimpErrorResult('Error saving GIMP document', error);
     }
 }
-const EXPORT_FORMAT_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.webp', '.tif', '.tiff'];
+const FLAT_EXPORT_FORMAT_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.webp', '.tif', '.tiff'];
+const LAYERED_EXPORT_FORMAT_EXTENSIONS = ['.psd'];
+const EXPORT_FORMAT_EXTENSIONS = [
+    ...FLAT_EXPORT_FORMAT_EXTENSIONS,
+    ...LAYERED_EXPORT_FORMAT_EXTENSIONS,
+];
 const exportSchema = {
     type: 'object',
     properties: {
         image: GIMP_IMAGE_PROP,
         file_path: {
             type: 'string',
-            description: 'Absolute path. The extension picks the format: jpg/jpeg, png, webp, tif/tiff. Refuses ' +
-                ".xcf outright — that is gimp_save_xcf's job. Metadata (EXIF/XMP/IPTC/GPS, thumbnail) is " +
-                'ALWAYS stripped on export, unconditionally — never carried over from the source.',
+            description: 'Absolute path. The extension picks the format: jpg/jpeg, png, webp, tif/tiff (flattened), ' +
+                "or psd (layered). Refuses .xcf outright — that is gimp_save_xcf's job. Metadata " +
+                '(EXIF/XMP/IPTC/GPS, thumbnail) is ALWAYS stripped on export, unconditionally — never ' +
+                'carried over from the source.',
         },
         overwrite: {
             type: 'boolean',
@@ -148,23 +157,59 @@ const exportSchema = {
             type: 'integer',
             enum: [8, 16],
             default: 8,
-            description: 'PNG/TIFF only: output bit depth. JPEG/WebP are always 8-bit.',
+            description: 'PNG/TIFF/PSD only: output bit depth. JPEG/WebP are always 8-bit.',
+        },
+        keep_alpha: {
+            type: 'boolean',
+            default: false,
+            description: 'PNG/WebP only: keep transparency. The visible layers are merged onto a transparent ' +
+                'canvas, so areas no layer covers (a cut-out, say) stay transparent. Default false ' +
+                'flattens onto white. Refused for JPEG and TIFF.',
         },
     },
     required: ['image', 'file_path'],
 };
+const LAYER_NAMES_SHOWN = 10;
+function layerNames(names) {
+    const shown = names.slice(0, LAYER_NAMES_SHOWN).map((n) => `"${n}"`);
+    const more = names.length - shown.length;
+    return more > 0 ? `${shown.join(', ')} and ${more} more` : shown.join(', ');
+}
+function layeredExportText(result) {
+    const parts = [
+        `Exported ${result.bytes.toLocaleString()} bytes to ${result.path} as a layered PSD with ` +
+            `${result.layers} layers. Live filters were baked into their layers' pixels.`,
+    ];
+    if (result.merged_groups.length > 0) {
+        parts.push(`Groups merged into one layer each, because PSD cannot store a filter on a group: ` +
+            `${layerNames(result.merged_groups)}.`);
+    }
+    if (result.rasterized_text.length > 0) {
+        parts.push(`Text layers written as pixels, not editable text: ${layerNames(result.rasterized_text)}.`);
+    }
+    if (result.may_blend_differently.length > 0) {
+        parts.push('Photoshop blends partly transparent layers and blend modes in gamma space, so these ' +
+            `may look slightly different there: ${layerNames(result.may_blend_differently)}.`);
+    }
+    parts.push('Metadata (EXIF/XMP/IPTC/GPS, thumbnail) was stripped.');
+    return parts.join(' ');
+}
 async function gimpExport(gimp, rawArgs) {
     try {
         const args = validateArgs(exportSchema, rawArgs);
         const filePath = requireAbsoluteGimpPath('file_path', args.file_path);
         const ext = extname(filePath).toLowerCase();
         if (ext === '.xcf') {
-            throw new GimpError('invalid_argument', '"file_path" must not be a .xcf file — gimp_export writes a flattened deliverable; use ' +
+            throw new GimpError('invalid_argument', '"file_path" must not be a .xcf file — gimp_export writes a deliverable; use ' +
                 'gimp_save_xcf to save the live, re-editable document.');
         }
         if (!EXPORT_FORMAT_EXTENSIONS.includes(ext)) {
             throw new GimpError('invalid_argument', `"file_path" must end in ${EXPORT_FORMAT_EXTENSIONS.join(', ')}, got "${ext || '(none)'}".`);
         }
+        const keepAlpha = args.keep_alpha === true;
+        if (keepAlpha && ext !== '.png' && ext !== '.webp') {
+            throw new GimpError('invalid_argument', `"keep_alpha" only works with a .png or .webp file_path, got "${ext}".`);
+        }
         refuseExistingGimpFile(filePath, args.overwrite, existsSync);
         const bridgeArgs = { image: args.image, path: filePath };
         if (ext === '.jpg' || ext === '.jpeg') {
@@ -182,8 +227,20 @@ async function gimpExport(gimp, rawArgs) {
             bridgeArgs.compression = args.tiff_compression;
             bridgeArgs.bit_depth = args.bit_depth;
         }
-        const result = await gimp.call('export', bridgeArgs);
+        else if (ext === '.psd') {
+            bridgeArgs.bit_depth = args.bit_depth;
+        }
+        if (keepAlpha)
+            bridgeArgs.keep_alpha = true;
         const format = ext.replace('.', '');
+        if (ext === '.psd') {
+            const result = await gimp.call('export', bridgeArgs);
+            return {
+                content: [{ type: 'text', text: layeredExportText(result) }],
+                structuredContent: { ...result, format },
+            };
+        }
+        const result = await gimp.call('export', bridgeArgs);
         return {
             content: [
                 {
@@ -240,7 +297,7 @@ export function createGimpDocumentTools(gimp) {
             tool: {
                 name: 'gimp_close_document',
                 description: 'Headless GIMP: close an image WITHOUT saving. Save first with gimp_save_xcf (keeps filters live) or ' +
-                    'gimp_export (flattened deliverable) if the work should be kept.',
+                    'gimp_export (deliverable) if the work should be kept.',
                 inputSchema: closeSchema,
                 outputSchema: { type: 'object', properties: { closed: { type: 'number' } } },
                 annotations: {
@@ -271,7 +328,8 @@ export function createGimpDocumentTools(gimp) {
                     'to overwrite an existing file unless overwrite: true. Save early: on a very large ' +
                     'document a save can take tens of seconds, and if any call times out the GIMP session ' +
                     'restarts and every unsaved open image and filter is lost — save before long operations, ' +
-                    'not after. For a flattened, shippable copy with metadata stripped, use gimp_export instead.',
+                    'not after. For a shippable copy with metadata stripped (flattened, or a layered .psd), ' +
+                    'use gimp_export instead.',
                 inputSchema: saveXcfSchema,
                 outputSchema: {
                     type: 'object',
@@ -290,12 +348,20 @@ export function createGimpDocumentTools(gimp) {
         {
             tool: {
                 name: 'gimp_export',
-                description: 'Headless GIMP: write a FLATTENED deliverable to disk — every live filter is baked in, ' +
-                    'and ALL metadata (EXIF/XMP/IPTC/GPS, thumbnail) is stripped unconditionally, never ' +
-                    'carried over from the source. Format is picked from the file_path extension (jpg/jpeg, ' +
-                    'png, webp, tif/tiff); any other extension is refused, and .xcf is refused outright — ' +
-                    'use gimp_save_xcf for the live, re-editable document instead. Refuses to overwrite an ' +
-                    'existing file unless overwrite: true (with it, the existing file is replaced).',
+                description: 'Headless GIMP: write a deliverable to disk — every live filter is baked in, and ALL ' +
+                    'metadata (EXIF/XMP/IPTC/GPS, thumbnail) is stripped unconditionally, never carried ' +
+                    'over from the source. Format is picked from the file_path extension: jpg/jpeg, png, ' +
+                    'webp and tif/tiff write a FLATTENED image; psd writes a LAYERED file for finishing in ' +
+                    'Photoshop or another editor. In a PSD, layers keep their masks, opacity, blend modes, ' +
+                    'visibility and groups; filters are baked into each layer; a group with its own filter ' +
+                    'is merged into one layer; text layers become pixels. Photoshop blends partly ' +
+                    'transparent layers and blend modes in gamma space, so those can look slightly ' +
+                    'different there — the result lists them. Any other extension is refused, and .xcf is ' +
+                    'refused outright — use gimp_save_xcf for the live, re-editable document instead. ' +
+                    'Refuses to overwrite an existing file unless overwrite: true (with it, the existing ' +
+                    'file is replaced). A flattened image is composited onto white by default; keep_alpha: ' +
+                    'true (png or webp only) keeps transparency, so a cut-out exports with a transparent ' +
+                    'background.',
                 inputSchema: exportSchema,
                 outputSchema: {
                     type: 'object',
@@ -303,6 +369,22 @@ export function createGimpDocumentTools(gimp) {
                         path: { type: 'string' },
                         bytes: { type: 'number' },
                         format: { type: ['string', 'null'] },
+                        layers: { type: 'number', description: 'PSD only: layers written, groups included.' },
+                        merged_groups: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'PSD only: groups merged into one layer to keep their own filter.',
+                        },
+                        rasterized_text: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'PSD only: text layers written as pixels.',
+                        },
+                        may_blend_differently: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'PSD only: visible layers below 100% opacity or with a non-normal blend mode.',
+                        },
                     },
                 },
                 annotations: {

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

@@ -8,6 +8,9 @@ const EFFECT_TYPES = [
     'lens_blur',
     'add_noise',
     'drop_shadow',
+    'outline',
+    'outer_glow',
+    'surface_blur',
 ];
 const effectSchema = {
     type: 'object',
@@ -41,7 +44,7 @@ const effectSchema = {
         layer_id: GIMP_LAYER_ID_PROP,
         mask: {
             type: 'string',
-            description: 'Name of a mask channel from gimp_create_mask, confining a NEW filter to it. Only valid ' +
+            description: 'Name of a saved selection channel, confining a NEW filter to it. Only valid ' +
                 "when creating (no filter_id) — a filter's mask is fixed at creation. ORDER MATTERS: " +
                 'straighten / flip / resize the canvas first (gimp_transform_canvas, gimp_resize_image), ' +
                 'then crop, THEN add masked effects — rotate, flip, and resize all refuse outright once ' +
@@ -67,8 +70,11 @@ const effectSchema = {
                 '(default 25 when creating) — capped much lower than the other two effects here (measured ' +
                 'live: expensive at full resolution). drop_shadow: blur radius in pixels at full ' +
                 'resolution, 0..1500 (default 10 when creating), clipped to the layer bounds rather than ' +
-                'growing it. Both lens_blur and drop_shadow are SPATIAL (radius-scaled on the proxy ' +
-                'preview, see gimp_overview). The bridge enforces the precise range for whichever ' +
+                'growing it. outer_glow: glow blur in pixels, 1..250 (default 20 when creating). ' +
+                'surface_blur: smoothing radius in pixels, 1..6 (default 4 when creating) — capped low ' +
+                'because its cost grows with the square of the radius (a 24 MP export takes ~17 s at 6). ' +
+                'lens_blur, drop_shadow, outer_glow and surface_blur are SPATIAL (radius-scaled on the ' +
+                'proxy preview, see gimp_overview). The bridge enforces the precise range for whichever ' +
                 '`type` you gave.',
         },
         softness: {
@@ -189,8 +195,38 @@ const effectSchema = {
             type: 'number',
             minimum: 0,
             maximum: 1,
-            description: 'drop_shadow only. Default (when creating): 0.5. The shadow color is black and not ' +
-                'configurable yet.',
+            description: 'drop_shadow: default (when creating) 0.5. The shadow color is black and not ' +
+                'configurable yet. outer_glow: default 0.75 (its color is the `color` field).',
+        },
+        width: {
+            type: 'number',
+            minimum: 1,
+            maximum: 50,
+            description: 'outline only. Stroke thickness in pixels at full resolution, 1..50. Default (when ' +
+                "creating): 4. SPATIAL. The stroke grows outward from the layer's alpha edge (round " +
+                "corners) and the layer's own pixels are untouched.",
+        },
+        spread: {
+            type: 'number',
+            minimum: 0,
+            maximum: 50,
+            description: "outer_glow only. Pixels the glow's solid core grows past the alpha edge before it " +
+                'blurs, 0..50. Default (when creating): 4. SPATIAL.',
+        },
+        color: {
+            type: 'string',
+            pattern: '^#[0-9a-fA-F]{6}$',
+            description: 'outline and outer_glow only. "#rrggbb" hex. Default (when creating): "#000000" for ' +
+                'outline, "#ffffff" for outer_glow.',
+        },
+        edge_preservation: {
+            type: 'number',
+            minimum: 0,
+            maximum: 1,
+            description: 'surface_blur only. How much edge contrast survives, 0..1: LOWER smooths harder (near 0 ' +
+                'starts to soften the edges too), HIGHER leaves more detail and noise. Default (when ' +
+                'creating): 0.08, which flattens fine noise and skin texture while keeping hard edges ' +
+                'sharp.',
         },
     },
     required: ['image', 'type'],
@@ -222,7 +258,7 @@ export function createGimpEffectTools(gimp) {
                 name: 'gimp_add_effect',
                 description: 'Headless GIMP: append (or, with filter_id, re-edit in place) one of a small ' +
                     'allow-listed set of GEGL effect filters — vignette, black_white, motion_blur, ' +
-                    'lens_blur, add_noise, drop_shadow — the same non-destructive, re-editable, maskable ' +
+                    'lens_blur, add_noise, drop_shadow, outline, outer_glow, surface_blur — the same non-destructive, re-editable, maskable ' +
                     "filter mechanism gimp_add_adjustment uses, sharing the SAME stack: gimp_filter's " +
                     "op=list/set_visibility/delete manage this tool's filters exactly as it manages " +
                     "gimp_add_adjustment's. `type` picks the effect; a field another effect uses is " +
@@ -230,16 +266,26 @@ export function createGimpEffectTools(gimp) {
                     'or `layer`, else the selected or top layer), not to the flattened image. A re-edit ' +
                     "(filter_id) MERGES: any field you omit keeps the filter's existing value. Only " +
                     'filters Editmamei created can be re-edited; one added in the GIMP GUI is refused ' +
-                    '(delete and re-create it). `mask` (a channel name from gimp_create_mask) confines a ' +
+                    '(delete and re-create it). `mask` (a saved selection channel name) confines a ' +
                     'NEW filter — fixed at creation, cannot change on a re-edit. ORDER MATTERS: straighten ' +
                     '/ flip / resize the canvas first, then crop, THEN add any masked effect — rotate, ' +
                     'flip, and resize all refuse outright once a masked filter exists, or any filter not ' +
                     'created by Editmamei. vignette, motion_blur, and drop_shadow stay locked to the ' +
                     'content through flip, resize, and an exact 90/180/270-degree rotate (their center/' +
                     'angle/offset fields are updated automatically, and gimp_filter op=list reflects the ' +
-                    'new values afterward) — rotating by any OTHER angle is refused while one of these ' +
-                    'three is present, rather than letting it drift out of alignment. lens_blur is a ' +
-                    'uniform soft-focus blur, not a depth-of-field falloff. For a plain blur with no bokeh ' +
+                    'new values afterward) — rotating by any OTHER angle is refused while a vignette, a ' +
+                    'motion_blur, or a drop_shadow with a non-zero offset is present, rather than letting ' +
+                    'it drift out of alignment. outline, outer_glow, surface_blur, lens_blur and a ' +
+                    'zero-offset drop_shadow have no direction, so they survive any rotation. Resizing ' +
+                    'scales their pixel sizes with the image (never below the 1 px minimum of outline ' +
+                    'width, outer_glow radius and surface_blur radius). lens_blur is a ' +
+                    'uniform soft-focus blur, not a depth-of-field falloff. outline puts a solid stroke ' +
+                    "around a layer's transparent edge (meme text, sticker cut-outs); outer_glow adds a " +
+                    'soft glow around it (glowing text); surface_blur smooths skin and other texture ' +
+                    'while keeping hard edges. outline and outer_glow need a layer with transparency, ' +
+                    'and attach to a text layer without rasterizing it: the text stays editable and the ' +
+                    'effect follows each edit. For a plain ' +
+                    'blur with no bokeh ' +
                     'highlight boost, use gimp_add_adjustment type=gaussian_blur instead. Check the stack ' +
                     'afterward with gimp_filter (op=list).',
                 inputSchema: effectSchema,