@pinepaper.studio/mcp-server 1.5.1 → 1.5.4

package/dist/types/code-generator.js

@@ -82,7 +82,7 @@ function generateBlendModeCode(itemVarName, blendMode) {
  */
 function generateCreateItemCode(itemType, position, properties) {
     // Extract special properties that need separate handling
-    const { color, fillColor, strokeColor, shadowColor, shadowBlur, shadowOffset, blendMode, opacity, ...baseProperties } = properties;
+    const { color, fillColor, strokeColor, shadowColor, shadowBlur, shadowOffset, blendMode, opacity, contentType, contentFormat, countdownTarget, countdownEndText, ...baseProperties } = properties;
     const params = {
         x: position.x,
         y: position.y,
@@ -127,6 +127,17 @@ const item = app.create('${itemType}', ${JSON.stringify(params, null, 2)});`;
     }
     // Ensure item is visible above backgrounds/generators
     code += `\nif (item.bringToFront) item.bringToFront();`;
+    // Add dynamic content support for text items
+    if (contentType && itemType === 'text') {
+        const opts = {};
+        if (contentFormat)
+            opts.format = contentFormat;
+        if (countdownTarget !== undefined)
+            opts.countdownTarget = countdownTarget;
+        if (countdownEndText)
+            opts.countdownEndText = countdownEndText;
+        code += `\nif (app.setDynamicContent) app.setDynamicContent(item, '${contentType}', ${JSON.stringify(opts)});`;
+    }
     code += `
 const itemId = item.data.registryId;
 app.historyManager.saveState();
@@ -139,15 +150,42 @@ app.historyManager.saveState();
  * Template for modifying items
  */
 function generateModifyItemCode(itemId, properties) {
-    return `
+    const { contentType, contentFormat, countdownTarget, countdownEndText, ...restProperties } = properties;
+    let code = `
 // Modify item ${itemId}
-app.select('${itemId}');
-app.modify(${JSON.stringify(properties, null, 2)});
+app.select('${itemId}');`;
+    // Pass non-dynamic-content properties to app.modify
+    if (Object.keys(restProperties).length > 0) {
+        code += `\napp.modify(${JSON.stringify(restProperties, null, 2)});`;
+    }
+    // Handle dynamic content type changes
+    if (contentType !== undefined) {
+        if (contentType === null || contentType === 'none' || contentType === '') {
+            // Remove dynamic content
+            code += `
+const entry = app.itemRegistry.get('${itemId}');
+if (entry && entry.item && app.removeDynamicContent) app.removeDynamicContent(entry.item);`;
+        }
+        else {
+            // Set dynamic content
+            const opts = {};
+            if (contentFormat)
+                opts.format = contentFormat;
+            if (countdownTarget !== undefined)
+                opts.countdownTarget = countdownTarget;
+            if (countdownEndText)
+                opts.countdownEndText = countdownEndText;
+            code += `
+const entry = app.itemRegistry.get('${itemId}');
+if (entry && entry.item && app.setDynamicContent) app.setDynamicContent(entry.item, '${contentType}', ${JSON.stringify(opts)});`;
+        }
+    }
+    code += `
 app.historyManager.saveState();
 
 // Return success
-({ success: true, itemId: '${itemId}' });
-`.trim();
+({ success: true, itemId: '${itemId}' });`;
+    return code.trim();
 }
 /**
  * Template for deleting items
@@ -257,14 +295,21 @@ app.animate(item, {
 /**
  * Template for keyframe animation
  */
-function generateKeyframeAnimateCode(itemId, keyframes, duration, loop = false) {
+function generateKeyframeAnimateCode(itemId, keyframes, duration, loop = false, timeOffset, clipInPoint, clipOutPoint) {
     const keyframesJson = JSON.stringify(keyframes, null, 2);
     const calculatedDuration = duration || Math.max(...keyframes.map(k => k.time));
+    const opts = { duration: calculatedDuration, loop };
+    if (timeOffset !== undefined)
+        opts.timeOffset = timeOffset;
+    if (clipInPoint !== undefined)
+        opts.clipInPoint = clipInPoint;
+    if (clipOutPoint !== undefined)
+        opts.clipOutPoint = clipOutPoint;
     return `
 // Apply keyframe animation to ${itemId}
-app.addAnimation('${itemId}', ${keyframesJson}, { duration: ${calculatedDuration}, loop: ${loop} });
+app.addAnimation('${itemId}', ${keyframesJson}, ${JSON.stringify(opts)});
 
-({ success: true, itemId: '${itemId}', duration: ${calculatedDuration}, loop: ${loop} });
+({ success: true, itemId: '${itemId}', duration: ${calculatedDuration}, loop: ${loop}${timeOffset !== undefined ? `, timeOffset: ${timeOffset}` : ''}${clipInPoint !== undefined ? `, clipInPoint: ${clipInPoint}` : ''}${clipOutPoint !== undefined ? `, clipOutPoint: ${clipOutPoint}` : ''} });
 `.trim();
 }
 /**
@@ -351,6 +396,12 @@ function generatePlayTimelineCode(action, duration, loop, time) {
 // Play keyframe timeline
 app.playKeyframeTimeline(${duration || 5}, ${loop ?? false});
 ({ success: true, action: 'play', duration: ${duration || 5}, loop: ${loop ?? false} });
+`.trim();
+        case 'pause':
+            return `
+// Pause keyframe timeline
+app.pauseKeyframeTimeline();
+({ success: true, action: 'pause' });
 `.trim();
         case 'stop':
             return `
@@ -576,7 +627,14 @@ export class PinePaperCodeGenerator {
      */
     generateCreateItem(input) {
         const validated = CreateItemInputSchema.parse(input);
-        return generateCreateItemCode(validated.itemType, validated.position, validated.properties);
+        const properties = { ...validated.properties };
+        if (validated.animationType !== undefined)
+            properties.animationType = validated.animationType;
+        if (validated.animationSpeed !== undefined)
+            properties.animationSpeed = validated.animationSpeed;
+        if (validated.keyframes !== undefined)
+            properties.keyframes = validated.keyframes;
+        return generateCreateItemCode(validated.itemType, validated.position, properties);
     }
     /**
      * Generate code for modifying an item
@@ -622,7 +680,7 @@ export class PinePaperCodeGenerator {
      */
     generateKeyframeAnimate(input) {
         const validated = KeyframeAnimateInputSchema.parse(input);
-        return generateKeyframeAnimateCode(validated.itemId, validated.keyframes, validated.duration, validated.loop);
+        return generateKeyframeAnimateCode(validated.itemId, validated.keyframes, validated.duration, validated.loop, validated.timeOffset, validated.clipInPoint, validated.clipOutPoint);
     }
     /**
      * Generate code for executing a generator
@@ -742,6 +800,70 @@ if (imported) {
         return `
 // Error: No SVG source provided
 throw new Error('Either svgString or url must be provided');
+`.trim();
+    }
+    /**
+     * Generate code for importing a Mermaid diagram (flowchart, stateDiagram,
+     * sequenceDiagram, erDiagram, classDiagram).
+     */
+    generateImportMermaid(mermaidText, options = {}) {
+        const escaped = mermaidText.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+        const optsJson = JSON.stringify(options);
+        return `
+// Import Mermaid diagram
+(function() {
+  if (!app.importMermaid) return { success: false, error: 'importMermaid not available — diagramSystem missing' };
+  const mermaidText = \`${escaped}\`;
+  const result = app.importMermaid(mermaidText, ${optsJson});
+  return {
+    success: !!result.success,
+    nodeCount: result.nodes ? result.nodes.length : 0,
+    edgeCount: result.edges ? result.edges.length : 0,
+    nodes: result.nodes || [],
+    edges: result.edges || [],
+    errors: result.errors || [],
+  };
+})();
+`.trim();
+    }
+    /**
+     * Generate code for capturing the canvas as pp: ontology. Wraps FxTool's
+     * app.exportCanvasOntology() — defined in PinePaper.js after the
+     * canvas-state-to-ontology promotion. Output mirrors the cloud-sync
+     * postMessage contract: { canvasWidth, canvasHeight, itemCount,
+     * itemTypes, hasAnimations, relationCount, items, triples, [viewport] }.
+     *
+     * Failure modes: app missing the method → return { success: false, error }
+     * with a clear FxTool-version hint. Internal exceptions propagate from
+     * the browser-side function (TripleLanguage warns to console; we don't
+     * fail the tool call on triple-only failures).
+     */
+    generateGetCanvasOntology(options = {}) {
+        const optsJson = JSON.stringify(options);
+        return `
+// Capture canvas as pp: ontology
+(function() {
+  if (!app.exportCanvasOntology) {
+    return {
+      success: false,
+      error: 'app.exportCanvasOntology not available — requires FxTool with canvas-ontology promotion. Falling back to pinepaper_get_items is acceptable but loses the triples representation.',
+    };
+  }
+  const ctx = app.exportCanvasOntology(${optsJson});
+  return {
+    success: true,
+    canvasWidth: ctx.canvasWidth,
+    canvasHeight: ctx.canvasHeight,
+    canvasPreset: ctx.canvasPreset,
+    itemCount: ctx.itemCount,
+    itemTypes: ctx.itemTypes,
+    hasAnimations: ctx.hasAnimations,
+    relationCount: ctx.relationCount,
+    items: ctx.items,
+    triples: ctx.triples,
+    viewport: ctx.viewport,
+  };
+})();
 `.trim();
     }
     /**
@@ -1340,10 +1462,11 @@ throw new Error('Unknown diagram mode action: ${action}');
      */
     generateAgentStartJob(input) {
         const validated = AgentStartJobInputSchema.parse(input);
-        const { name, screenshotPolicy, canvasPreset, clearCanvas } = validated;
+        const { name, screenshotPolicy, canvasPreset, clearCanvas, includeOntology } = validated;
         const nameStr = name ? `'${name.replace(/'/g, "\\'")}'` : 'null';
         const policyStr = screenshotPolicy || 'on_complete';
         const shouldClear = clearCanvas !== false;
+        const wantOntology = includeOntology !== false;
         let code = `
 // Start agent job
 (async function() {
@@ -1372,10 +1495,31 @@ throw new Error('Unknown diagram mode action: ${action}');
   app.setCanvasSize('${canvasPreset}');
   // Allow canvas resize to take effect
   await new Promise(r => setTimeout(r, 50));
+`;
+        }
+        if (wantOntology) {
+            code += `
+  // Capture initial canvas ontology so the agent has baseline context
+  // without a follow-up pinepaper_get_canvas_ontology call. After
+  // clearCanvas this is a tiny empty-state payload; with clearCanvas:false
+  // it captures whatever's already on the canvas. Older FxTool builds
+  // without exportCanvasOntology produce an _ontologyUnavailable: true
+  // marker so the agent knows to fall back to pinepaper_get_items.
+  let _ontology = null;
+  let _ontologyUnavailable = false;
+  try {
+    if (app.exportCanvasOntology) {
+      _ontology = app.exportCanvasOntology();
+    } else {
+      _ontologyUnavailable = true;
+    }
+  } catch (e) {
+    _ontologyUnavailable = true;
+  }
 `;
         }
         code += `
-  // Return job context with canvas size
+  // Return job context with canvas size${wantOntology ? ' + initial ontology' : ''}
   const _cs = app.getCanvasSize ? app.getCanvasSize() : { width: 800, height: 600 };
   return {
     success: true,
@@ -1384,7 +1528,9 @@ throw new Error('Unknown diagram mode action: ${action}');
     screenshotPolicy: '${policyStr}',
     canvasPreset: ${canvasPreset ? `'${canvasPreset}'` : 'null'},
     canvasCleared: ${shouldClear},
-    canvasSize: { width: _cs.width || 800, height: _cs.height || 600 }
+    canvasSize: { width: _cs.width || 800, height: _cs.height || 600 }${wantOntology ? `,
+    ontology: _ontology,
+    ontologyUnavailable: _ontologyUnavailable || undefined` : ''}
   };
 })();
 `;
@@ -1794,13 +1940,13 @@ return { success: true, action: 'seek', time: ${op.time || 0} };
      */
     generateAgentExport(input) {
         const validated = AgentExportInputSchema.parse(input);
-        const { platform, format, quality } = validated;
+        const { platform, format, quality, framing } = validated;
         const qualityLevel = quality || 'standard';
-        // Quality settings
+        // Quality settings (bitrate in bps for VideoEncoder)
         const qualitySettings = {
-            draft: { compression: 0.6, fps: 15, dpi: 72 },
-            standard: { compression: 0.85, fps: 30, dpi: 150 },
-            high: { compression: 0.95, fps: 60, dpi: 300 },
+            draft: { compression: 0.6, fps: 15, dpi: 72, bitrate: 2_000_000 },
+            standard: { compression: 0.85, fps: 30, dpi: 150, bitrate: 5_000_000 },
+            high: { compression: 0.95, fps: 60, dpi: 300, bitrate: 8_000_000 },
         }[qualityLevel];
         // Platform presets
         const platformPresets = {
@@ -1824,10 +1970,38 @@ return { success: true, action: 'seek', time: ${op.time || 0} };
   const platform = '${platform}';
   const format = '${exportFormat}';
   const quality = '${qualityLevel}';
+  const framing = '${framing}';
   const settings = ${JSON.stringify(qualitySettings)};
   const dimensions = ${JSON.stringify({ width: preset.width, height: preset.height })};
 
-  let result = { success: false, platform, format, quality };
+  // Resolve camera-view framing dims when requested. Reads the first
+  // camera_animates keyframe's zoom and divides the canvas dims by it
+  // (mirrors FxTool ExportEngine.js:466-485). Camera animation still
+  // drives motion during export — framing only fixes the output frame.
+  let cameraDims = null;
+  if (framing === 'camera') {
+    if (!['gif', 'mp4', 'webm'].includes(format)) {
+      return { success: false, platform, format, framing, error: 'framing: "camera" is only supported for video formats (gif, mp4, webm). Use format: "mp4" / "gif" / "webm" or omit framing.' };
+    }
+    const rr = app.relationRegistry;
+    const hasWalkthrough = rr && typeof rr.hasCameraAnimation === 'function' && rr.hasCameraAnimation();
+    if (!hasWalkthrough) {
+      return { success: false, platform, format, framing, error: 'framing: "camera" requires a camera_animates walkthrough on the canvas. Add one or omit framing.' };
+    }
+    const params = rr.getCameraAnimationParams ? rr.getCameraAnimationParams() : null;
+    if (!params || (params.mode || 'keyframes') !== 'keyframes' || !params.keyframes || !params.keyframes.length) {
+      return { success: false, platform, format, framing, error: 'framing: "camera" requires a keyframe-mode camera walkthrough with at least one keyframe.' };
+    }
+    const firstKf = params.keyframes[0];
+    const firstZoom = firstKf && firstKf.zoom > 0 ? firstKf.zoom : 1;
+    const canvasEl = document.querySelector('canvas');
+    cameraDims = {
+      width: Math.round((canvasEl ? canvasEl.width : dimensions.width) / firstZoom),
+      height: Math.round((canvasEl ? canvasEl.height : dimensions.height) / firstZoom),
+    };
+  }
+
+  let result = { success: false, platform, format, quality, framing };
 
   try {
     switch (format) {
@@ -1875,28 +2049,44 @@ return { success: true, action: 'seek', time: ${op.time || 0} };
       case 'mp4':
       case 'webm': {
         const videoMimeType = { mp4: 'video/mp4', webm: 'video/webm', gif: 'image/gif' }[format];
-        // Use _quickExportVideo (delegates to VideoExporter.export internally)
-        if (app.exportEngine && app.exportEngine._quickExportVideo) {
-          const videoResult = await app.exportEngine._quickExportVideo(format, { fps: settings.fps, duration: 5 }, false);
+        // FxTool VideoExporter._calculateBitrate multiplies a per-resolution
+        // base by settings.quality (0.5-1.0). Our existing per-tier compression
+        // values (0.6 / 0.85 / 0.95) map directly to that scale. Without this,
+        // ExportEngine._quickExportVideo overrides quality with undefined for
+        // mp4/webm, _calculateBitrate yields NaN, and VideoEncoder.configure
+        // rejects with 'malformed bitrate value'.
+        const baseVideoSettings = { format, fps: settings.fps, quality: settings.compression, duration: 5 };
+        const blobToDataUrl = (b) => new Promise(resolve => {
+          const r = new FileReader();
+          r.onloadend = () => resolve(r.result);
+          r.readAsDataURL(b);
+        });
+        // Camera framing requires going direct to videoExporter so width/height
+        // pass through — _quickExportVideo strips dim fields.
+        if (cameraDims && app.exportEngine && app.exportEngine.videoExporter) {
+          const blob = await app.exportEngine.videoExporter.export({ ...baseVideoSettings, width: cameraDims.width, height: cameraDims.height });
+          const dataUrl = await blobToDataUrl(blob);
+          result = { success: true, platform, format, framing, data: dataUrl, mimeType: videoMimeType, size: blob.size, dimensions: cameraDims };
+        } else if ((format === 'mp4' || format === 'webm') && app.exportEngine && app.exportEngine.videoExporter) {
+          // Bypass _quickExportVideo for mp4/webm — it hardcodes
+          // quality:undefined for these formats and produces a NaN bitrate.
+          const blob = await app.exportEngine.videoExporter.export(baseVideoSettings);
+          const dataUrl = await blobToDataUrl(blob);
+          result = { success: true, platform, format, framing, data: dataUrl, mimeType: videoMimeType, size: blob.size };
+        } else if (app.exportEngine && app.exportEngine._quickExportVideo) {
+          // GIF path (working): _quickExportVideo forwards gifQuality to
+          // gif.js. Also serves as the fallback if videoExporter is absent.
+          const videoResult = await app.exportEngine._quickExportVideo(format, baseVideoSettings, false);
           if (videoResult && videoResult.blob) {
-            const reader = new FileReader();
-            const dataUrl = await new Promise(resolve => {
-              reader.onloadend = () => resolve(reader.result);
-              reader.readAsDataURL(videoResult.blob);
-            });
-            result = { success: true, platform, format, data: dataUrl, mimeType: videoMimeType, size: videoResult.blob.size };
+            const dataUrl = await blobToDataUrl(videoResult.blob);
+            result = { success: true, platform, format, framing, data: dataUrl, mimeType: videoMimeType, size: videoResult.blob.size };
           } else {
             result = { success: false, error: format.toUpperCase() + ' export returned no data' };
           }
         } else if (app.exportEngine && app.exportEngine.videoExporter) {
-          // Fallback: call VideoExporter.export directly
-          const blob = await app.exportEngine.videoExporter.export({ format, fps: settings.fps, duration: 5 });
-          const reader = new FileReader();
-          const dataUrl = await new Promise(resolve => {
-            reader.onloadend = () => resolve(reader.result);
-            reader.readAsDataURL(blob);
-          });
-          result = { success: true, platform, format, data: dataUrl, mimeType: videoMimeType, size: blob.size };
+          const blob = await app.exportEngine.videoExporter.export(baseVideoSettings);
+          const dataUrl = await blobToDataUrl(blob);
+          result = { success: true, platform, format, framing, data: dataUrl, mimeType: videoMimeType, size: blob.size };
         } else {
           result = { success: false, error: format.toUpperCase() + ' export not available' };
         }
@@ -2339,7 +2529,7 @@ app.historyManager.saveState();
         if (gradientDirection)
             options.gradientDirection = gradientDirection;
         return `
-// Create letter collage: "${text}"
+// Create letter collage
 (function() {
   const text = ${JSON.stringify(text)};
   const options = ${JSON.stringify(options, null, 2)};
@@ -2354,7 +2544,21 @@ app.historyManager.saveState();
     app.historyManager.saveState('create_letter_collage');
   }
 
-  return result;
+  // Return a SERIALIZABLE summary — never the raw result. result.group and
+  // result.letters are live Paper.js objects (circular parent/children refs,
+  // methods, canvas handles); the browser round-trip (page.evaluate / CDP
+  // return-by-value) can't serialize them, so returning result throws
+  // "Failed to execute code in browser" even though the collage was already
+  // created — a false negative. Surface registry ids instead.
+  const collageId = (result && (result.collageId
+    || (result.group && result.group.data && (result.group.data.id || result.group.data.registryId)))) || null;
+  const letterIds = (result && Array.isArray(result.letters))
+    ? result.letters.map(function(l){ return (l && l.data && (l.data.id || l.data.registryId)) || null; }).filter(Boolean)
+    : [];
+  if (!collageId) {
+    return { success: false, error: 'createLetterCollage returned no id', letterCount: letterIds.length, letterIds: letterIds };
+  }
+  return { success: true, collageId: collageId, itemId: collageId, letterCount: letterIds.length, letterIds: letterIds };
 })();
 `.trim();
     }
@@ -3465,6 +3669,1219 @@ ${mask ? `    app.imageTools.applyMask(raster, '${mask}');\n` : ''}    const ite
 })();
 `.trim();
     }
+    generateManageScenes(input) {
+        const guard = `if (!app.sceneManager) return { error: 'SceneManager not available' };`;
+        switch (input.action) {
+            case 'save':
+                return `
+// Save current canvas as scene
+(async function() {
+  ${guard}
+  try {
+    const result = await app.sceneManager.saveCurrentAsScene(${JSON.stringify(input.name || 'Untitled Scene')});
+    return { success: true, action: 'save', sceneId: result?.id || result, name: ${JSON.stringify(input.name || 'Untitled Scene')} };
+  } catch (e) {
+    return { error: 'Failed to save scene: ' + e.message };
+  }
+})();
+`.trim();
+            case 'load':
+                return `
+// Load scene
+(async function() {
+  ${guard}
+  try {
+    await app.sceneManager.loadScene(${JSON.stringify(input.sceneId)}${input.transition ? `, { transition: ${JSON.stringify(input.transition)} }` : ''});
+    return { success: true, action: 'load', sceneId: ${JSON.stringify(input.sceneId)}${input.transition ? `, transition: ${JSON.stringify(input.transition)}` : ''} };
+  } catch (e) {
+    return { error: 'Failed to load scene: ' + e.message };
+  }
+})();
+`.trim();
+            case 'list':
+                return `
+// List all scenes
+(function() {
+  ${guard}
+  const scenes = app.sceneManager.listScenes();
+  return { success: true, action: 'list', scenes: scenes, count: scenes.length };
+})();
+`.trim();
+            case 'delete':
+                return `
+// Delete scene
+(function() {
+  ${guard}
+  app.sceneManager.deleteScene(${JSON.stringify(input.sceneId)});
+  return { success: true, action: 'delete', sceneId: ${JSON.stringify(input.sceneId)} };
+})();
+`.trim();
+            case 'rename':
+                return `
+// Rename scene
+(function() {
+  ${guard}
+  app.sceneManager.renameScene(${JSON.stringify(input.sceneId)}, ${JSON.stringify(input.name)});
+  return { success: true, action: 'rename', sceneId: ${JSON.stringify(input.sceneId)}, name: ${JSON.stringify(input.name)} };
+})();
+`.trim();
+            case 'duplicate':
+                return `
+// Duplicate scene
+(function() {
+  ${guard}
+  const result = app.sceneManager.duplicateScene(${JSON.stringify(input.sceneId)});
+  return { success: true, action: 'duplicate', originalId: ${JSON.stringify(input.sceneId)}, newScene: result };
+})();
+`.trim();
+            case 'reorder':
+                return `
+// Reorder scenes
+(function() {
+  ${guard}
+  app.sceneManager.reorderScenes(${JSON.stringify(input.sceneIds)});
+  return { success: true, action: 'reorder', order: ${JSON.stringify(input.sceneIds)} };
+})();
+`.trim();
+            case 'info':
+                return `
+// Get scene info
+(function() {
+  ${guard}
+  const scene = app.sceneManager.getScene(${JSON.stringify(input.sceneId)});
+  if (!scene) return { error: 'Scene not found: ${input.sceneId}' };
+  return { success: true, action: 'info', scene: scene };
+})();
+`.trim();
+            case 'export':
+                return `
+// Export all scenes
+(function() {
+  ${guard}
+  const data = app.sceneManager.exportScenes();
+  return { success: true, action: 'export', data: data };
+})();
+`.trim();
+            case 'import':
+                return `
+// Import scenes
+(function() {
+  ${guard}
+  try {
+    const json = ${JSON.stringify(input.scenesJson)};
+    app.sceneManager.importScenes(json${input.merge !== undefined ? `, { merge: ${input.merge} }` : ''});
+    return { success: true, action: 'import'${input.merge !== undefined ? `, merge: ${input.merge}` : ''} };
+  } catch (e) {
+    return { error: 'Failed to import scenes: ' + e.message };
+  }
+})();
+`.trim();
+            default:
+                return `(function() { return { error: 'Unknown manage_scenes action: ${input.action}' }; })();`;
+        }
+    }
+    generateScenePlayback(input) {
+        const guard = `if (!app.sceneManager) return { error: 'SceneManager not available' };`;
+        switch (input.action) {
+            case 'create_chain': {
+                const opts = [];
+                if (input.loop !== undefined)
+                    opts.push(`loop: ${input.loop}`);
+                if (input.autoPlay !== undefined)
+                    opts.push(`autoPlay: ${input.autoPlay}`);
+                if (input.defaultDuration !== undefined)
+                    opts.push(`defaultDuration: ${input.defaultDuration * 1000}`);
+                if (input.defaultTransition !== undefined)
+                    opts.push(`defaultTransition: ${JSON.stringify(input.defaultTransition)}`);
+                if (input.transitionDuration !== undefined)
+                    opts.push(`transitionDuration: ${input.transitionDuration * 1000}`);
+                const optsStr = opts.length > 0 ? `, { ${opts.join(', ')} }` : '';
+                return `
+// Create scene chain for sequential playback
+(function() {
+  ${guard}
+  app.sceneManager.createChain(${JSON.stringify(input.sceneIds)}${optsStr});
+  return { success: true, action: 'create_chain', sceneIds: ${JSON.stringify(input.sceneIds)}${input.loop !== undefined ? `, loop: ${input.loop}` : ''}${input.defaultDuration !== undefined ? `, defaultDuration: ${input.defaultDuration}` : ''} };
+})();
+`.trim();
+            }
+            case 'play':
+                return `
+// Play scene chain
+(async function() {
+  ${guard}
+  try {
+    await app.sceneManager.playChain();
+    return { success: true, action: 'play' };
+  } catch (e) {
+    return { error: 'Failed to play chain: ' + e.message };
+  }
+})();
+`.trim();
+            case 'pause':
+                return `
+// Pause scene chain
+(function() {
+  ${guard}
+  app.sceneManager.pauseChain();
+  return { success: true, action: 'pause' };
+})();
+`.trim();
+            case 'resume':
+                return `
+// Resume scene chain
+(function() {
+  ${guard}
+  app.sceneManager.resumeChain();
+  return { success: true, action: 'resume' };
+})();
+`.trim();
+            case 'stop':
+                return `
+// Stop scene chain
+(function() {
+  ${guard}
+  app.sceneManager.stopChain();
+  return { success: true, action: 'stop' };
+})();
+`.trim();
+            case 'toggle_loop':
+                return `
+// Toggle loop mode
+(function() {
+  ${guard}
+  app.sceneManager.setLoop(${input.enabled ?? true});
+  return { success: true, action: 'toggle_loop', enabled: ${input.enabled ?? true} };
+})();
+`.trim();
+            case 'jump':
+                return `
+// Jump to scene index
+(async function() {
+  ${guard}
+  try {
+    await app.sceneManager.jumpToChainIndex(${input.index ?? 0});
+    return { success: true, action: 'jump', index: ${input.index ?? 0} };
+  } catch (e) {
+    return { error: 'Failed to jump to index: ' + e.message };
+  }
+})();
+`.trim();
+            default:
+                return `(function() { return { error: 'Unknown scene_playback action: ${input.action}' }; })();`;
+        }
+    }
+    // ===========================================================================
+    // SELECTION, TRANSFORM & HISTORY
+    // ===========================================================================
+    generateSelection(input) {
+        switch (input.action) {
+            case 'select': {
+                const ids = JSON.stringify(input.itemIds || []);
+                const mode = input.mode || 'replace';
+                return `
+// Select items
+(function() {
+  const ids = ${ids};
+  if (ids.length === 0) return { error: 'No itemIds provided' };
+  ${mode === 'replace' ? 'app.deselectAll();' : ''}
+  const selected = [];
+  for (const id of ids) {
+    const entry = app.itemRegistry.get(id);
+    if (entry && entry.item) {
+      ${mode === 'remove' ? 'entry.item.selected = false;' : 'app.select(entry.item);'}
+      selected.push(id);
+    }
+  }
+  return { success: true, action: 'select', mode: '${mode}', selected };
+})();`.trim();
+            }
+            case 'select_all':
+                return `
+// Select all items
+(function() {
+  app.selectAll();
+  const items = app.getSelection().map(i => i.data?.itemId || i.name || i.id);
+  return { success: true, action: 'select_all', count: items.length, items };
+})();`.trim();
+            case 'deselect_all':
+                return `
+// Deselect all items
+(function() {
+  app.deselectAll();
+  return { success: true, action: 'deselect_all' };
+})();`.trim();
+            case 'get':
+                return `
+// Get current selection
+(function() {
+  const items = app.getSelection().map(i => ({
+    itemId: i.data?.itemId || i.name || i.id,
+    type: i.data?.itemType || i.className,
+    bounds: i.bounds ? { x: i.bounds.x, y: i.bounds.y, width: i.bounds.width, height: i.bounds.height } : null
+  }));
+  return { success: true, action: 'get', count: items.length, items };
+})();`.trim();
+            case 'delete_selected':
+                return `
+// Delete selected items
+(function() {
+  const selection = app.getSelection();
+  const deleted = selection.map(i => i.data?.itemId || i.name || i.id);
+  app.deleteSelected();
+  return { success: true, action: 'delete_selected', deleted, count: deleted.length };
+})();`.trim();
+            default:
+                return `(function() { return { error: 'Unknown selection action: ${input.action}' }; })();`;
+        }
+    }
+    generateTransform(input) {
+        switch (input.action) {
+            case 'nudge': {
+                const dx = input.dx ?? 0;
+                const dy = input.dy ?? 0;
+                return `
+// Nudge item position
+(function() {
+  const entry = app.itemRegistry.get(${JSON.stringify(input.itemId || '')});
+  if (!entry || !entry.item) return { error: 'Item not found: ${input.itemId}' };
+  entry.item.position.x += ${dx};
+  entry.item.position.y += ${dy};
+  return { success: true, action: 'nudge', itemId: '${input.itemId}', dx: ${dx}, dy: ${dy}, position: { x: entry.item.position.x, y: entry.item.position.y } };
+})();`.trim();
+            }
+            case 'flip': {
+                const dir = input.direction || 'horizontal';
+                return `
+// Flip item ${dir}ly
+(function() {
+  const entry = app.itemRegistry.get(${JSON.stringify(input.itemId || '')});
+  if (!entry || !entry.item) return { error: 'Item not found: ${input.itemId}' };
+  ${dir === 'horizontal' ? 'entry.item.scale(-1, 1);' : 'entry.item.scale(1, -1);'}
+  return { success: true, action: 'flip', itemId: '${input.itemId}', direction: '${dir}' };
+})();`.trim();
+            }
+            case 'reorder': {
+                const order = input.order || 'bringToFront';
+                const methodMap = {
+                    bringToFront: 'bringToFront',
+                    sendToBack: 'sendToBack',
+                    moveUp: 'moveAbove',
+                    moveDown: 'moveBelow',
+                };
+                const method = methodMap[order] || 'bringToFront';
+                const needsSibling = order === 'moveUp' || order === 'moveDown';
+                if (needsSibling) {
+                    const siblingExpr = order === 'moveUp' ? 'entry.item.nextSibling' : 'entry.item.previousSibling';
+                    return `
+// Reorder item: ${order}
+(function() {
+  const entry = app.itemRegistry.get(${JSON.stringify(input.itemId || '')});
+  if (!entry || !entry.item) return { error: 'Item not found: ${input.itemId}' };
+  const sibling = ${siblingExpr};
+  if (sibling) entry.item.${method}(sibling);
+  return { success: true, action: 'reorder', itemId: '${input.itemId}', order: '${order}' };
+})();`.trim();
+                }
+                return `
+// Reorder item: ${order}
+(function() {
+  const entry = app.itemRegistry.get(${JSON.stringify(input.itemId || '')});
+  if (!entry || !entry.item) return { error: 'Item not found: ${input.itemId}' };
+  entry.item.${method}();
+  return { success: true, action: 'reorder', itemId: '${input.itemId}', order: '${order}' };
+})();`.trim();
+            }
+            default:
+                return `(function() { return { error: 'Unknown transform action: ${input.action}' }; })();`;
+        }
+    }
+    generateHistory(input) {
+        const guard = `if (!app.historyManager) return { error: 'HistoryManager not available' };`;
+        switch (input.action) {
+            case 'undo':
+                return `
+// Undo last action
+(function() {
+  ${guard}
+  app.historyManager.undo();
+  return { success: true, action: 'undo' };
+})();`.trim();
+            case 'redo':
+                return `
+// Redo last undone action
+(function() {
+  ${guard}
+  app.historyManager.redo();
+  return { success: true, action: 'redo' };
+})();`.trim();
+            case 'get_state':
+                return `
+// Get history state
+(function() {
+  ${guard}
+  const state = app.historyManager.getState();
+  return { success: true, action: 'get_state', ...state };
+})();`.trim();
+            default:
+                return `(function() { return { error: 'Unknown history action: ${input.action}' }; })();`;
+        }
+    }
+    // ===========================================================================
+    // IMAGE PROCESSING
+    // ===========================================================================
+    generateImageFilter(input) {
+        const guard = `if (!app.imageTools) return { error: 'ImageTools not available' };`;
+        switch (input.action) {
+            case 'apply':
+                return `
+// Apply image filter
+(async function() {
+  ${guard}
+  try {
+    const result = await app.imageTools.applyFilter(${JSON.stringify(input.itemId)}, ${JSON.stringify(input.filterName || '')}, ${JSON.stringify(input.params || {})});
+    return { success: true, action: 'apply', itemId: ${JSON.stringify(input.itemId)}, filter: ${JSON.stringify(input.filterName || '')} };
+  } catch (e) {
+    return { error: 'Failed to apply filter: ' + e.message };
+  }
+})();`.trim();
+            case 'chain':
+                return `
+// Apply filter chain
+(async function() {
+  ${guard}
+  try {
+    const filters = ${JSON.stringify(input.filters || [])};
+    const result = await app.imageTools.applyFilterChain(${JSON.stringify(input.itemId)}, filters);
+    return { success: true, action: 'chain', itemId: ${JSON.stringify(input.itemId)}, filterCount: filters.length };
+  } catch (e) {
+    return { error: 'Failed to apply filter chain: ' + e.message };
+  }
+})();`.trim();
+            default:
+                return `(function() { return { error: 'Unknown image_filter action: ${input.action}' }; })();`;
+        }
+    }
+    generateLasso(input) {
+        const guard = `if (!app.imageTools) return { error: 'ImageTools not available' };`;
+        switch (input.action) {
+            case 'activate':
+                return `
+// Activate lasso selection
+(async function() {
+  ${guard}
+  try {
+    await app.imageTools.activateLasso(${JSON.stringify(input.itemId || '')});
+    return { success: true, action: 'activate', itemId: ${JSON.stringify(input.itemId || '')} };
+  } catch (e) {
+    return { error: 'Failed to activate lasso: ' + e.message };
+  }
+})();`.trim();
+            case 'apply':
+                return `
+// Apply lasso selection
+(async function() {
+  ${guard}
+  try {
+    const result = await app.imageTools.applyLasso();
+    return { success: true, action: 'apply' };
+  } catch (e) {
+    return { error: 'Failed to apply lasso: ' + e.message };
+  }
+})();`.trim();
+            default:
+                return `(function() { return { error: 'Unknown lasso action: ${input.action}' }; })();`;
+        }
+    }
+    generateCutoutStyle(input) {
+        const guard = `if (!app.imageTools) return { error: 'ImageTools not available' };`;
+        switch (input.action) {
+            case 'apply':
+                return `
+// Apply cutout style
+(async function() {
+  ${guard}
+  try {
+    const result = await app.imageTools.applyCutoutStyle(${JSON.stringify(input.itemId || '')}, ${JSON.stringify(input.preset || '')}, ${JSON.stringify(input.options || {})});
+    return { success: true, action: 'apply', itemId: ${JSON.stringify(input.itemId || '')}, preset: ${JSON.stringify(input.preset || '')} };
+  } catch (e) {
+    return { error: 'Failed to apply cutout style: ' + e.message };
+  }
+})();`.trim();
+            case 'list':
+                return `
+// List available cutout styles
+(function() {
+  ${guard}
+  const styles = app.imageTools.getCutoutStyles();
+  return { success: true, action: 'list', styles };
+})();`.trim();
+            default:
+                return `(function() { return { error: 'Unknown cutout_style action: ${input.action}' }; })();`;
+        }
+    }
+    // ===========================================================================
+    // COMPOSITION & VIEW
+    // ===========================================================================
+    generatePrecomp(input) {
+        switch (input.action) {
+            case 'create': {
+                const opts = {};
+                if (input.name)
+                    opts.name = input.name;
+                if (input.loop !== undefined)
+                    opts.loop = input.loop;
+                if (input.duration !== undefined)
+                    opts.duration = input.duration;
+                return `
+// Create precomp from items
+(function() {
+  const itemIds = ${JSON.stringify(input.itemIds || [])};
+  const opts = ${JSON.stringify(opts)};
+  const precomp = app.createPrecomp(itemIds, opts);
+  return { success: true, action: 'create', precompId: precomp?.id || precomp, name: ${JSON.stringify(input.name || '')} };
+})();`.trim();
+            }
+            case 'add':
+                return `
+// Add item to precomp
+(function() {
+  app.addToPrecomp(${JSON.stringify(input.precompId || '')}, ${JSON.stringify(input.itemId || '')});
+  return { success: true, action: 'add', precompId: ${JSON.stringify(input.precompId || '')}, itemId: ${JSON.stringify(input.itemId || '')} };
+})();`.trim();
+            case 'remove':
+                return `
+// Remove item from precomp
+(function() {
+  app.removeFromPrecomp(${JSON.stringify(input.precompId || '')}, ${JSON.stringify(input.itemId || '')});
+  return { success: true, action: 'remove', precompId: ${JSON.stringify(input.precompId || '')}, itemId: ${JSON.stringify(input.itemId || '')} };
+})();`.trim();
+            default:
+                return `(function() { return { error: 'Unknown precomp action: ${input.action}' }; })();`;
+        }
+    }
+    generateView(input) {
+        switch (input.action) {
+            case 'fit': {
+                const mode = input.mode || 'content';
+                const padding = input.padding ?? 20;
+                return `
+// Fit view to ${mode}
+(function() {
+  app.fitView('${mode}', ${padding});
+  return { success: true, action: 'fit', mode: '${mode}', padding: ${padding} };
+})();`.trim();
+            }
+            case 'get_state':
+                return `
+// Get current view state
+(function() {
+  const state = app.getViewState();
+  return { success: true, action: 'get_state', ...state };
+})();`.trim();
+            default:
+                return `(function() { return { error: 'Unknown view action: ${input.action}' }; })();`;
+        }
+    }
+    generateBackground(input) {
+        switch (input.action) {
+            case 'set': {
+                const mode = input.mode || 'color';
+                if (mode === 'generator') {
+                    return `
+// Set background via generator
+(async function() {
+  try {
+    await app.executeGenerator(${JSON.stringify(input.generator || '')}, ${JSON.stringify(input.generatorParams || {})});
+    return { success: true, action: 'set', mode: 'generator', generator: ${JSON.stringify(input.generator || '')} };
+  } catch (e) {
+    return { error: 'Failed to set generator background: ' + e.message };
+  }
+})();`.trim();
+                }
+                if (mode === 'pattern') {
+                    return `
+// Set background pattern
+(function() {
+  app.setBackgroundPattern(${JSON.stringify(input.pattern || '')});
+  return { success: true, action: 'set', mode: 'pattern', pattern: ${JSON.stringify(input.pattern || '')} };
+})();`.trim();
+                }
+                // default: color
+                return `
+// Set background color
+(function() {
+  app.setBackgroundColor(${JSON.stringify(input.color || '#ffffff')});
+  return { success: true, action: 'set', mode: 'color', color: ${JSON.stringify(input.color || '#ffffff')} };
+})();`.trim();
+            }
+            case 'clear':
+                return `
+// Clear background
+(function() {
+  app.clearBackground();
+  return { success: true, action: 'clear' };
+})();`.trim();
+            case 'get':
+                return `
+// Get background info
+(function() {
+  const bg = app.getBackground();
+  return { success: true, action: 'get', ...bg };
+})();`.trim();
+            default:
+                return `(function() { return { error: 'Unknown background action: ${input.action}' }; })();`;
+        }
+    }
+    // ===========================================================================
+    // CANVAS QUERIES
+    // ===========================================================================
+    generateQuery(input) {
+        switch (input.action) {
+            case 'get_by_id':
+                return `
+// Get item details by ID
+(function() {
+  const entry = app.itemRegistry.get(${JSON.stringify(input.itemId || '')});
+  if (!entry || !entry.item) return { error: 'Item not found: ${input.itemId}' };
+  const item = entry.item;
+  return {
+    success: true, action: 'get_by_id',
+    itemId: ${JSON.stringify(input.itemId || '')},
+    type: item.data?.itemType || item.className,
+    position: { x: item.position.x, y: item.position.y },
+    bounds: item.bounds ? { x: item.bounds.x, y: item.bounds.y, width: item.bounds.width, height: item.bounds.height } : null,
+    visible: item.visible,
+    opacity: item.opacity,
+    rotation: item.rotation,
+    selected: item.selected,
+  };
+})();`.trim();
+            case 'hit_test': {
+                const tolerance = input.tolerance ?? 5;
+                const all = input.all ?? false;
+                return `
+// Hit test at point
+(function() {
+  const point = new paper.Point(${input.x ?? 0}, ${input.y ?? 0});
+  ${all
+                    ? `const results = app.hitTestAll(point, { tolerance: ${tolerance} });
+  const hits = results.map(r => ({
+    itemId: r.item?.data?.itemId || r.item?.name || r.item?.id,
+    type: r.item?.data?.itemType || r.item?.className,
+    point: { x: r.point?.x, y: r.point?.y }
+  }));
+  return { success: true, action: 'hit_test', x: ${input.x ?? 0}, y: ${input.y ?? 0}, hits, count: hits.length };`
+                    : `const result = app.hitTest(point, { tolerance: ${tolerance} });
+  if (!result) return { success: true, action: 'hit_test', x: ${input.x ?? 0}, y: ${input.y ?? 0}, hit: null };
+  return {
+    success: true, action: 'hit_test',
+    x: ${input.x ?? 0}, y: ${input.y ?? 0},
+    hit: { itemId: result.item?.data?.itemId || result.item?.name || result.item?.id, type: result.item?.data?.itemType || result.item?.className }
+  };`}
+})();`.trim();
+            }
+            case 'is_empty':
+                return `
+// Check if canvas is empty
+(function() {
+  const items = app.itemRegistry.getAll();
+  return { success: true, action: 'is_empty', empty: items.length === 0, count: items.length };
+})();`.trim();
+            default:
+                return `(function() { return { error: 'Unknown query action: ${input.action}' }; })();`;
+        }
+    }
+    // ===========================================================================
+    // DEFORMATION
+    // ===========================================================================
+    generateDeform(input) {
+        const guard = `if (!app.deformPresets) return { error: 'DeformPresets not available' };`;
+        switch (input.action) {
+            case 'apply': {
+                if (!input.itemId)
+                    return `(function() { return { error: 'itemId is required for deform apply' }; })();`;
+                if (!input.preset)
+                    return `(function() { return { error: 'preset is required for deform apply' }; })();`;
+                const params = {};
+                if (input.frequency !== undefined)
+                    params.frequency = input.frequency;
+                if (input.amplitude !== undefined)
+                    params.amplitude = input.amplitude;
+                if (input.phase)
+                    params.phase = input.phase;
+                if (input.loop !== undefined)
+                    params.loop = input.loop;
+                if (input.axis)
+                    params.axis = input.axis;
+                if (input.turns !== undefined)
+                    params.turns = input.turns;
+                if (input.waves !== undefined)
+                    params.waves = input.waves;
+                if (input.maxDisplacement !== undefined)
+                    params.maxDisplacement = input.maxDisplacement;
+                if (input.speed !== undefined)
+                    params.speed = input.speed;
+                if (input.steps !== undefined)
+                    params.steps = input.steps;
+                const itemIdStr = JSON.stringify(input.itemId);
+                return `
+// Apply deformation preset
+(function() {
+  ${guard}
+  const entry = app.itemRegistry.get(${itemIdStr});
+  if (!entry || !entry.item) return { error: 'Item not found: ' + ${itemIdStr} };
+  app.deformPresets.apply(entry.item, '${input.preset}', ${JSON.stringify(params)});
+  return { success: true, action: 'apply', itemId: ${itemIdStr}, preset: '${input.preset}' };
+})();`.trim();
+            }
+            case 'trigger': {
+                if (!input.itemId)
+                    return `(function() { return { error: 'itemId is required for deform trigger' }; })();`;
+                if (!input.preset)
+                    return `(function() { return { error: 'preset is required for deform trigger' }; })();`;
+                const params = {};
+                if (input.amplitude !== undefined)
+                    params.amplitude = input.amplitude;
+                if (input.speed !== undefined)
+                    params.speed = input.speed;
+                const itemIdStr = JSON.stringify(input.itemId);
+                return `
+// Trigger one-shot deformation
+(function() {
+  ${guard}
+  const entry = app.itemRegistry.get(${itemIdStr});
+  if (!entry || !entry.item) return { error: 'Item not found: ' + ${itemIdStr} };
+  app.deformPresets.trigger(entry.item, '${input.preset}', ${JSON.stringify(params)});
+  return { success: true, action: 'trigger', itemId: ${itemIdStr}, preset: '${input.preset}' };
+})();`.trim();
+            }
+            case 'remove': {
+                if (!input.itemId)
+                    return `(function() { return { error: 'itemId is required for deform remove' }; })();`;
+                const itemIdStr = JSON.stringify(input.itemId);
+                return `
+// Remove deformation and restore geometry
+(function() {
+  ${guard}
+  const entry = app.itemRegistry.get(${itemIdStr});
+  if (!entry || !entry.item) return { error: 'Item not found: ' + ${itemIdStr} };
+  app.deformPresets.remove(entry.item);
+  return { success: true, action: 'remove', itemId: ${itemIdStr} };
+})();`.trim();
+            }
+            default:
+                return `(function() { return { error: 'Unknown deform action: ${input.action}' }; })();`;
+        }
+    }
+    // ===========================================================================
+    // SPRITE SHEETS
+    // ===========================================================================
+    generateSpriteSheet(input) {
+        const guard = `if (!app.spriteSheetSystem) return { error: 'SpriteSheetSystem not available' };`;
+        switch (input.action) {
+            case 'generate': {
+                const opts = {};
+                if (input.poses)
+                    opts.poses = input.poses;
+                if (input.transition)
+                    opts.transition = input.transition;
+                if (input.bakedAnimation)
+                    opts.bakedAnimation = input.bakedAnimation;
+                if (input.animations)
+                    opts.animations = input.animations;
+                if (input.padding !== undefined)
+                    opts.padding = input.padding;
+                if (input.name)
+                    opts.name = input.name;
+                return `
+// Generate sprite sheet from skeleton
+(async function() {
+  ${guard}
+  const sheet = await app.spriteSheetSystem.generateSpriteSheet(${JSON.stringify(input.skeletonId || '')}, ${JSON.stringify(opts)});
+  return { success: true, action: 'generate', spriteSheetId: sheet.id, name: sheet.name, width: sheet.atlasWidth, height: sheet.atlasHeight, frameCount: sheet.frames?.size ?? sheet.frames?.length ?? 0 };
+})();`.trim();
+            }
+            case 'play': {
+                const opts = {};
+                if (input.x !== undefined)
+                    opts.x = input.x;
+                if (input.y !== undefined)
+                    opts.y = input.y;
+                if (input.animation)
+                    opts.animation = input.animation;
+                if (input.fps !== undefined)
+                    opts.fps = input.fps;
+                if (input.scale !== undefined)
+                    opts.scale = input.scale;
+                return `
+// Play sprite sheet animation
+(async function() {
+  ${guard}
+  const player = await app.spriteSheetSystem.playSpriteSheet(${JSON.stringify(input.spriteSheetId || '')}, ${JSON.stringify(opts)});
+  return { success: true, action: 'play', playerId: player.id };
+})();`.trim();
+            }
+            case 'export':
+                return `
+// Export sprite sheet
+(async function() {
+  ${guard}
+  const result = await app.spriteSheetSystem.exportSpriteSheet(${JSON.stringify(input.spriteSheetId || '')}, { format: '${input.format || 'png'}', download: true, includeMetadata: true });
+  return { success: true, action: 'export', format: '${input.format || 'png'}' };
+})();`.trim();
+            default:
+                return `(function() { return { error: 'Unknown sprite sheet action: ${input.action}' }; })();`;
+        }
+    }
+    // ===========================================================================
+    // STORAGE
+    // ===========================================================================
+    generateStorage(input) {
+        const guard = `if (!app.storageManager) return { error: 'StorageManager not available' };`;
+        switch (input.action) {
+            case 'save': {
+                const name = input.name ? JSON.stringify(input.name) : "'Untitled Project'";
+                const thumbnailCode = input.thumbnail
+                    ? `const thumbnail = app.exportThumbnail ? app.exportThumbnail() : null;\n  if (thumbnail) project.thumbnail = thumbnail;`
+                    : '';
+                return `
+// Save project
+(async function() {
+  ${guard}
+  const project = { name: ${name}, data: app.serialize() };
+  ${thumbnailCode}
+  const projectId = await app.storageManager.saveProject(project);
+  return { success: true, action: 'save', projectId, name: ${name} };
+})();`.trim();
+            }
+            case 'load': {
+                const projId = JSON.stringify(input.projectId || '');
+                return `
+// Load project
+(async function() {
+  ${guard}
+  const project = await app.storageManager.loadProject(${projId});
+  if (!project) return { error: 'Project not found: ' + ${projId} };
+  app.deserialize(project.data);
+  return { success: true, action: 'load', projectId: ${projId}, name: project.name };
+})();`.trim();
+            }
+            case 'list':
+                return `
+// List saved projects
+(async function() {
+  ${guard}
+  const projects = await app.storageManager.listProjects();
+  return { success: true, action: 'list', projects: projects.map(p => ({ id: p.id, name: p.name, updatedAt: p.updatedAt })), count: projects.length };
+})();`.trim();
+            case 'delete': {
+                const projId = JSON.stringify(input.projectId || '');
+                return `
+// Delete project
+(async function() {
+  ${guard}
+  await app.storageManager.deleteProject(${projId});
+  return { success: true, action: 'delete', projectId: ${projId} };
+})();`.trim();
+            }
+            default:
+                return `(function() { return { error: 'Unknown storage action: ${input.action}' }; })();`;
+        }
+    }
+    // ===========================================================================
+    // INTERACTION
+    // ===========================================================================
+    generateInteraction(input) {
+        const guard = `if (!app.interactionSystem) return { error: 'InteractionSystem not available' };`;
+        switch (input.action) {
+            case 'add_behavior': {
+                const itemIdStr = JSON.stringify(input.itemId || '');
+                const params = JSON.stringify(input.params || {});
+                return `
+// Add behavior to item
+(function() {
+  ${guard}
+  const entry = app.itemRegistry.get(${itemIdStr});
+  if (!entry || !entry.item) return { error: 'Item not found: ' + ${itemIdStr} };
+  const behaviorId = app.interactionSystem.addContinuousBehavior(entry.item, '${input.behaviorType}', ${params});
+  return { success: true, action: 'add_behavior', itemId: ${itemIdStr}, behaviorType: '${input.behaviorType}', behaviorId };
+})();`.trim();
+            }
+            case 'remove_behavior': {
+                const itemIdStr = JSON.stringify(input.itemId || '');
+                const behaviorIdStr = JSON.stringify(input.behaviorId || '');
+                return `
+// Remove behavior from item
+(function() {
+  ${guard}
+  const entry = app.itemRegistry.get(${itemIdStr});
+  if (!entry || !entry.item) return { error: 'Item not found: ' + ${itemIdStr} };
+  app.interactionSystem.removeContinuousBehavior(entry.item, ${behaviorIdStr});
+  return { success: true, action: 'remove_behavior', itemId: ${itemIdStr}, behaviorId: ${behaviorIdStr} };
+})();`.trim();
+            }
+            case 'trigger_action': {
+                const params = JSON.stringify(input.params || {});
+                return `
+// Trigger interaction action
+(function() {
+  ${guard}
+  app.interactionSystem.triggerAction('${input.actionType}', ${params});
+  return { success: true, action: 'trigger_action', actionType: '${input.actionType}' };
+})();`.trim();
+            }
+            case 'get_state':
+                return `
+// Get interaction state
+(function() {
+  ${guard}
+  const state = app.interactionSystem.getState ? app.interactionSystem.getState() : {};
+  return { success: true, action: 'get_state', ...state };
+})();`.trim();
+            default:
+                return `(function() { return { error: 'Unknown interaction action: ${input.action}' }; })();`;
+        }
+    }
+    // ===========================================================================
+    // WIDGET EXPORT
+    // ===========================================================================
+    generateExportWidget(input) {
+        const opts = {};
+        if (input.download !== undefined)
+            opts.download = input.download;
+        if (input.filename)
+            opts.filename = input.filename;
+        if (input.includeInteractions !== undefined)
+            opts.includeInteractions = input.includeInteractions;
+        if (input.minify !== undefined)
+            opts.minify = input.minify;
+        return `
+// Export widget (pp:PinePaper ontology JSON)
+(async function() {
+  if (!app.exportWidget) return { error: 'Widget export not available' };
+  const result = await app.exportWidget(${JSON.stringify(opts)});
+  return { success: true, json: result.json, filename: result.filename, embedCode: result.embedCode, metadata: result.data?.metadata };
+})();`.trim();
+    }
+    generateExportWidgetHtml(input) {
+        const opts = {};
+        if (input.title)
+            opts.title = input.title;
+        if (input.download !== undefined)
+            opts.download = input.download;
+        return `
+// Export widget as self-contained HTML
+(async function() {
+  if (!app.exportWidgetHTML) return { error: 'Widget HTML export not available' };
+  const result = await app.exportWidgetHTML(${JSON.stringify(opts)});
+  return { success: true, html: result.html, estimatedSize: result.estimatedSize, analysis: { itemTypes: [...result.analysis.itemTypes], relationTypes: [...result.analysis.relationTypes], hasSimpleAnimations: result.analysis.hasSimpleAnimations, hasKeyframeAnimations: result.analysis.hasKeyframeAnimations, hasMasks: result.analysis.hasMasks } };
+})();`.trim();
+    }
+    // ===========================================================================
+    // DATA VISUALIZATION (CHARTS)
+    // ===========================================================================
+    generateChart(input) {
+        const guard = `if (!app.chartSystem) return { error: 'ChartSystem not available' };`;
+        switch (input.action) {
+            case 'create': {
+                if (!input.chartType)
+                    return `(function() { return { error: 'chartType is required for create' }; })();`;
+                if (!input.data)
+                    return `(function() { return { error: 'data is required for create' }; })();`;
+                const dataStr = JSON.stringify(input.data);
+                const optsStr = JSON.stringify(input.options || {});
+                return `
+// Create chart
+(function() {
+  ${guard}
+  const group = app.createChart(${JSON.stringify(input.chartType)}, ${dataStr}, ${optsStr});
+  if (!group) return { error: 'Failed to create chart' };
+  const chartId = app.chartSystem.getLastChartId();
+  return { success: true, action: 'create', chartType: ${JSON.stringify(input.chartType)}, chartId, dataPoints: ${input.data.length} };
+})();`.trim();
+            }
+            case 'update': {
+                if (!input.chartId)
+                    return `(function() { return { error: 'chartId is required for update' }; })();`;
+                const chartIdStr = JSON.stringify(input.chartId);
+                const dataStr = JSON.stringify(input.data || []);
+                const optsStr = JSON.stringify(input.options || {});
+                return `
+// Update chart data
+(function() {
+  ${guard}
+  const chart = app.chartSystem.getChart(${chartIdStr});
+  if (!chart) return { error: 'Chart not found: ' + ${chartIdStr} };
+  app.chartSystem.update(${chartIdStr}, ${dataStr}, ${optsStr});
+  return { success: true, action: 'update', chartId: ${chartIdStr} };
+})();`.trim();
+            }
+            case 'reconfigure': {
+                if (!input.chartId)
+                    return `(function() { return { error: 'chartId is required for reconfigure' }; })();`;
+                const chartIdStr = JSON.stringify(input.chartId);
+                const optsStr = JSON.stringify(input.options || {});
+                return `
+// Reconfigure chart styling
+(function() {
+  ${guard}
+  const chart = app.chartSystem.getChart(${chartIdStr});
+  if (!chart) return { error: 'Chart not found: ' + ${chartIdStr} };
+  app.chartSystem.reconfigure(${chartIdStr}, ${optsStr});
+  return { success: true, action: 'reconfigure', chartId: ${chartIdStr} };
+})();`.trim();
+            }
+            case 'remove': {
+                if (!input.chartId)
+                    return `(function() { return { error: 'chartId is required for remove' }; })();`;
+                const chartIdStr = JSON.stringify(input.chartId);
+                return `
+// Remove chart
+(function() {
+  ${guard}
+  app.chartSystem.remove(${chartIdStr});
+  return { success: true, action: 'remove', chartId: ${chartIdStr} };
+})();`.trim();
+            }
+            default:
+                return `(function() { return { error: 'Unknown chart action: ${input.action}' }; })();`;
+        }
+    }
+    // ===========================================================================
+    // MAGIC SYSTEM
+    // ===========================================================================
+    generateMagic(input) {
+        const guard = `if (!app.magicSystem) return { error: 'MagicSystem not available' };`;
+        switch (input.action) {
+            case 'animate': {
+                const opts = {};
+                if (input.mood)
+                    opts.energy = input.mood;
+                if (input.selectionOnly !== undefined)
+                    opts.selectionOnly = input.selectionOnly;
+                return `
+// Magic auto-animate
+(async function() {
+  ${guard}
+  const result = await app.magicSystem.autoAnimate(${JSON.stringify(opts)});
+  return { success: true, action: 'animate', itemsAnimated: result.count, mood: result.energy, type: result.type };
+})();`.trim();
+            }
+            case 'remix': {
+                const opts = {};
+                if (input.selectionOnly !== undefined)
+                    opts.selectionOnly = input.selectionOnly;
+                return `
+// Magic style remix
+(async function() {
+  ${guard}
+  const result = await app.magicSystem.remixStyle(${JSON.stringify(opts)});
+  return { success: true, action: 'remix', itemsRemixed: result.count, palette: result.palette };
+})();`.trim();
+            }
+            default:
+                return `(function() { return { error: 'Unknown magic action: ${input.action}' }; })();`;
+        }
+    }
+    // ===========================================================================
+    // PHYSICS (RIGID BODY SIMULATION)
+    // ===========================================================================
+    generatePhysics(input) {
+        const guard = `if (!app.physicsWorld) return { error: 'PhysicsWorld not available' };`;
+        switch (input.action) {
+            case 'init': {
+                const gravity = JSON.stringify(input.gravity || { x: 0, y: 980 });
+                return `
+// Initialize physics world
+(function() {
+  ${guard}
+  app.physicsWorld.init({ gravity: ${gravity} });
+  return { success: true, action: 'init', gravity: ${gravity} };
+})();`.trim();
+            }
+            case 'add_body': {
+                if (!input.itemId)
+                    return `(function() { return { error: 'itemId is required for add_body' }; })();`;
+                const itemIdStr = JSON.stringify(input.itemId);
+                const config = {};
+                if (input.bodyType)
+                    config.type = input.bodyType;
+                if (input.mass !== undefined)
+                    config.mass = input.mass;
+                if (input.friction !== undefined)
+                    config.friction = input.friction;
+                if (input.restitution !== undefined)
+                    config.restitution = input.restitution;
+                if (input.fixedRotation !== undefined)
+                    config.fixedRotation = input.fixedRotation;
+                if (input.shape)
+                    config.shape = input.shape;
+                return `
+// Add physics body
+(function() {
+  ${guard}
+  const entry = app.itemRegistry.get(${itemIdStr});
+  if (!entry || !entry.item) return { error: 'Item not found: ' + ${itemIdStr} };
+  const ok = app.physicsWorld.addBody(${itemIdStr}, ${JSON.stringify(config)});
+  return { success: ok, action: 'add_body', itemId: ${itemIdStr}, bodyType: ${JSON.stringify(input.bodyType || 'dynamic')} };
+})();`.trim();
+            }
+            case 'remove_body': {
+                if (!input.itemId)
+                    return `(function() { return { error: 'itemId is required for remove_body' }; })();`;
+                const itemIdStr = JSON.stringify(input.itemId);
+                return `
+// Remove physics body
+(function() {
+  ${guard}
+  app.physicsWorld.removeBody(${itemIdStr});
+  return { success: true, action: 'remove_body', itemId: ${itemIdStr} };
+})();`.trim();
+            }
+            case 'apply_force': {
+                if (!input.itemId)
+                    return `(function() { return { error: 'itemId is required for apply_force' }; })();`;
+                if (!input.force)
+                    return `(function() { return { error: 'force is required for apply_force' }; })();`;
+                const itemIdStr = JSON.stringify(input.itemId);
+                return `
+// Apply continuous force
+(function() {
+  ${guard}
+  app.physicsWorld.applyForce(${itemIdStr}, ${JSON.stringify(input.force)});
+  return { success: true, action: 'apply_force', itemId: ${itemIdStr}, force: ${JSON.stringify(input.force)} };
+})();`.trim();
+            }
+            case 'apply_impulse': {
+                if (!input.itemId)
+                    return `(function() { return { error: 'itemId is required for apply_impulse' }; })();`;
+                if (!input.impulse)
+                    return `(function() { return { error: 'impulse is required for apply_impulse' }; })();`;
+                const itemIdStr = JSON.stringify(input.itemId);
+                return `
+// Apply instant impulse
+(function() {
+  ${guard}
+  app.physicsWorld.applyImpulse(${itemIdStr}, ${JSON.stringify(input.impulse)});
+  return { success: true, action: 'apply_impulse', itemId: ${itemIdStr}, impulse: ${JSON.stringify(input.impulse)} };
+})();`.trim();
+            }
+            case 'set_velocity': {
+                if (!input.itemId)
+                    return `(function() { return { error: 'itemId is required for set_velocity' }; })();`;
+                if (!input.velocity)
+                    return `(function() { return { error: 'velocity is required for set_velocity' }; })();`;
+                const itemIdStr = JSON.stringify(input.itemId);
+                return `
+// Set body velocity
+(function() {
+  ${guard}
+  app.physicsWorld.setVelocity(${itemIdStr}, ${JSON.stringify(input.velocity)});
+  return { success: true, action: 'set_velocity', itemId: ${itemIdStr}, velocity: ${JSON.stringify(input.velocity)} };
+})();`.trim();
+            }
+            case 'get_state': {
+                if (!input.itemId)
+                    return `(function() { return { error: 'itemId is required for get_state' }; })();`;
+                const itemIdStr = JSON.stringify(input.itemId);
+                return `
+// Get physics body state
+(function() {
+  ${guard}
+  const state = app.physicsWorld.getBodyState(${itemIdStr});
+  if (!state) return { error: 'No physics body for item: ' + ${itemIdStr} };
+  return { success: true, action: 'get_state', itemId: ${itemIdStr}, ...state };
+})();`.trim();
+            }
+            case 'create_ground': {
+                const y = input.y !== undefined ? input.y : 500;
+                const w = input.width !== undefined ? input.width : 2000;
+                return `
+// Create ground plane
+(function() {
+  ${guard}
+  const groundId = app.physicsWorld.createGround(${y}, ${w});
+  return { success: true, action: 'create_ground', groundId, y: ${y}, width: ${w} };
+})();`.trim();
+            }
+            case 'create_joint': {
+                if (!input.itemId)
+                    return `(function() { return { error: 'itemId is required for create_joint' }; })();`;
+                if (!input.targetItemId)
+                    return `(function() { return { error: 'targetItemId is required for create_joint' }; })();`;
+                if (!input.jointType)
+                    return `(function() { return { error: 'jointType is required for create_joint' }; })();`;
+                const itemIdStr = JSON.stringify(input.itemId);
+                const targetStr = JSON.stringify(input.targetItemId);
+                const params = JSON.stringify({ type: input.jointType, ...(input.jointParams || {}) });
+                return `
+// Create physics joint
+(function() {
+  ${guard}
+  const joint = app.physicsWorld.createJoint(${itemIdStr}, ${targetStr}, ${params});
+  if (!joint) return { error: 'Failed to create joint between ' + ${itemIdStr} + ' and ' + ${targetStr} };
+  return { success: true, action: 'create_joint', itemId: ${itemIdStr}, targetItemId: ${targetStr}, jointType: ${JSON.stringify(input.jointType)} };
+})();`.trim();
+            }
+            default:
+                return `(function() { return { error: 'Unknown physics action: ${input.action}' }; })();`;
+        }
+    }
+    // ===========================================================================
+    // MEASUREMENT SYSTEM
+    // ===========================================================================
+    generateMeasurement(input) {
+        const guard = `if (!app.measurementSystem) return { error: 'MeasurementSystem not available' };`;
+        switch (input.action) {
+            case 'set_rulers': {
+                const enabled = input.enabled !== false;
+                return `
+// Toggle rulers
+(function() {
+  ${guard}
+  app.measurementSystem.setRulersVisible(${enabled});
+  return { success: true, action: 'set_rulers', enabled: ${enabled} };
+})();`.trim();
+            }
+            case 'set_grid': {
+                const enabled = input.enabled !== false;
+                return `
+// Toggle grid
+(function() {
+  ${guard}
+  app.measurementSystem.setGridVisible(${enabled});
+  return { success: true, action: 'set_grid', enabled: ${enabled} };
+})();`.trim();
+            }
+            // No measurementSystem guard — reads from itemRegistry directly
+            case 'get_dimensions': {
+                if (!input.itemId)
+                    return `(function() { return { error: 'itemId is required for get_dimensions' }; })();`;
+                const itemIdStr = JSON.stringify(input.itemId);
+                return `
+// Get item dimensions
+(function() {
+  const entry = app.itemRegistry.get(${itemIdStr});
+  if (!entry || !entry.item) return { error: 'Item not found: ' + ${itemIdStr} };
+  const b = entry.item.bounds;
+  return { success: true, action: 'get_dimensions', itemId: ${itemIdStr}, x: b.x, y: b.y, width: b.width, height: b.height, rotation: entry.item.rotation || 0 };
+})();`.trim();
+            }
+            case 'set_snap': {
+                const enabled = input.enabled !== false;
+                return `
+// Toggle snap to grid
+(function() {
+  ${guard}
+  app.measurementSystem.setSnapToUnitEnabled(${enabled});
+  return { success: true, action: 'set_snap', enabled: ${enabled} };
+})();`.trim();
+            }
+            default:
+                return `(function() { return { error: 'Unknown measurement action: ${input.action}' }; })();`;
+        }
+    }
 }
 // Export singleton instance
 export const codeGenerator = new PinePaperCodeGenerator();