@pinepaper.studio/mcp-server 1.5.3 → 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();
 }
 /**
@@ -582,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
@@ -628,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
@@ -748,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();
     }
     /**
@@ -1346,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() {
@@ -1378,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,
@@ -1390,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` : ''}
   };
 })();
 `;
@@ -1800,7 +1940,7 @@ 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 (bitrate in bps for VideoEncoder)
         const qualitySettings = {
@@ -1830,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) {
@@ -1881,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, bitrate: settings.bitrate, 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, bitrate: settings.bitrate, 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' };
         }
@@ -2345,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)};
@@ -2360,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();
     }
@@ -4094,6 +4292,596 @@ ${mask ? `    app.imageTools.applyMask(raster, '${mask}');\n` : ''}    const ite
                 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();