@pinepaper.studio/mcp-server 1.6.10 → 1.6.11

package/dist/types/code-generator.js

@@ -181,12 +181,27 @@ app.historyManager.saveState();
  */
 function generateModifyItemCode(itemId, properties) {
     const { contentType, contentFormat, countdownTarget, countdownEndText, ...restProperties } = properties;
+    // modifyItem(id, changes), NOT select() + modify().
+    //
+    // modify() operates on the SELECTION, so this selected an id and then edited
+    // whatever was selected — on an id that does not resolve, select changes
+    // nothing and modify edits the PREVIOUS selection instead. modifyItem takes
+    // the reference and returns false when it cannot resolve it, which is the
+    // answer this emitter needs and never asked for.
+    //
+    // The warning the engine logs on that path is console.warn, which production
+    // strips, so the failure was invisible twice over.
     let code = `
 // Modify item ${itemId}
-app.select('${itemId}');`;
-    // Pass non-dynamic-content properties to app.modify
+let _modified = true;`;
     if (Object.keys(restProperties).length > 0) {
-        code += `\napp.modify(${JSON.stringify(restProperties, null, 2)});`;
+        code += `
+_modified = app.modifyItem('${itemId}', ${JSON.stringify(restProperties, null, 2)}) !== false;
+if (!_modified) { return { success: false, error: 'no item ${itemId} — nothing was modified' }; }`;
+    }
+    else {
+        code += `
+if (!app.getItemById('${itemId}')) { return { success: false, error: 'no item ${itemId}' }; }`;
     }
     // Handle dynamic content type changes
     if (contentType !== undefined) {
@@ -212,10 +227,10 @@ if (entry && entry.item && app.setDynamicContent) app.setDynamicContent(entry.it
     }
     code += `
 app.historyManager.saveState();
-
-// Return success
-({ success: true, itemId: '${itemId}' });`;
-    return code.trim();
+return { success: true, itemId: '${itemId}' };`;
+    // Wrapped, because the body now RETURNS early on a miss rather than falling
+    // through to an unconditional success.
+    return `(function() {\n${code.trim()}\n})();`;
 }
 /**
  * Template for deleting items
@@ -675,9 +690,24 @@ function generateSetCanvasSizeCode(width, height, preset) {
         : `{ width: ${width}, height: ${height} }`;
     return `
 // Set canvas size
-app.setCanvasSize(${sizeArg});
-app.historyManager.saveState();
-({ success: true, width: ${width}, height: ${height} });
+(function() {
+  // READ THE VERDICT. This called setCanvasSize and then declared success with
+  // the dimensions it had ASKED for — so an unknown preset, or a width of -5,
+  // came back as a successful resize while the canvas was left exactly as it
+  // was. The engine now refuses by name; older builds return undefined, which
+  // is not a refusal and must not be read as one.
+  const r = app.setCanvasSize(${sizeArg});
+  if (r && r.ok === false) {
+    return { success: false, error: r.reason || 'the canvas size was refused',
+      ...(r.known ? { knownPresets: r.known } : {}) };
+  }
+  app.historyManager.saveState();
+  // Report what the canvas ACTUALLY took where the engine says so, rather than
+  // echoing the request back.
+  return { success: true, width: (r && r.width) || ${width}, height: (r && r.height) || ${height},
+    ...(r && r.preset ? { preset: r.preset } : {}),
+    ...(r && r.unbounded !== undefined ? { unbounded: r.unbounded } : {}) };
+})();
 `.trim();
 }
 /**
@@ -1220,19 +1250,33 @@ export class PinePaperCodeGenerator {
         if (url) {
             return `
 // Import SVG from URL${source === 'figma' ? ' (Figma-normalised)' : ''}
-const response = await fetch('${url}');
-const svgText = await response.text();
-const _r = ${importExpr('svgText')};
-const imported = _r.item;
-if (imported) {
+// WRAPPED, because these were bare top-level statements with an await. That
+// parses under the governor, which builds an AsyncFunction, and is a SYNTAX
+// ERROR on the eval fallback — so importing an SVG by URL never ran at all on
+// a studio without runGenerated. A paren-led async IIFE parses on both and
+// still gives the governor a trailing expression to capture.
+(async function() {
+  let response;
+  try {
+    response = await fetch('${url}');
+  } catch (netErr) {
+    return { success: false, error: 'could not reach ${url} — ' + ((netErr && netErr.message) || 'network request failed') };
+  }
+  if (!response.ok) {
+    return { success: false, error: 'the server refused ${url} — HTTP ' + response.status + ' ' + (response.statusText || ''), status: response.status };
+  }
+  const svgText = await response.text();
+  const _r = ${importExpr('svgText')};
+  const imported = _r.item;
+  if (!imported) {
+    return { success: false, error: 'the response from ${url} did not parse as SVG. Check the URL serves the file itself rather than a page around it.' };
+  }
   imported.position = new paper.Point(${position.x}, ${position.y});
   imported.scale(${scale});
   const itemId = app.registerItem(imported, 'svg-import', { source: 'mcp' });
   app.historyManager.saveState();
-  ({ success: true, itemId, changes: _r.changes, position: { x: ${position.x}, y: ${position.y} } });
-} else {
-  throw new Error('Failed to import SVG from URL');
-}
+  return { success: true, itemId, changes: _r.changes, position: { x: ${position.x}, y: ${position.y} } };
+})();
 `.trim();
         }
         if (svgString) {
@@ -2465,8 +2509,12 @@ return { itemId };
                 const modifyProps = JSON.stringify(op.properties || {});
                 return `
 const targetId = ${itemRef};
-app.select(targetId);
-app.modify(${modifyProps});
+// modifyItem(id, changes), not select() + modify(). modify() edits the
+// SELECTION, so an id that does not resolve left the PREVIOUS selection to be
+// edited instead — and this then reported modified:true either way.
+if (app.modifyItem(targetId, ${modifyProps}) === false) {
+  return { success: false, itemId: targetId, error: 'no item ' + targetId + ' — nothing was modified' };
+}
 return { itemId: targetId, modified: true };
 `;
             case 'animate':
@@ -2541,9 +2589,16 @@ return { success: true, generator: '${genName}'${op.generatorRegion ? ', region:
                 const h = op.height || 1080;
                 const sizeArg = op.preset ? `'${op.preset}'` : `{ width: ${w}, height: ${h} }`;
                 return `
-app.setCanvasSize(${sizeArg});
+// Read the verdict, as the standalone tool now does: an unknown preset or an
+// out-of-range dimension is refused by name, and reporting the size we ASKED
+// for left the batch claiming a resize that never happened.
+const _cs = app.setCanvasSize(${sizeArg});
+if (_cs && _cs.ok === false) {
+  return { success: false, error: _cs.reason || 'the canvas size was refused',
+    ...(_cs.known ? { knownPresets: _cs.known } : {}) };
+}
 await new Promise(r => setTimeout(r, 50));
-return { success: true, width: ${w}, height: ${h} };
+return { success: true, width: (_cs && _cs.width) || ${w}, height: (_cs && _cs.height) || ${h} };
 `;
             }
             case 'keyframe_animate': {
@@ -4071,7 +4126,7 @@ return { success: true, action: 'seek', time: ${op.time || 0} };
         // records the baked offset at item.data._bakedRotation and sums the two itself
         // (PinePaper.js does exactly this); read the same sum rather than the half of
         // it that happens to be zero.
-        const _rot = (item.data?._bakedRotation || 0) + (item.rotation || 0);
+        const _rot = typeof app.authoredRotation === 'function' ? app.authoredRotation(item) : ((item.data?._bakedRotation || 0) + (item.rotation || 0));
         if (_rot) itemData.properties.rotation = _rot;
         if (item.data?.content) itemData.properties.content = item.data.content;
         if (item.visible === false) itemData.properties.visible = false;
@@ -4433,6 +4488,33 @@ return { success: true, action: 'seek', time: ${op.time || 0} };
   }
 })();
 `.trim();
+    }
+    /**
+     * What THIS item can animate, from the engine's own table.
+     *
+     * The table is derived from the applier rather than written beside it, so it
+     * cannot drift from what actually gets applied — and it is filtered by item
+     * type, because the trim/dash four only exist on a path and a rectangle has
+     * no fontSize.
+     *
+     * `interpolates: false` is passed through VERBATIM and never flattened away.
+     * `content` and `blendMode` are DISCRETE — they hold their value until the
+     * next keyframe rather than blending toward it — and treating content as
+     * tweenable is what made every word in a cycler appear half a beat early.
+     * A list that says only "animatable" rebuilds that bug in the next agent.
+     */
+    generateListItemAnimatableProperties(itemId) {
+        return `
+// Animatable properties of ${JSON.stringify(itemId)}
+(function() {
+  if (typeof app.listAnimatableProperties !== 'function') {
+    return { success: false, error: 'app.listAnimatableProperties unavailable — update the studio. The keyframe tool lists the properties it accepts in its own description meanwhile.' };
+  }
+  const item = app.getItemById(${JSON.stringify(itemId)});
+  if (!item) { return { success: false, error: 'no item ${itemId}' }; }
+  const r = app.listAnimatableProperties(item);
+  return { success: true, ...r };
+})();`.trim();
     }
     generateGetAnimatableProperties() {
         return `
@@ -4829,7 +4911,21 @@ ${mask ? `    app.imageTools.applyMask(raster, '${mask}');\n` : ''}    // The RE
 // Toggle loop mode
 (function() {
   ${guard}
-  app.sceneManager.setLoop(${input.enabled ?? true});
+  // chainLoop is a PROPERTY, set by createChain({loop}) and read by the chain
+  // advance. setLoop has never existed, so this reported a toggle it had not
+  // performed — and a chain built without loop went on not looping.
+  if (typeof app.sceneManager.setLoop === 'function') {
+    app.sceneManager.setLoop(${input.enabled ?? true});
+  } else if ('chainLoop' in app.sceneManager) {
+    app.sceneManager.chainLoop = ${input.enabled ?? true};
+  } else {
+    return { success: false, action: 'toggle_loop',
+      error: 'this build has no chain-loop control to set. Pass loop:true to create_chain instead, which is where the setting is read from.' };
+  }
+  if (!app.sceneManager.sceneChain || !app.sceneManager.sceneChain.length) {
+    return { success: true, action: 'toggle_loop', enabled: ${input.enabled ?? true},
+      note: 'no chain exists yet — this setting applies to the next one created, and create_chain takes loop directly.' };
+  }
   return { success: true, action: 'toggle_loop', enabled: ${input.enabled ?? true} };
 })();
 `.trim();
@@ -5707,7 +5803,7 @@ ${resolve}
     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.data?._bakedRotation || 0) + (item.rotation || 0),
