@efectoapp/mcp-server 0.1.0

package/dist/tools/state.js

@@ -0,0 +1,943 @@
+"use strict";
+/**
+ * State Building Tools
+ *
+ * Tools for creating and modifying poster state:
+ * - create_poster: Initialize a new poster
+ * - set_background: Configure background layer
+ * - add_layer: Add a layer to the poster
+ * - modify_layer: Modify an existing layer
+ * - apply_effect: Apply main effect (ASCII, dither, etc.)
+ * - add_postprocess: Add post-processing effect
+ *
+ * All state follows the LayerShareState contract for API compatibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateTools = void 0;
+exports.resetState = resetState;
+exports.getCurrentState = getCurrentState;
+exports.handleStateTool = handleStateTool;
+// Current poster state (single poster for now)
+let currentPoster = null;
+// Reset state (useful for testing)
+function resetState() {
+    currentPoster = null;
+}
+// Get current state
+function getCurrentState() {
+    return currentPoster;
+}
+// Generate unique ID
+function generateId() {
+    return `layer_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+// Create default background layer
+function createDefaultBackgroundLayer(backgroundColor) {
+    return {
+        id: 'bg',
+        name: 'Background',
+        type: 'background',
+        visible: true,
+        locked: false,
+        transform: {
+            x: 0,
+            y: 0,
+            width: 1,
+            height: 1,
+            rotation: 0,
+            opacity: 1,
+        },
+        contentType: 'solid',
+        solidColor: backgroundColor,
+    };
+}
+// Tool definitions
+exports.stateTools = [
+    {
+        name: 'create_poster',
+        description: 'Create a new poster with specified aspect ratio. Always starts with a background layer at index 0.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                aspectRatio: {
+                    type: 'string',
+                    enum: ['16:9', '9:16', '1:1', '4:3', 'full'],
+                    description: 'Canvas aspect ratio (default: 9:16 for portrait poster)',
+                    default: '9:16',
+                },
+                backgroundColor: {
+                    type: 'string',
+                    description: 'Background color in hex format (e.g., "#1a1a1a")',
+                    default: '#1a1a1a',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'set_background',
+        description: 'Configure the background layer (always at index 0). Can be solid color, image, or video.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    enum: ['solid', 'image', 'video'],
+                    description: 'Background content type',
+                    default: 'solid',
+                },
+                color: {
+                    type: 'string',
+                    description: 'Solid background color in hex (for type: solid)',
+                },
+                imageUrl: {
+                    type: 'string',
+                    description: 'Image URL (for type: image)',
+                },
+                videoUrl: {
+                    type: 'string',
+                    description: 'Video URL (for type: video)',
+                },
+                objectFit: {
+                    type: 'string',
+                    enum: ['cover', 'contain'],
+                    description: 'How media fills the canvas',
+                    default: 'cover',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'add_layer',
+        description: 'Add a new layer to the poster. Layers are added above existing layers.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    enum: ['text', 'image', 'video'],
+                    description: 'Type of layer to add',
+                },
+                name: { type: 'string', description: 'Layer name' },
+                // Transform properties (normalized 0-1 coordinates relative to canvas)
+                x: { type: 'number', description: 'X position (-1 to 1, 0 is center)', default: 0 },
+                y: { type: 'number', description: 'Y position (-1 to 1, 0 is center)', default: 0 },
+                width: { type: 'number', description: 'Width (0-1 relative to canvas)', default: 1 },
+                height: { type: 'number', description: 'Height (0-1 relative to canvas)', default: 1 },
+                rotation: { type: 'number', description: 'Rotation in degrees', default: 0 },
+                opacity: { type: 'number', description: 'Opacity 0-1', default: 1 },
+                // Text layer properties
+                content: { type: 'string', description: 'Text content (required for text layers)' },
+                fontFamily: { type: 'string', description: 'Font family name', default: 'DM Sans' },
+                fontSize: { type: 'number', description: 'Font size in pixels', default: 48 },
+                fontWeight: { type: 'string', enum: ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'], description: 'Font weight', default: 'bold' },
+                color: { type: 'string', description: 'Text color in hex', default: '#ffffff' },
+                textAlign: { type: 'string', enum: ['left', 'center', 'right'], description: 'Text alignment', default: 'center' },
+                letterSpacing: { type: 'number', description: 'Letter spacing in pixels', default: 0 },
+                lineHeight: { type: 'number', description: 'Line height multiplier', default: 1.2 },
+                // Image/Video properties
+                mediaUrl: { type: 'string', description: 'Media URL (required for image/video layers)' },
+                objectFit: { type: 'string', enum: ['cover', 'contain'], description: 'Object fit mode', default: 'cover' },
+            },
+            required: ['type'],
+        },
+    },
+    {
+        name: 'modify_layer',
+        description: 'Modify an existing layer by ID',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                layerId: { type: 'string', description: 'ID of the layer to modify' },
+                // Transform properties
+                x: { type: 'number', description: 'X position' },
+                y: { type: 'number', description: 'Y position' },
+                width: { type: 'number', description: 'Width' },
+                height: { type: 'number', description: 'Height' },
+                rotation: { type: 'number', description: 'Rotation in degrees' },
+                opacity: { type: 'number', description: 'Opacity 0-1' },
+                visible: { type: 'boolean', description: 'Layer visibility' },
+                locked: { type: 'boolean', description: 'Layer lock state' },
+                name: { type: 'string', description: 'Layer name' },
+                // Text layer properties
+                content: { type: 'string' },
+                fontFamily: { type: 'string' },
+                fontSize: { type: 'number' },
+                fontWeight: { type: 'string' },
+                color: { type: 'string' },
+                textAlign: { type: 'string' },
+                letterSpacing: { type: 'number' },
+                lineHeight: { type: 'number' },
+                // Media properties
+                mediaUrl: { type: 'string' },
+                objectFit: { type: 'string' },
+            },
+            required: ['layerId'],
+        },
+    },
+    {
+        name: 'apply_effect',
+        description: 'Apply or update the main effect (ASCII, dither, halftone, glitch, or art effect). Only one main effect can be active at a time.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                effectId: {
+                    type: 'string',
+                    enum: [
+                        'none',
+                        // ASCII
+                        'ascii-standard', 'ascii-blocks', 'ascii-braille', 'ascii-hatching',
+                        'ascii-matrix', 'ascii-technical', 'ascii-dense', 'ascii-minimal',
+                        // Dither
+                        'dither-floyd-steinberg', 'dither-atkinson', 'dither-jarvis-judice-ninke',
+                        'dither-stucki', 'dither-burkes', 'dither-sierra', 'dither-two-row-sierra',
+                        'dither-sierra-lite', 'color-separation',
+                        // Halftone
+                        'halftone-mono', 'halftone-cmyk',
+                        // Glitch
+                        'glitch-chromatic', 'glitch-digital', 'glitch-vhs', 'glitch-weird',
+                        // Art
+                        'art-kuwahara', 'art-crosshatch', 'art-lineart', 'art-engraving', 'art-stipple',
+                        // Special
+                        'special-warp',
+                    ],
+                    description: 'Effect ID to apply',
+                },
+                enabled: { type: 'boolean', description: 'Whether effect is enabled', default: true },
+                // ASCII effect settings
+                cellSize: { type: 'number', description: 'Cell size for ASCII effects (4-32)', default: 8 },
+                color: { type: 'boolean', description: 'Enable color mode for ASCII', default: true },
+                invert: { type: 'boolean', description: 'Invert ASCII effect', default: false },
+                // Dither effect settings
+                pixelation: { type: 'number', description: 'Pixelation level for dither (1-10)', default: 3 },
+                colors: { type: 'array', items: { type: 'string' }, description: 'Color palette for dither' },
+                // Halftone effect settings
+                dotSize: { type: 'number', description: 'Dot size for halftone effects' },
+                // Glitch effect settings
+                intensity: { type: 'number', description: 'Glitch intensity (0-1)' },
+                speed: { type: 'number', description: 'Glitch animation speed' },
+            },
+            required: ['effectId'],
+        },
+    },
+    {
+        name: 'add_postprocess',
+        description: 'Add a post-processing effect that stacks on top of the main effect',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    enum: [
+                        'scanlines', 'vignette', 'chromatic-aberration', 'curvature',
+                        'grain', 'noise', 'pixelate', 'wave', 'rgb-glitch', 'brightness-contrast',
+                        'color-tint', 'palette', 'jitter', 'bloom', 'dot-screen', 'sepia',
+                        'grid', 'light-beams', 'warp', 'motion-blur',
+                    ],
+                    description: 'Post-process type',
+                },
+                enabled: { type: 'boolean', description: 'Whether effect is enabled', default: true },
+                // Common settings (type-specific settings vary)
+                intensity: { type: 'number', description: 'Effect intensity' },
+                // Scanlines
+                count: { type: 'number', description: 'Number of scanlines' },
+                // Vignette
+                radius: { type: 'number', description: 'Vignette radius' },
+                // Chromatic aberration
+                strength: { type: 'number', description: 'Aberration strength' },
+                angle: { type: 'number', description: 'Aberration angle' },
+                // Grain
+                size: { type: 'number', description: 'Grain size' },
+                speed: { type: 'number', description: 'Animation speed' },
+                // Brightness/Contrast
+                brightness: { type: 'number', description: 'Brightness adjustment' },
+                contrast: { type: 'number', description: 'Contrast adjustment' },
+                saturation: { type: 'number', description: 'Saturation adjustment' },
+                hue: { type: 'number', description: 'Hue rotation' },
+            },
+            required: ['type'],
+        },
+    },
+    {
+        name: 'remove_layer',
+        description: 'Remove a layer by ID. Cannot remove the background layer.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                layerId: { type: 'string', description: 'ID of the layer to remove' },
+            },
+            required: ['layerId'],
+        },
+    },
+    {
+        name: 'get_state',
+        description: 'Get the current poster state as LayerShareState JSON (for debugging or verification)',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+];
+/**
+ * Get effect settings key from effectId
+ */
+function getEffectSettingsKey(effectId) {
+    if (effectId.startsWith('ascii-'))
+        return 'ascii';
+    if (effectId.startsWith('dither-') || effectId === 'color-separation')
+        return 'dither';
+    if (effectId === 'halftone-mono')
+        return 'monoHalftone';
+    if (effectId === 'halftone-cmyk')
+        return 'cmykHalftone';
+    if (effectId === 'glitch-chromatic')
+        return 'chromatic';
+    if (effectId.startsWith('glitch-'))
+        return 'glitch';
+    if (effectId === 'art-kuwahara')
+        return 'kuwahara';
+    if (effectId === 'art-crosshatch')
+        return 'crosshatch';
+    if (effectId === 'art-lineart')
+        return 'lineart';
+    if (effectId === 'art-engraving')
+        return 'engraving';
+    if (effectId === 'art-stipple')
+        return 'stipple';
+    if (effectId === 'special-warp')
+        return 'sinewarp';
+    if (effectId === 'none')
+        return null;
+    return null;
+}
+/**
+ * Handle state tool calls
+ */
+async function handleStateTool(name, args) {
+    const params = args || {};
+    switch (name) {
+        case 'create_poster': {
+            const aspectRatio = params.aspectRatio || '9:16';
+            const backgroundColor = params.backgroundColor || '#1a1a1a';
+            currentPoster = {
+                canvas: { aspectRatio, backgroundColor },
+                layers: [createDefaultBackgroundLayer(backgroundColor)],
+                postProcesses: [],
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Poster created with background layer',
+                            canvas: currentPoster.canvas,
+                            layerCount: currentPoster.layers.length,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        case 'set_background': {
+            if (!currentPoster) {
+                return {
+                    content: [{ type: 'text', text: 'Error: No poster created. Use create_poster first.' }],
+                };
+            }
+            // Background is always at index 0
+            const bgLayer = currentPoster.layers[0];
+            if (bgLayer.type !== 'background') {
+                return {
+                    content: [{ type: 'text', text: 'Error: Background layer not found at index 0' }],
+                };
+            }
+            const contentType = params.type || 'solid';
+            bgLayer.contentType = contentType;
+            if (contentType === 'solid') {
+                if (params.color) {
+                    bgLayer.solidColor = params.color;
+                    currentPoster.canvas.backgroundColor = params.color;
+                }
+                delete bgLayer.inputMedia;
+            }
+            else if (contentType === 'image' && params.imageUrl) {
+                bgLayer.inputMedia = {
+                    mediaUrl: params.imageUrl,
+                    mediaType: 'image',
+                    brightness: 1,
+                    contrast: 1,
+                    saturation: 1,
+                    objectFit: params.objectFit || 'cover',
+                };
+            }
+            else if (contentType === 'video' && params.videoUrl) {
+                bgLayer.inputMedia = {
+                    mediaUrl: params.videoUrl,
+                    mediaType: 'video',
+                    brightness: 1,
+                    contrast: 1,
+                    saturation: 1,
+                    objectFit: params.objectFit || 'cover',
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Background updated',
+                            background: bgLayer,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        case 'add_layer': {
+            if (!currentPoster) {
+                return {
+                    content: [{ type: 'text', text: 'Error: No poster created. Use create_poster first.' }],
+                };
+            }
+            const layerType = params.type;
+            if (!layerType) {
+                return {
+                    content: [{ type: 'text', text: 'Error: Layer type is required' }],
+                };
+            }
+            if (layerType === 'background') {
+                return {
+                    content: [{ type: 'text', text: 'Error: Use set_background to modify the background layer' }],
+                };
+            }
+            const layerId = generateId();
+            const baseLayer = {
+                id: layerId,
+                type: layerType,
+                name: params.name || `${layerType.charAt(0).toUpperCase() + layerType.slice(1)} Layer`,
+                visible: true,
+                locked: false,
+                transform: {
+                    x: params.x ?? 0,
+                    y: params.y ?? 0,
+                    width: params.width ?? 1,
+                    height: params.height ?? 1,
+                    rotation: params.rotation ?? 0,
+                    opacity: params.opacity ?? 1,
+                },
+            };
+            let layer;
+            if (layerType === 'text') {
+                layer = {
+                    ...baseLayer,
+                    type: 'text',
+                    content: params.content || 'Text',
+                    fontFamily: params.fontFamily || 'DM Sans',
+                    fontSize: params.fontSize || 48,
+                    fontWeight: params.fontWeight || 'bold',
+                    color: params.color || '#ffffff',
+                    textAlign: params.textAlign || 'center',
+                    letterSpacing: params.letterSpacing ?? 0,
+                    lineHeight: params.lineHeight ?? 1.2,
+                };
+            }
+            else if (layerType === 'image') {
+                if (!params.mediaUrl) {
+                    return {
+                        content: [{ type: 'text', text: 'Error: mediaUrl is required for image layers' }],
+                    };
+                }
+                layer = {
+                    ...baseLayer,
+                    type: 'image',
+                    mediaUrl: params.mediaUrl,
+                    objectFit: params.objectFit || 'cover',
+                    brightness: 1,
+                    contrast: 1,
+                    saturation: 1,
+                };
+            }
+            else if (layerType === 'video') {
+                if (!params.mediaUrl) {
+                    return {
+                        content: [{ type: 'text', text: 'Error: mediaUrl is required for video layers' }],
+                    };
+                }
+                layer = {
+                    ...baseLayer,
+                    type: 'video',
+                    mediaUrl: params.mediaUrl,
+                    objectFit: params.objectFit || 'cover',
+                    brightness: 1,
+                    contrast: 1,
+                    saturation: 1,
+                    loop: true,
+                    playbackSpeed: 1,
+                };
+            }
+            else {
+                layer = baseLayer;
+            }
+            currentPoster.layers.push(layer);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Layer added',
+                            layer,
+                            totalLayers: currentPoster.layers.length,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        case 'modify_layer': {
+            if (!currentPoster) {
+                return {
+                    content: [{ type: 'text', text: 'Error: No poster created. Use create_poster first.' }],
+                };
+            }
+            const layerId = params.layerId;
+            if (!layerId) {
+                return {
+                    content: [{ type: 'text', text: 'Error: layerId is required' }],
+                };
+            }
+            const layerIndex = currentPoster.layers.findIndex((l) => l.id === layerId);
+            if (layerIndex < 0) {
+                return {
+                    content: [{ type: 'text', text: `Error: Layer not found: ${layerId}` }],
+                };
+            }
+            const layer = currentPoster.layers[layerIndex];
+            // Update transform properties
+            const transformKeys = ['x', 'y', 'width', 'height', 'rotation', 'opacity'];
+            for (const key of transformKeys) {
+                if (params[key] !== undefined) {
+                    layer.transform[key] = params[key];
+                }
+            }
+            // Update base properties
+            if (params.visible !== undefined)
+                layer.visible = params.visible;
+            if (params.locked !== undefined)
+                layer.locked = params.locked;
+            if (params.name !== undefined)
+                layer.name = params.name;
+            // Update text layer properties
+            if (layer.type === 'text') {
+                const textLayer = layer;
+                if (params.content !== undefined)
+                    textLayer.content = params.content;
+                if (params.fontFamily !== undefined)
+                    textLayer.fontFamily = params.fontFamily;
+                if (params.fontSize !== undefined)
+                    textLayer.fontSize = params.fontSize;
+                if (params.fontWeight !== undefined)
+                    textLayer.fontWeight = params.fontWeight;
+                if (params.color !== undefined)
+                    textLayer.color = params.color;
+                if (params.textAlign !== undefined)
+                    textLayer.textAlign = params.textAlign;
+                if (params.letterSpacing !== undefined)
+                    textLayer.letterSpacing = params.letterSpacing;
+                if (params.lineHeight !== undefined)
+                    textLayer.lineHeight = params.lineHeight;
+            }
+            // Update media layer properties (flat structure)
+            if (layer.type === 'image' || layer.type === 'video') {
+                const mediaLayer = layer;
+                if (params.mediaUrl !== undefined)
+                    mediaLayer.mediaUrl = params.mediaUrl;
+                if (params.objectFit !== undefined)
+                    mediaLayer.objectFit = params.objectFit;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Layer modified',
+                            layer,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        case 'apply_effect': {
+            if (!currentPoster) {
+                return {
+                    content: [{ type: 'text', text: 'Error: No poster created. Use create_poster first.' }],
+                };
+            }
+            const effectId = params.effectId;
+            if (!effectId) {
+                return {
+                    content: [{ type: 'text', text: 'Error: effectId is required' }],
+                };
+            }
+            if (effectId === 'none') {
+                delete currentPoster.effect;
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ success: true, message: 'Effect removed' }, null, 2),
+                        },
+                    ],
+                };
+            }
+            const settingsKey = getEffectSettingsKey(effectId);
+            const effect = {
+                effectId,
+                enabled: params.enabled ?? true,
+            };
+            // Build effect-specific settings with proper defaults matching LayerShareState
+            if (settingsKey === 'ascii') {
+                // Extract style from effectId (e.g., "ascii-standard" -> "standard")
+                const style = effectId.replace('ascii-', '');
+                effect.ascii = {
+                    style,
+                    cellSize: params.cellSize ?? 9,
+                    invert: params.invert ?? false,
+                    color: params.color ?? true,
+                    charRotation: false,
+                    postfx: {
+                        preset: 'none',
+                        scanlineIntensity: 0,
+                        scanlineCount: 200,
+                        targetFPS: 0,
+                        jitterIntensity: 0,
+                        jitterSpeed: 1,
+                        mouseGlowEnabled: false,
+                        mouseGlowRadius: 200,
+                        mouseGlowIntensity: 1.5,
+                        vignetteIntensity: 0,
+                        vignetteRadius: 0.8,
+                        colorPalette: 'original',
+                        curvature: 0,
+                        aberrationStrength: 0,
+                        noiseIntensity: 0,
+                        noiseScale: 1,
+                        noiseSpeed: 1,
+                        waveAmplitude: 0,
+                        waveFrequency: 10,
+                        waveSpeed: 1,
+                        glitchIntensity: 0,
+                        glitchFrequency: 0,
+                        brightnessAdjust: 0,
+                        contrastAdjust: 1,
+                    },
+                };
+            }
+            else if (settingsKey === 'dither') {
+                // Extract pattern from effectId (e.g., "dither-floyd-steinberg" -> "floydSteinberg")
+                const patternMap = {
+                    'dither-floyd-steinberg': 'floydSteinberg',
+                    'dither-atkinson': 'atkinson',
+                    'dither-jarvis-judice-ninke': 'jarvisJudiceNinke',
+                    'dither-stucki': 'stucki',
+                    'dither-burkes': 'burkes',
+                    'dither-sierra': 'sierra',
+                    'dither-two-row-sierra': 'twoRowSierra',
+                    'dither-sierra-lite': 'sierraLite',
+                    'color-separation': 'floydSteinberg',
+                };
+                effect.dither = {
+                    pattern: patternMap[effectId] || 'floydSteinberg',
+                    pixelation: params.pixelation ?? 3,
+                    paletteId: 'noir',
+                    colors: params.colors ?? ['#000000', '#ffffff'],
+                    brightness: params.brightness ?? 1,
+                    contrast: params.contrast ?? 1.2,
+                    threshold: 1.0,
+                    bloomEnabled: false,
+                    bloomIntensity: 0.5,
+                    bloomRadius: 8,
+                };
+            }
+            else if (settingsKey === 'monoHalftone') {
+                effect.monoHalftone = {
+                    colorBack: '#f2f1e8',
+                    colorFront: '#2b2b2b',
+                    originalColors: false,
+                    gridType: 'square',
+                    dotType: 'circle',
+                    inverted: false,
+                    size: params.dotSize ?? 0.3,
+                    radius: 0.5,
+                    contrast: 1.2,
+                    spread: 0.3,
+                    grainMixer: 0.0,
+                    grainOverlay: 0.0,
+                };
+            }
+            else if (settingsKey === 'cmykHalftone') {
+                effect.cmykHalftone = {
+                    colorBack: '#f5f5f0',
+                    colorC: '#00aeef',
+                    colorM: '#ec008c',
+                    colorY: '#fff200',
+                    colorK: '#231f20',
+                    size: params.dotSize ?? 0.3,
+                    gridNoise: 0.0,
+                    type: 'ink',
+                    softness: 0.0,
+                    contrast: 1.2,
+                    intensity: 1.0,
+                    angleOffset: 0.0,
+                    misregistration: 0.0,
+                    spread: 0.3,
+                    gainC: 1.0,
+                    gainM: 1.0,
+                    gainY: 1.0,
+                    gainK: 1.0,
+                    floodC: 0.0,
+                    floodM: 0.0,
+                    floodY: 0.0,
+                    floodK: 0.0,
+                    grainMixer: 0.0,
+                    grainSize: 1.0,
+                    grainOverlay: 0.0,
+                };
+            }
+            else if (settingsKey === 'chromatic') {
+                effect.chromatic = {
+                    shape: 'dot',
+                    radius: 4,
+                    rotateR: 15,
+                    rotateG: 75,
+                    rotateB: 0,
+                    scatter: 0,
+                    blending: 1,
+                    blendingMode: 'linear',
+                    greyscale: false,
+                };
+            }
+            else if (settingsKey === 'glitch') {
+                effect.glitch = {
+                    // VHS glitch defaults
+                    grain: 0.4,
+                    glitchBlocks: 0.5,
+                    rgbShift: 0.85,
+                    scanlines: 0.85,
+                    noise: 0.3,
+                    distortion: 0.85,
+                    // Digital glitch defaults
+                    blockSize: 0.5,
+                    displacement: 0.5,
+                    blockOpacity: 1.0,
+                    colorSplit: 0.5,
+                    lineTear: 0.5,
+                    pixelate: 0.3,
+                    // Weird glitch defaults
+                    glitchChance: 0.2,
+                    glitchSpeed: 7.0,
+                    sliceDensity: 14.0,
+                    sliceStrength: 0.38,
+                    shakeStrength: 0.02,
+                    chromaOffset: 0.016,
+                    noiseStrength: 0.2,
+                    colorFlashStrength: 0.4,
+                    scanlineStrength: 0.18,
+                    localWarpStrength: 0.14,
+                    flipChance: 0.15,
+                    // Shared
+                    speed: params.speed ?? 1,
+                    animated: true,
+                };
+            }
+            else if (settingsKey === 'kuwahara') {
+                effect.kuwahara = {
+                    radius: 4,
+                    alpha: 25,
+                    sharpness: 0.5,
+                    sectors: 8,
+                    saturation: 1.0,
+                    quantize: 0,
+                };
+            }
+            else if (settingsKey === 'crosshatch') {
+                effect.crosshatch = {
+                    spacing: 12,
+                    thickness: 2,
+                    angle: 45,
+                    contrast: 1.0,
+                    edgeStrength: 1.0,
+                    wave: 0.33,
+                    waveFreq: 3,
+                    lineWeight: 0,
+                    inkColor: '#1a1a1a',
+                    paperColor: '#f5f5dc',
+                };
+            }
+            else if (settingsKey === 'lineart') {
+                effect.lineart = {
+                    threshold: 0.15,
+                    thickness: 2,
+                    softness: 0,
+                    fillOpacity: 0,
+                    invert: false,
+                    wave: 0.05,
+                    waveFreq: 3,
+                    lineWeight: 0,
+                    lineColor: '#1a1a1a',
+                    fillColor: '#808080',
+                    backgroundColor: '#ffffff',
+                };
+            }
+            else if (settingsKey === 'engraving') {
+                effect.engraving = {
+                    lineFrequency: 80,
+                    lineWeight: 0.5,
+                    contrast: 1.0,
+                    wave: 0.1,
+                    waveFreq: 3,
+                    inkColor: '#1a1a1a',
+                    paperColor: '#f5f5dc',
+                };
+            }
+            else if (settingsKey === 'stipple') {
+                effect.stipple = {
+                    dotDensity: 0.5,
+                    dotSize: 2,
+                    contrast: 1.0,
+                    randomness: 0.5,
+                    inkColor: '#1a1a1a',
+                    paperColor: '#f5f5dc',
+                };
+            }
+            else if (settingsKey === 'sinewarp') {
+                effect.sinewarp = {
+                    speed: 0.5,
+                    scale: 4,
+                    amplitude: 0.5,
+                    bumpIntensity: 0.05,
+                    specularPower: 12,
+                    color: true,
+                    textureScale: 1,
+                };
+            }
+            currentPoster.effect = effect;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Effect applied',
+                            effect,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        case 'add_postprocess': {
+            if (!currentPoster) {
+                return {
+                    content: [{ type: 'text', text: 'Error: No poster created. Use create_poster first.' }],
+                };
+            }
+            const ppType = params.type;
+            if (!ppType) {
+                return {
+                    content: [{ type: 'text', text: 'Error: Post-process type is required' }],
+                };
+            }
+            const ppId = `pp_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+            const settings = {};
+            // Extract relevant settings based on type
+            const settingKeys = [
+                'intensity', 'count', 'radius', 'strength', 'angle', 'size', 'speed',
+                'brightness', 'contrast', 'saturation', 'hue',
+            ];
+            for (const key of settingKeys) {
+                if (params[key] !== undefined) {
+                    settings[key] = params[key];
+                }
+            }
+            const postProcess = {
+                id: ppId,
+                type: ppType,
+                enabled: params.enabled ?? true,
+                settings,
+            };
+            currentPoster.postProcesses.push(postProcess);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Post-process added',
+                            postProcess,
+                            totalPostProcesses: currentPoster.postProcesses.length,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        case 'remove_layer': {
+            if (!currentPoster) {
+                return {
+                    content: [{ type: 'text', text: 'Error: No poster created. Use create_poster first.' }],
+                };
+            }
+            const layerId = params.layerId;
+            if (!layerId) {
+                return {
+                    content: [{ type: 'text', text: 'Error: layerId is required' }],
+                };
+            }
+            const layerIndex = currentPoster.layers.findIndex((l) => l.id === layerId);
+            if (layerIndex < 0) {
+                return {
+                    content: [{ type: 'text', text: `Error: Layer not found: ${layerId}` }],
+                };
+            }
+            if (layerIndex === 0) {
+                return {
+                    content: [{ type: 'text', text: 'Error: Cannot remove background layer' }],
+                };
+            }
+            currentPoster.layers.splice(layerIndex, 1);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Layer removed',
+                            remainingLayers: currentPoster.layers.length,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        case 'get_state': {
+            if (!currentPoster) {
+                return {
+                    content: [{ type: 'text', text: 'No poster created yet. Use create_poster first.' }],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(currentPoster, null, 2),
+                    },
+                ],
+            };
+        }
+        default:
+            return {
+                content: [{ type: 'text', text: `Unknown state tool: ${name}` }],
+            };
+    }
+}
+//# sourceMappingURL=state.js.map