+    rotation: typeof app.authoredRotation === 'function' ? app.authoredRotation(item) : ((item.data?._bakedRotation || 0) + (item.rotation || 0)),
     selected: item.selected,
   };
 })();`.trim();
@@ -6481,7 +6577,7 @@ if (!app.spriteSystem) return { error: 'SpriteSheetSystem not available' };`;
   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.data?._bakedRotation || 0) + (entry.item.rotation || 0) };
+  return { success: true, action: 'get_dimensions', itemId: ${itemIdStr}, x: b.x, y: b.y, width: b.width, height: b.height, rotation: typeof app.authoredRotation === 'function' ? app.authoredRotation(entry.item) : ((entry.item.data?._bakedRotation || 0) + (entry.item.rotation || 0)) };
 })();`.trim();
             }
             case 'set_snap': {
@@ -6990,10 +7086,25 @@ ${guard}
                 });
                 return `
 // Display text style: ${input.styleKey} — stacked-layer title, id adopted from the text
-(function() {
+(async function() {
   if (typeof app.applyTextStyle !== 'function') { return { success: false, error: 'app.applyTextStyle unavailable — update FxTool to a text-styles build' }; }
+  // LOAD THE FACES FIRST. The decorative stylesheet is fetched on pointerenter
+  // over the style grid — a gesture no agent ever makes — so every decorative
+  // family was missing in production and a style asking for one silently drew
+  // the fallback and reported success. ensureFontsLoaded is the fix; guarded,
+  // because a studio without it behaves as it always did.
+  if (typeof app.ensureFontsLoaded === 'function') {
+    try { await app.ensureFontsLoaded('decorative'); } catch (_) { /* the pending flag below still reports it */ }
+  }
   const r = app.applyTextStyle(${S(input.itemId)}, ${S(input.styleKey)}, ${opts});
   if (!r || !r.ok) { return { success: false, error: (r && r.error) || 'style failed' }; }
+  // fontPending: the face is not there YET, so this drew in the fallback. Said
+  // out loud rather than left to be discovered in the export.
+  if (r.fontPending) {
+    return { success: true, action: 'apply_style', id: r.id, style: r.style, layers: r.layers,
+      palette: r.palette, bounds: r.bounds, fontPending: true,
+      warning: 'the face for this style had not loaded, so it drew in a FALLBACK font. Re-apply the style, or call pinepaper_font check with the family and your text to see what is really being used.' };
+  }
   // The styled group ADOPTS the text item's registry id — r.id is the SAME id
   // the caller passed, so their handle keeps working. Say so in the result.
   return { success: true, action: 'apply_style', id: r.id, style: r.style, layers: r.layers, palette: r.palette, bounds: r.bounds };