@pinepaper.studio/mcp-server 1.6.15 → 1.6.17

package/dist/types/code-generator.js

@@ -4,6 +4,7 @@
  * Converts MCP tool inputs to executable PinePaper JavaScript code.
  * This code is designed to run in the browser context where window.PinePaper is available.
  */
+import { normalizeSvgSize } from '../utils/svg-size.js';
 import { REQUIRED_ENGINE_METHODS, OPTIONAL_ENGINE_METHODS } from '../tools/engine-methods.js';
 import { ACCEPTED_CREATE_PARAMS, NORMALIZE_PARAM_READS, MODIFY_CHANGE_READS } from '../tools/shape-params.js';
 import { generateP5DrawCode } from '../tools/p5-compat/p5-helpers.js';
@@ -917,8 +918,15 @@ if (_flagged && _flagged.item && _flagged.item.data) Object.assign(_flagged.item
         + modIgnored.filter((k) => MODIFY_DID_YOU_MEAN[k]).map((k) => ` Did you mean ${MODIFY_DID_YOU_MEAN[k]} (not ${k})?`).join(''))}`;
     code += `
 app.historyManager.saveState();
+${properties.content !== undefined ? `
+// CONTENT UNDER A CONTENT TRACK (round 10, 10.13): the keyframes set the text
+// on every frame, so a direct edit is overwritten at once — it answered
+// success and changed nothing visible.
+const __ctItem = app.getItemById('${itemId}');
+const __ctKeys = (__ctItem && __ctItem.data && Array.isArray(__ctItem.data.keyframes))
+  ? __ctItem.data.keyframes.filter(function(k) { return k && k.properties && Object.prototype.hasOwnProperty.call(k.properties, 'content'); }).length : 0;` : ''}
 ${modDirection ? emitDirectionCheck(`app.getItemById('${itemId}')`, modDirection) : ''}${modTabular ? emitTabularCheck(`app.getItemById('${itemId}')`) : ''}${modStrokePos ? emitStrokePositionCheck(`app.getItemById('${itemId}')`, modStrokePos) : ''}
-return { success: true, itemId: '${itemId}'${modFit ? ', textFit: __textFit' : ''}${modDirection ? ', direction: __direction' : ''}${modTabular ? ', tabularFigures: __tabular' : ''}${modStrokePos ? ', strokePosition: __strokePos' : ''}${affine ? `, affine: ${JSON.stringify({ skewX, skewY, matrix, note: 'applied to the current shape: calling again compounds it. To undo, apply the inverse (negative skew, or the inverse matrix).' })}` : ''}${modLifetime ? ', lifetime: __lifetime' : ''}${modFont ? ', ...(__font ? { font: __font } : {})' : ''}${modWarning} };`;
+return { success: true, itemId: '${itemId}'${properties.content !== undefined ? `, ...(__ctKeys ? { contentTrackWarning: 'this text\\'s content is keyframed (' + __ctKeys + ' key(s)), so the track sets it on every frame and this edit does not show. Change the content keys with pinepaper_keyframe_animate (append: true replaces same-time keys), or animate another property.' } : {})` : ''}${modFit ? ', textFit: __textFit' : ''}${modDirection ? ', direction: __direction' : ''}${modTabular ? ', tabularFigures: __tabular' : ''}${modStrokePos ? ', strokePosition: __strokePos' : ''}${affine ? `, affine: ${JSON.stringify({ skewX, skewY, matrix, note: 'applied to the current shape: calling again compounds it. To undo, apply the inverse (negative skew, or the inverse matrix).' })}` : ''}${modLifetime ? ', lifetime: __lifetime' : ''}${modFont ? ', ...(__font ? { font: __font } : {})' : ''}${modWarning} };`;
     // Wrapped, because the body now RETURNS early on a miss rather than falling
     // through to an unconditional success. Async only when a font must load
     // before modifyItem re-measures the text.
@@ -1235,7 +1243,7 @@ if (!_target) {
   return { success: false, error: ${JSON.stringify(itemId)} + ' is not on the canvas, so ' + ${JSON.stringify(what)} + ' would have done nothing. Check the id with pinepaper_get_items — create returns the registry id, not the Paper id.' };
 }`.trim();
 }
-function generateKeyframeAnimateCode(itemId, keyframes, duration, loop = false, timeOffset, clipInPoint, clipOutPoint, timeUnits) {
+function generateKeyframeAnimateCode(itemId, keyframes, duration, loop = false, timeOffset, clipInPoint, clipOutPoint, timeUnits, append = false) {
     const keyframesJson = JSON.stringify(normalizeKeyframePositions(keyframes), null, 2);
     const calculatedDuration = duration || Math.max(...keyframes.map(k => k.time));
     const opts = { duration: calculatedDuration, loop };
@@ -1247,6 +1255,10 @@ function generateKeyframeAnimateCode(itemId, keyframes, duration, loop = false,
         opts.clipOutPoint = clipOutPoint;
     if (timeUnits !== undefined)
         opts.timeUnits = timeUnits;
+    // addAnimation SETS the item's track; mode 'merge' adds to it (FxTool
+    // 2475333b). An engine without merge ignores the option and replaces.
+    if (append)
+        opts.mode = 'merge';
     // A FADE ON AN AUDIO ITEM WAS ACCEPTED AND NEVER HEARD. addAnimation keyframes
     // the audio item's sentinel, and the mix reads one static audioGain per clip,
     // so {audioGain: 0→1} answered success, duration 15, and exported at a flat
@@ -1285,7 +1297,10 @@ function generateKeyframeAnimateCode(itemId, keyframes, duration, loop = false,
     const gaps = keyframes
         .map((k, i) => ({ time: k.time, missing: allProps.filter((p) => !propSets[i].includes(p)) }))
         .filter((g) => g.missing.length);
-    const gapNote = gaps.length && keyframes.length > 1
+    // With append the gaps that matter are the MERGED track's (an earlier key
+    // with no scale beside a new key with one), so that check runs in the page
+    // on the result instead (below).
+    const gapNote = !append && gaps.length && keyframes.length > 1
         ? `, propertyGaps: ${JSON.stringify(gaps.slice(0, 10))}, gapWarning: ${JSON.stringify(`${gaps.length} keyframe(s) leave out a property other keys animate (${[...new Set(gaps.flatMap((g) => g.missing))].join(', ')}). The engine can break that property's track at such a key; repeat the value on every key — hold it by repeating the previous value.`)}`
         : '';
     const first = [...keyframes].sort((a, b) => a.time - b.time)[0];
@@ -1302,8 +1317,25 @@ function generateKeyframeAnimateCode(itemId, keyframes, duration, loop = false,
 // Apply keyframe animation to ${itemId}
 (function() {
   ${requireItem(itemId, 'the animation')}${audioLevelGuard}
+  // The track as it was, so the result can say what happened to it: merged
+  // (every earlier key still there) or replaced. That is the evidence of
+  // merge support — an older engine takes the option and replaces anyway.
+  const __ki = _target && (_target.item || _target);
+  const __prev = (__ki && __ki.data && Array.isArray(__ki.data.keyframes)) ? __ki.data.keyframes.map(function(k) { return k && k.time; }) : [];
   app.addAnimation('${itemId}', ${keyframesJson}, ${JSON.stringify(opts)});
-  return { success: true, itemId: '${itemId}', duration: ${calculatedDuration}, loop: ${loop}${timeOffset !== undefined ? `, timeOffset: ${timeOffset}` : ''}${clipInPoint !== undefined ? `, clipInPoint: ${clipInPoint}` : ''}${clipOutPoint !== undefined ? `, clipOutPoint: ${clipOutPoint}` : ''}${easingNote}${loopNote}${gapNote} };
+  const __now = (__ki && __ki.data && Array.isArray(__ki.data.keyframes)) ? __ki.data.keyframes.map(function(k) { return k && k.time; }) : [];
+  const __kept = __prev.every(function(t) { return __now.indexOf(t) >= 0; });${append ? `
+  // Property gaps across the merged track (the same check a single call makes
+  // on its own keys at generation time).
+  const __all = (__ki && __ki.data && Array.isArray(__ki.data.keyframes)) ? __ki.data.keyframes : [];
+  const __props = __all.reduce(function(acc, k) { Object.keys((k && k.properties) || {}).forEach(function(p) { if (acc.indexOf(p) < 0) acc.push(p); }); return acc; }, []);
+  const __gaps = __all.length > 1 ? __all.map(function(k) { const have = Object.keys((k && k.properties) || {}); return { time: k && k.time, missing: __props.filter(function(p) { return have.indexOf(p) < 0; }) }; }).filter(function(g) { return g.missing.length; }) : [];` : ''}
+  const __track = !__prev.length ? null
+    : ${append ? `(__kept
+      ? { appended: true, previousKeys: __prev.length, keys: __now.length }
+      : { appended: false, replaced: true, previousKeys: __prev.length, warning: 'append was asked for, but this studio replaced the existing track (' + __prev.length + ' key(s)) instead of adding to it: it has no merge mode. Put every key in one keyframe_animate call.' })`
+        : `{ replaced: true, previousKeys: __prev.length, note: 'the item already had a keyframe track (' + __prev.length + ' key(s)); this call replaced it. To add keys to it instead, pass append: true.' }`};
+  return { success: true, itemId: '${itemId}', duration: ${calculatedDuration}, loop: ${loop}${append ? ', append: true' : ''}, ...(__track ? { track: __track } : {})${append ? `, ...(__gaps.length ? { propertyGaps: __gaps.slice(0, 10), gapWarning: __gaps.length + ' key(s) of the merged track leave out a property other keys animate (' + __gaps.reduce(function(a, g) { g.missing.forEach(function(p) { if (a.indexOf(p) < 0) a.push(p); }); return a; }, []).join(', ') + '). The engine can break that property at such a key; give each key the full set — hold a value by repeating it.' } : {})` : ''}${timeOffset !== undefined ? `, timeOffset: ${timeOffset}` : ''}${clipInPoint !== undefined ? `, clipInPoint: ${clipInPoint}` : ''}${clipOutPoint !== undefined ? `, clipOutPoint: ${clipOutPoint}` : ''}${easingNote}${loopNote}${gapNote} };
 })();
 `.trim();
 }
@@ -1666,7 +1698,8 @@ function generateSetCanvasSizeCode(width, height, preset) {
   // 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 } : {}) };
+    ...(r && r.unbounded !== undefined ? { unbounded: r.unbounded } : {})${!preset && (width > 8192 || height > 8192) ? `,
+    note: 'above 8192 px per side: Chrome and Firefox render it (the studio allows up to 16384 safely), but Safari and iOS may produce a blank or corrupt canvas — export from Chrome.'` : ''} };
 })();
 `.trim();
 }
@@ -2219,6 +2252,9 @@ export class PinePaperCodeGenerator {
      */
     generateModifyItem(input) {
         const validated = ModifyItemInputSchema.parse(input);
+        if (validated.atTime !== undefined) {
+            return generateAutoKeyCode(validated.itemId, validated.properties, validated.atTime, validated.easing);
+        }
         return generateModifyItemCode(validated.itemId, validated.properties, validated.data);
     }
     /**
@@ -2283,7 +2319,7 @@ export class PinePaperCodeGenerator {
      */
     generateKeyframeAnimate(input) {
         const validated = KeyframeAnimateInputSchema.parse(input);
-        return generateKeyframeAnimateCode(validated.itemId, validated.keyframes, validated.duration, validated.loop, validated.timeOffset, validated.clipInPoint, validated.clipOutPoint, validated.timeUnits);
+        return generateKeyframeAnimateCode(validated.itemId, validated.keyframes, validated.duration, validated.loop, validated.timeOffset, validated.clipInPoint, validated.clipOutPoint, validated.timeUnits, validated.append);
     }
     /**
      * Generate code for importing / retargeting a motion-capture clip
@@ -2435,12 +2471,21 @@ ${INLINE_REMOTE_IMAGES}
   imported.scale(${scale});
   const itemId = app.registerItem(imported, 'svg-import', { source: 'mcp' });
   app.historyManager.saveState();
+  const _b = imported.bounds;
+  const _tiny = _b && _b.width < 16 && _b.height < 16;
   return { success: true, itemId, changes: _r.changes, position: { x: ${position.x}, y: ${position.y} },
+    size: _b ? { width: Math.round(_b.width * 10) / 10, height: Math.round(_b.height * 10) / 10 } : null,
+    ...(_tiny ? { warning: 'the SVG came in at ' + _b.width.toFixed(1) + 'x' + _b.height.toFixed(1) + ' px — too small to see (a root sized in em or % reads as 1 px). Pass scale, or give the SVG a width / height in px.' } : {}),
     ...(_inl.notes.length ? { imageWarnings: _inl.notes } : {}) };
 })();
 `.trim();
         }
         if (svgString) {
+            // A root sized in em / % (icon sets) renders ~5 px: sized from the
+            // viewBox instead, and the result says so (see utils/svg-size.ts).
+            const sized = normalizeSvgSize(svgString);
+            svgString = sized.svg;
+            const sizeFix = sized.fix;
             // Escape the SVG string for embedding in code
             const escapedSvg = svgString.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
             return `
@@ -2459,7 +2504,14 @@ imported.position = new paper.Point(${position.x}, ${position.y});
 imported.scale(${scale});
 const itemId = app.registerItem(imported, 'svg-import', { source: 'mcp' });
 app.historyManager.saveState();
+// A SPECK IS NOT A SUCCESS WORTH REPORTING QUIETLY: under 16 px both ways,
+// the import is said to be tiny, with the fix.
+const _b = imported.bounds;
+const _tiny = _b && _b.width < 16 && _b.height < 16;
 return { success: true, itemId, changes: _r.changes, position: { x: ${position.x}, y: ${position.y} },
+  size: _b ? { width: Math.round(_b.width * 10) / 10, height: Math.round(_b.height * 10) / 10 } : null,
+  ${sizeFix ? `sizeFix: ${JSON.stringify(sizeFix)},` : ''}
+  ...(_tiny ? { warning: 'the SVG came in at ' + _b.width.toFixed(1) + 'x' + _b.height.toFixed(1) + ' px — too small to see. Pass scale, or give the SVG a width / height in px.' } : {}),
   ...(_inl.notes.length ? { imageWarnings: _inl.notes } : {}) };
 })();
 `.trim();
@@ -3945,7 +3997,7 @@ return { success: true, action: 'seek', time: ${op.time || 0} };
     }
     generateAgentExport(input) {
         const validated = AgentExportInputSchema.parse(input);
-        const { platform, format, quality, framing, duration, estimateOnly, scale, fps, pdf: pdfOpts, region, time: stillTime, maxBytes, loop: gifLoop, broadcast, broadcastHeadroom, bitrate, minBitrate, bitrateMode, transparent, alphaQuantizer, ad: adOpts } = validated;
+        const { platform, format, quality, framing, duration, estimateOnly, scale, fps, pdf: pdfOpts, region, time: stillTime, maxBytes, loop: gifLoop, broadcast, broadcastHeadroom, bitrate, minBitrate, bitrateMode, transparent, alphaQuantizer, deterministic, ad: adOpts, frames } = validated;
         // Encoder options (FxTool 16719759); the schema keeps them to mp4 / webm.
         const videoEncodeOpts = {};
         if (broadcast)
@@ -3963,6 +4015,10 @@ return { success: true, action: 'seek', time: ${op.time || 0} };
             videoEncodeOpts.minBitrate = minBitrate;
         if (bitrateMode !== undefined)
             videoEncodeOpts.bitrateMode = bitrateMode;
+        // Byte-identical repeats (FxTool 3b335567): the container timestamps are
+        // the only bytes that varied, and this pins them.
+        if (deterministic)
+            videoEncodeOpts.deterministic = true;
         // A transparent WebM (FxTool 1833b397) rides the store route too.
         const webmAlpha = format === 'webm' && transparent === true;
         if (webmAlpha) {
@@ -3972,13 +4028,22 @@ return { success: true, action: 'seek', time: ${op.time || 0} };
         }
         const encodeOptsJs = Object.keys(videoEncodeOpts).length ? `, ...${JSON.stringify(videoEncodeOpts)}` : '';
         const qualityLevel = quality || 'standard';
-        const videoDuration = duration ?? 5;
+        let videoDuration = duration ?? 5;
         // Quality settings (bitrate in bps for VideoEncoder)
         const qualitySettings = {
             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];
+        // FRAMES, EXACTLY (showcase film, 11.1). The engine makes ceil(duration x
+        // fps) frames for mp4 / webm / gif and floor(...) for apng, so 7.91667 s
+        // at 24 fps was 191 frames, not 190 — and N / fps itself can land a hair
+        // above N in floating point (190 / 24 * 24 > 190). The duration is nudged
+        // a microsecond toward the side that rounds to N.
+        if (frames !== undefined) {
+            const fpsEff = fps ?? qualitySettings.fps;
+            videoDuration = frames / fpsEff + (format === 'apng' ? 1e-6 : -1e-6);
+        }
         // Platform presets
         const platformPresets = {
             'instagram': { width: 1080, height: 1080, staticFormat: 'png', animatedFormat: 'mp4' },
@@ -4459,6 +4524,9 @@ ${stillTime !== undefined ? `
           // a neighbouring card's overflowing headline. Older studios ignore the
           // fourth argument, and leave lastRegionExcluded unset.
           if ('lastRegionExcluded' in app) app.lastRegionExcluded = null;
+          // A video in the region is waited for at this time (round 12, 12.5):
+          // the render drew before the clip's seek landed.
+          if (typeof app.awaitMediaAt === 'function') await app.awaitMediaAt(${stillTime !== undefined ? stillTime : "typeof app.playbackTime === 'number' ? app.playbackTime : 0"});
           const regionUrl = app.renderRegionToDataURL(new paper.Rectangle(${region.x}, ${region.y}, ${region.width}, ${region.height}), rw, rh${region.excludeForeign === false ? '' : ', { excludeForeign: true }'});
           const __excluded = Array.isArray(app.lastRegionExcluded) ? app.lastRegionExcluded.filter(function(id) { return id; }) : null;
           // ITEMS THAT CROSS THE REGION'S EDGE (round 9 II, 1.78). In the sheet
@@ -4688,7 +4756,12 @@ ${stillTime !== undefined ? `
                 + ' MB inline ceiling, and this studio has no app.exportEngine.exportToStore to page it out of — update FxTool, or lower duration/quality',
             };
           }
-          return { success: true, platform, format, framing, data: await blobToDataUrl(blob), mimeType: videoMimeType, size: blob.size };
+          // The container the file IS: an encoder that cannot do H.264 at this
+          // size writes VP9 WebM (round 12: mp4 at 12000 px came back WebM),
+          // and naming it .mp4 breaks players. Said below in fidelity.
+          const __mime = (blob.type && String(blob.type).split(';')[0]) || videoMimeType;
+          const __fmt = __mime === 'video/webm' ? 'webm' : __mime === 'video/mp4' ? 'mp4' : format;
+          return { success: true, platform, format: __fmt, framing, data: await blobToDataUrl(blob), mimeType: __mime, size: blob.size };
         };
 
         // Camera framing requires going direct to videoExporter so width/height
@@ -4968,6 +5041,18 @@ ${stillTime !== undefined ? `
 
   if (result && result.success) Object.assign(result, fidelity(format));
   if (result && result.success && __fit) result.platformFit = __fit;
+  // A LANDSCAPE CANVAS FOR A PORTRAIT PLATFORM (or the reverse) is not an
+  // aspect nuance but the wrong deliverable: tiktok on a 16:9 canvas came out
+  // 1920x1080 with only a note (round 10, 10.7). Said where a caller looks.
+  if (result && result.success && __fit) {
+    const __pw = __fit.preset.split('x').map(Number), __uw = __fit.used.split('x').map(Number);
+    if ((__pw[0] > __pw[1]) !== (__uw[0] > __uw[1]) && __pw[0] !== __pw[1]) {
+      result.fidelity = result.fidelity || { warnings: [] };
+      result.fidelity.warnings = (result.fidelity.warnings || []).concat([{ code: 'platform_orientation_mismatch',
+        message: platform + ' is ' + (__pw[0] > __pw[1] ? 'landscape' : 'portrait') + ' (' + __fit.preset + '), but the canvas is ' + (__uw[0] > __uw[1] ? 'landscape' : 'portrait') + ', so the file is ' + __fit.used + '. For a ' + platform + ' deliverable, resize the canvas to ' + __fit.preset + ' (pinepaper_set_canvas_size) and re-lay the scene for it; the export does not reframe a scene.' }]);
+      if (result.fidelity.note) delete result.fidelity.note;
+    }
+  }
   // AUDIO TIMING, WHERE THE STUDIO REPORTS IT (6.27). An MP4's AAC track used
   // to start ~44 ms late and run past the picture — a 6.000 s bumper with sound
   // then failed its cap. The engine now reports the track; it is surfaced as
@@ -5025,6 +5110,56 @@ ${stillTime !== undefined ? `
   // The applied value is the engine's own report where it gives one
   // (5adfcf1c: lastVideoReport.headroom), so the result and the report agree.
   if (result && result.success) result.broadcastHeadroom = { value: (__vr && typeof __vr.headroom === 'number') ? __vr.headroom : 12, defaulted: true, note: 'broadcast defaults to 12 luma codes of headroom, which keeps encoder ringing legal; pass broadcastHeadroom: 0 for the full range.' };` : ''}
+  // FROZEN OUTPUT (round 12, 12.3): constant bitrate at 3552x1080 answered
+  // success with 600 identical frames. The file cannot be decoded here on the
+  // store route, so this is a size check: an animated scene whose video
+  // carries under 0.002 bits per pixel per frame is almost certainly one
+  // frame repeated. Labelled as a suspicion, with how to confirm it.
+  if (result && result.success && (result.format === 'mp4' || result.format === 'webm') && result.fidelity && result.fidelity.checked && result.fidelity.checked.animated && typeof result.size === 'number') {
+    const __d = result.dimensions || dimensions;
+    const __frames = Math.max(1, Math.round(${videoDuration} * (settings.fps || 30)));
+    const __bpp = (result.size * 8) / Math.max(1, __d.width * __d.height * __frames);
+    // The studio's own count of distinct frames it fed the encoder, where it
+    // reports one, decides; the size is only the fallback (a small dot moving on
+    // a flat field is also a tiny file).
+    const __vf = __vr && __vr.frames;
+    const __distinct = __vf && typeof __vf.distinct === 'number' ? __vf.distinct : null;
+    // The studio's decoded-output test (output_frozen) is the real answer for
+    // an encoder freeze; the size guess stays out when it has spoken.
+    const __engineFrozen = !!(__vr && Array.isArray(__vr.warnings) && __vr.warnings.some(function(w) { return w && w.code === 'output_frozen'; }));
+    if (!__engineFrozen && (__distinct !== null ? __distinct <= 1 : __bpp < 0.002)) {
+      result.fidelity.warnings = (result.fidelity.warnings || []).concat([{ code: 'possibly_frozen',
+        message: __distinct !== null
+          ? 'the scene animates, but the studio rendered ' + __distinct + ' distinct frame(s) for the encoder — the animation did not play during the export (not an encoder fault). Check that the animation runs on the timeline over the exported range.'
+          : 'the video carries ' + __bpp.toFixed(5) + ' bits per pixel per frame (' + result.size + ' bytes for ' + __frames + ' frames at ' + __d.width + 'x' + __d.height + ') — the encoder has most likely repeated one frame. Check two frames (ffprobe, or pinepaper_capture_frames against the scene); a smaller size, bitrateMode variable, or format webm usually avoids it.' }]);
+      if (result.fidelity.note) delete result.fidelity.note;
+    }
+  }
+  // THE STUDIO'S OWN CODED VIDEO WARNINGS (e.g. an output-side freeze the
+  // input-frame count cannot see): passed through when they carry a code this
+  // tool does not already raise from the numbers. Plain-string warnings are
+  // the bitrate / luma texts, raised above from their numbers instead.
+  if (result && result.success && __vr && Array.isArray(__vr.warnings)) {
+    // format_substituted is NOT here: the studio's own (agreed with FxTool)
+    // is the better-informed one, so it passes and this tool's is skipped.
+    const __mine = ['bitrate_below_floor', 'luma_out_of_range', 'determinism_not_pinned', 'dimensions_rounded', 'possibly_frozen', 'alpha_not_applied', 'alpha_keyframe_mismatch'];
+    const __extra = __vr.warnings.filter(function(w) { return w && typeof w === 'object' && typeof w.code === 'string' && __mine.indexOf(w.code) < 0; })
+      .map(function(w) { return { code: w.code, message: String(w.message || w.code) }; });
+    if (__extra.length) {
+      result.fidelity = result.fidelity || { warnings: [] };
+      result.fidelity.warnings = (result.fidelity.warnings || []).concat(__extra);
+      if (result.fidelity.note) delete result.fidelity.note;
+    }
+  }
+  // A DIFFERENT CONTAINER THAN ASKED (round 12, 12.7): the file is named by
+  // what it is, and the substitution is said, not left to a player to find.
+  const __studioSaidFormat = !!(__vr && Array.isArray(__vr.warnings) && __vr.warnings.some(function(w) { return w && w.code === 'format_substituted'; }));
+  if (!__studioSaidFormat && result && result.success && (result.format === 'mp4' || result.format === 'webm') && result.format !== format && (format === 'mp4' || format === 'webm')) {
+    result.fidelity = result.fidelity || { warnings: [] };
+    result.fidelity.warnings = (result.fidelity.warnings || []).concat([{ code: 'format_substituted',
+      message: format + ' was asked for, but the browser encoder could not make ' + format + ' at ' + ((result.dimensions && result.dimensions.width) || '') + 'x' + ((result.dimensions && result.dimensions.height) || '') + ((__vr && __vr.codecFallback && __vr.codecFallback.reason) ? ' (' + __vr.codecFallback.reason + ')' : '') + ', so the file is ' + result.format + ' (saved with that extension). For ' + format + ' at this size, export smaller (scale) and upscale, or re-encode the ' + result.format + '.' }]);
+    if (result.fidelity.note) delete result.fidelity.note;
+  }
   // AN ODD SIDE ROUNDED UP (FxTool e64a5260). H.264 needs even dimensions, so
   // 1200x675 came out 1200x676 — and platform specs are exact-pixel. The
   // result's dimensions become what the file IS, and fidelity says why.
@@ -5037,7 +5172,34 @@ ${stillTime !== undefined ? `
       message: 'the file is ' + __vd.output[0] + 'x' + __vd.output[1] + ', not the requested ' + __vd.requested[0] + 'x' + __vd.requested[1] + ': H.264 needs even dimensions, so an odd side was rounded up by 1 px (the extra row / column is background). For an exact-pixel spec, use an even canvas size, or crop the extra line when re-encoding (ffmpeg -vf crop=' + __vd.requested[0] + ':' + __vd.requested[1] + ':0:0).' }]);
     if (result.fidelity.note) delete result.fidelity.note;
   }
-  // LUMA OUTSIDE 16-235 (8.35, FxTool 4f1ec3ae). The broadcast encode is
+${deterministic ? `  // DETERMINISTIC: the container timestamps are pinned either way; the PIXELS
+  // are only identical run to run on the software encoder, because the
+  // browser may pick a different hardware backend each time (FxTool
+  // e34ae03d: 92/255 between backends, 2/255 run to run on hardware). The
+  // engine requests software and reports what it got.
+  // Where the studio says outright whether the file repeats (bitExact, FxTool
+  // PR #31: it test-encodes and keeps whichever encoder does — often the
+  // HARDWARE one on a Mac, since Chrome's software H.264 is not repeatable at
+  // some sizes), that answer decides; the encoder name is only the fallback
+  // for studios that do not report it.
+  if (result && result.success) {
+    const __hw = __vr && __vr.hardwareAcceleration;
+    const __exact = __vr && typeof __vr.bitExact === 'boolean' ? __vr.bitExact : null;
+    if (__exact === false) {
+      result.fidelity = result.fidelity || { warnings: [] };
+      result.fidelity.warnings = (result.fidelity.warnings || []).concat([{ code: 'determinism_not_pinned',
+        message: 'deterministic was asked for, but no encoder on this machine repeats byte for byte at this size (the studio test-encoded and checked): the pixels may differ slightly between runs. Do not cache this file by hash; a different frame size may repeat.' }]);
+      if (result.fidelity.note) delete result.fidelity.note;
+    } else if (__exact === null && __hw !== 'prefer-software') {
+      result.fidelity = result.fidelity || { warnings: [] };
+      result.fidelity.warnings = (result.fidelity.warnings || []).concat([{ code: 'determinism_not_pinned',
+        message: __hw
+          ? 'deterministic was asked for, but the encoder ran with hardwareAcceleration ' + JSON.stringify(__hw) + ': the container is pinned, the pixels may still differ slightly between runs (hardware encoders vary). Do not cache this file by hash.'
+          : 'deterministic pinned the container timestamps, but this studio does not report which encoder backend ran, so the pixels may differ slightly between runs if the browser switches between hardware and software encoding. Do not rely on byte-identical files from this studio.' }]);
+      if (result.fidelity.note) delete result.fidelity.note;
+    }
+  }
+` : ''}  // LUMA OUTSIDE 16-235 (8.35, FxTool 4f1ec3ae). The broadcast encode is
   // decoded back and measured: H.264 ringing at hard edges puts a fraction of
   // a percent of samples out of range, which QC rejects. broadcastHeadroom
   // cuts it but never to zero, so a legaliser pass is the requirement.
@@ -5051,7 +5213,10 @@ ${Object.keys(videoEncodeOpts).length ? `  if (result && result.success) {
     const __vw = [];
     // The engine joins its warnings into one string (bitrate floor, then
     // luma), so each is raised from its own numbers, not from that text.
-    if (__vr && typeof __vr.achievedBitrate === 'number' && typeof __vr.bitrateFloor === 'number' && __vr.achievedBitrate < __vr.bitrateFloor * 0.95) {
+    // The studio's own measured bitrate_not_honoured, where it sends one,
+    // replaces this estimate.
+    const __engineBitrate = !!(__vr && Array.isArray(__vr.warnings) && __vr.warnings.some(function(w) { return w && w.code === 'bitrate_not_honoured'; }));
+    if (!__engineBitrate && __vr && typeof __vr.achievedBitrate === 'number' && typeof __vr.bitrateFloor === 'number' && __vr.achievedBitrate < __vr.bitrateFloor * 0.95) {
       __vw.push({ code: 'bitrate_below_floor', message: 'achieved ' + (__vr.achievedBitrate / 1e6).toFixed(2) + ' Mbps against a ' + (__vr.bitrateFloor / 1e6).toFixed(1) + ' Mbps floor: the browser encoder treats the bitrate as a ceiling and does not pad simple content. Re-encode for delivery (e.g. ffmpeg -b:v with -minrate / -bufsize) if the spec requires the floor.' });
     }
     if (!__vr || typeof __vr !== 'object') {
@@ -6831,7 +6996,7 @@ ${stillTime !== undefined ? `  try { app.setPlaybackTime(__prevT); } catch (_) {
 `.trim();
     }
     generateImportImage(input) {
-        const { url, position, maxWidth, maxHeight, mask, smoothing } = input;
+        const { url, position, maxWidth, maxHeight, mask, smoothing, maxEdge, nativeSize } = input;
         // Each fragment used to be written with a LEADING comma, as if it followed
         // an entry that no longer exists — so the first one opened the object with
         // `{, position: …}` and the emitted code was a syntax error. Passing any
@@ -6842,6 +7007,7 @@ ${stillTime !== undefined ? `  try { app.setPlaybackTime(__prevT); } catch (_) {
             position ? `position: { x: ${position.x}, y: ${position.y} }` : '',
             maxWidth !== undefined ? `maxWidth: ${maxWidth}` : '',
             maxHeight !== undefined ? `maxHeight: ${maxHeight}` : '',
+            nativeSize ? 'nativeSize: true' : '',
         ].filter(Boolean);
         const optsLiteral = optParts.length ? `{ ${optParts.join(', ')} }` : '{}';
         return `
@@ -6897,7 +7063,7 @@ ${stillTime !== undefined ? `  try { app.setPlaybackTime(__prevT); } catch (_) {
         fr.readAsDataURL(blob);
       });
     }
-    const entry = await app.imageTools.uploadFromURL(src);
+    const entry = await app.imageTools.uploadFromURL(src${maxEdge !== undefined ? `, { maxEdge: ${maxEdge === 'native' ? 'Infinity' : maxEdge} }` : ''});
     const opts = ${optsLiteral};
     const raster = await app.imageTools.placeImage(entry.id, Object.keys(opts).length > 0 ? opts : undefined);
 ${smoothing ? `    // Pixel art wants 'off': Paper's Raster draws with smoothing 'low' by
@@ -6936,7 +7102,13 @@ ${mask ? `    // A MASK REPLACES THE RASTER (round 8 DD, 4.10). applyMask builds
       success: true,
       itemId: itemId,
       message: 'Image imported and placed on canvas.',
-      bounds: { x: b.x, y: b.y, width: b.width, height: b.height }${mask ? `,\n      mask: '${mask}'` : ''}
+      bounds: { x: b.x, y: b.y, width: b.width, height: b.height }${mask ? `,\n      mask: '${mask}'` : ''},
+      // Stored smaller than its source (the studio's cap): said, with the
+      // way to keep every pixel. The studio reports native size where it can.
+      ...((entry && entry.nativeWidth && entry.width && entry.nativeWidth > entry.width)
+        ? { stored: { width: entry.width, height: entry.height }, native: { width: entry.nativeWidth, height: entry.nativeHeight },
+            note: 'the studio stored this image at ' + entry.width + 'x' + entry.height + ' (its source is ' + entry.nativeWidth + 'x' + entry.nativeHeight + '). Pass maxEdge: "native" to keep every pixel.' }
+        : {})
     };
   } catch (e) {
     return { error: 'Failed to import image: ' + e.message };
@@ -7701,6 +7873,12 @@ ${loads}
         // Anything else (asset id, data:, URL) passes through untouched.
         // @engine-methods analyzeAudio animateToBeat
         const resolveSource = `  let __src = ${JSON.stringify(input.source || '')};
+  // A large source was staged beside the code (see the handler); read it back.
+  if (__src.indexOf('__ppStage:') === 0) {
+    const __staged = window.__ppStage && window.__ppStage[__src.slice('__ppStage:'.length)];
+    if (!__staged) return { success: false, error: 'the staged audio did not reach the page — try again, or upload it with pinepaper_media upload_audio and pass the returned id.' };
+    __src = __staged;
+  }
   const __A = (typeof window !== 'undefined') && window.PinePaperAgent;
   const __m = (__src && __A && typeof __A.listMedia === 'function')
     ? __A.listMedia().find(function(x) { return x.id === __src || x.registryId === __src; })
@@ -7724,6 +7902,11 @@ ${resolveSource}
   if (r && typeof r === 'object' && 'ok' in r) {
     return { success: r.ok !== false, ...r };
   }
+  // Nothing back is not a result: it was reported as success with an empty
+  // body (gap 5.5), which reads as "analysed, no beats".
+  if (r === undefined || r === null) {
+    return { success: false, error: '${method} returned nothing, so there is no result to report. If the source is large, upload it with pinepaper_media upload_audio and pass the returned id.' };
+  }
   return { success: true, result: r };
 })();`.trim();
         if (input.action === 'analyze') {
@@ -8247,7 +8430,12 @@ ${resolve}
   // engine mints a NUMBER. Returning the number meant the id could not be
   // round-tripped: pass it back to add/remove and zod rejects it before the
   // call is made.
-  const _pid = precomp && precomp.id !== undefined ? precomp.id : precomp;
+  // THE REGISTRY ID, not Paper's. createPrecomp returns the group, whose
+  // .id is Paper's numeric id ("49"), which no tool accepts back ("precomp:
+  // no such item(s): 49", round 10, 10.11). The registry id — what
+  // listPrecomps and every other tool use — is on the group's data.
+  const _d = (precomp && precomp.data) || {};
+  const _pid = _d.registryId || _d.id || (precomp && precomp.id !== undefined ? precomp.id : precomp);
   return { success: true, action: 'create', precompId: String(_pid), itemCount: items.length, name: ${JSON.stringify(input.name || '')} };
 })();`.trim();
             }
@@ -8258,7 +8446,11 @@ ${resolve}
   // addToPrecomp answers falsy when the precomp or the item is not found, and
   // this reported success regardless — the same silent-success shape as an
   // unknown itemId elsewhere.
-  const _ok = app.addToPrecomp(${JSON.stringify(input.precompId || '')}, ${JSON.stringify(input.itemId || '')});
+  // The engine takes the ITEM, not its id (it clones it); an id string made
+  // add throw and could never have worked. Resolved here, and a miss named.
+  const _item = app.getItemById(${JSON.stringify(input.itemId || '')});
+  if (!_item) return { success: false, action: 'add', error: 'no item ' + ${JSON.stringify(JSON.stringify(input.itemId || ''))} + ' on the canvas — check the id with pinepaper_get_items.' };
+  const _ok = app.addToPrecomp(${JSON.stringify(input.precompId || '')}, _item);
   if (_ok === false || _ok === null || _ok === undefined) {
     return { success: false, action: 'add', error: 'nothing was added — check the precompId (create returns it as a string) and the itemId with pinepaper_get_items.' };
   }
@@ -8268,7 +8460,14 @@ ${resolve}
                 return `
 // Remove item from precomp
 (function() {
-  app.removeFromPrecomp(${JSON.stringify(input.precompId || '')}, ${JSON.stringify(input.itemId || '')});
+  // The item, not its id (the engine checks item.parent); and its answer is
+  // read — null meant nothing was removed, and this said success regardless.
+  const _item = app.getItemById(${JSON.stringify(input.itemId || '')});
+  if (!_item) return { success: false, action: 'remove', error: 'no item ' + ${JSON.stringify(JSON.stringify(input.itemId || ''))} + ' on the canvas — check the id with pinepaper_get_items.' };
+  const _r = app.removeFromPrecomp(${JSON.stringify(input.precompId || '')}, _item);
+  if (_r === null || _r === undefined || _r === false) {
+    return { success: false, action: 'remove', error: 'nothing was removed — the item is not in that precomp, or the precompId is not a precomp (create returns it; list shows them).' };
+  }
   return { success: true, action: 'remove', precompId: ${JSON.stringify(input.precompId || '')}, itemId: ${JSON.stringify(input.itemId || '')} };
 })();`.trim();
             default:
@@ -9424,24 +9623,55 @@ if (!app.spriteSystem) return { error: 'SpriteSheetSystem not available' };`;
         const n = Math.min(1200, Math.max(3, Math.round(duration * fps)));
         return `
 // Accessibility measurements (${checks.join(', ')})
-(function() {
+(async function() {
   const out = { success: true, fps: ${fps}, duration: ${duration} };
   const rgba = function(c) {
     if (!c || c.gradient || typeof c.red !== 'number') return null;
     return { r: Math.round(c.red * 255), g: Math.round(c.green * 255), b: Math.round(c.blue * 255), a: typeof c.alpha === 'number' ? c.alpha : 1 };
   };
   out.page = (app.canvasEl && app.canvasEl.style && app.canvasEl.style.backgroundColor) || null;
-${checks.includes('contrast') ? `  const all = (app.itemRegistry && typeof app.itemRegistry.getAll === 'function') ? app.itemRegistry.getAll() : [];
-  const texts = all.filter(function(e) { return e && e.item && e.item.className === 'PointText' && e.item.visible !== false && String(e.item.content || '').trim() !== ''; });
-  const solids = all.filter(function(e) { return e && e.item && e.item.className !== 'PointText' && e.item.visible !== false && rgba(e.item.fillColor) && e.item.bounds; });
-  out.texts = texts.map(function(e) {
-    const it = e.item, c = it.bounds.center;
-    const under = solids.filter(function(s) { return s.item.bounds.contains(c) && typeof s.item.isBelow === 'function' && s.item.isBelow(it); });
-    const top = under.reduce(function(best, s) { return (!best || (typeof s.item.isAbove === 'function' && s.item.isAbove(best.item))) ? s : best; }, null);
-    const w = String(it.fontWeight || '');
-    return { id: e.itemId, content: String(it.content), fill: rgba(it.fillColor), fontSize: it.fontSize || 0,
-      bold: w === 'bold' || Number(w) >= 700, behind: top ? rgba(top.item.fillColor) : null, behindId: top ? top.itemId : undefined };
+${checks.includes('contrast') ? `  // SAMPLED OVER TIME (round 12, 12.9): text is judged where it is on screen.
+  // Reading only the current playhead found no visible text in a scene of
+  // timed captions and passed with nothing checked. The times: 0, inside each
+  // text's lifetime, every keyframe time, and every second of the duration —
+  // the playhead is moved, lifetimes applied, and put back.
+  const all = (app.itemRegistry && typeof app.itemRegistry.getAll === 'function') ? app.itemRegistry.getAll() : [];
+  const snap = function(t) {
+    const texts = all.filter(function(e) { return e && e.item && e.item.className === 'PointText' && e.item.visible !== false && e.item.opacity !== 0 && String(e.item.content || '').trim() !== ''; });
+    const solids = all.filter(function(e) { return e && e.item && e.item.className !== 'PointText' && e.item.visible !== false && rgba(e.item.fillColor) && e.item.bounds; });
+    return texts.map(function(e) {
+      const it = e.item, c = it.bounds.center;
+      const under = solids.filter(function(s) { return s.item.bounds.contains(c) && typeof s.item.isBelow === 'function' && s.item.isBelow(it); });
+      const top = under.reduce(function(best, s) { return (!best || (typeof s.item.isAbove === 'function' && s.item.isAbove(best.item))) ? s : best; }, null);
+      const w = String(it.fontWeight || '');
+      return { id: e.itemId, t: t, content: String(it.content), fill: rgba(it.fillColor), fontSize: it.fontSize || 0,
+        bold: w === 'bold' || Number(w) >= 700, behind: top ? rgba(top.item.fillColor) : null, behindId: top ? top.itemId : undefined };
+    });
+  };
+  const times = [0];
+  all.forEach(function(e) {
+    const d = (e && e.item && e.item.data) || {};
+    if (typeof d.bornAt === 'number') times.push(d.bornAt + Math.min(0.1, (typeof d.ttl === 'number' ? d.ttl : 1) / 2));
+    if (Array.isArray(d.keyframes)) d.keyframes.forEach(function(k) { if (k && typeof k.time === 'number') times.push(k.time); });
   });
+  Array.from({ length: Math.floor(${duration}) + 1 }, function(_, i) { times.push(i); });
+  const uniq = times.filter(function(t, i) { return t >= 0 && t <= ${duration} + 1e-6 && times.indexOf(t) === i; }).sort(function(a, b) { return a - b; }).slice(0, 60);
+  const L = globalThis.__ppMcp;
+  const at = function(t) {
+    if (typeof app.setPlaybackTime === 'function') app.setPlaybackTime(t);
+    if (L && L.lifetimeApp === app && typeof L.applyLifetimes === 'function') { try { L.applyLifetimes(t); } catch (_) { /* sampled as is */ } }
+    if (typeof paper !== 'undefined' && paper.view && typeof paper.view.update === 'function') paper.view.update();
+  };
+  const prevT = typeof app.playbackTime === 'number' ? app.playbackTime : 0;
+  out.texts = [];
+  if (typeof app.setPlaybackTime === 'function') {
+    uniq.forEach(function(t) { at(t); out.texts = out.texts.concat(snap(t)); });
+    at(prevT);
+    out.sampledTimes = uniq.length;
+  } else {
+    out.texts = snap(prevT);
+    out.sampledTimes = 1;
+  }
 ` : ''}${checks.includes('flash') ? `  if (typeof app.captureFramesAt !== 'function') {
     out.flashUnavailable = 'this studio has no deterministic frame capture (app.captureFramesAt), so flashing was not checked.';
   } else {
@@ -9451,7 +9681,9 @@ ${checks.includes('contrast') ? `  const all = (app.itemRegistry && typeof app.i
     const ctx = small.getContext('2d', { willReadFrequently: true });
     const lut = Array.from({ length: 256 }, function(_, v) { const x = v / 255; return x <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4); });
     const times = Array.from({ length: ${n} }, function(_, i) { return i / ${fps}; });
-    out.series = app.captureFramesAt(times, { capture: function(c) {
+    // Waits for video per frame where the studio can (12.6).
+    const __cap = typeof app.captureFramesAtAsync === 'function' ? app.captureFramesAtAsync.bind(app) : app.captureFramesAt.bind(app);
+    out.series = await __cap(times, { capture: function(c) {
       // Transparent canvas shows the page's CSS background, so composite on it.
       ctx.fillStyle = out.page || '#ffffff';
       ctx.fillRect(0, 0, W, H);
@@ -9477,7 +9709,7 @@ ${checks.includes('contrast') ? `  const all = (app.itemRegistry && typeof app.i
         const includeDataUrls = !!input.includeDataUrls;
         return `
 // Deterministic frame capture
-(function() {
+(async function() {
   if (typeof app.captureFramesAt !== 'function') {
     return { success: false, error: 'app.captureFramesAt unavailable — update FxTool to a build with the deterministic capture entrypoint' };
   }
@@ -9494,7 +9726,24 @@ ${checks.includes('contrast') ? `  const all = (app.itemRegistry && typeof app.i
     // plain 9-text scene (round 7 X, #7) on studios without hashFrame. A native
     // reduce is not a generated loop and is not counted; same djb2-xor.
     : function(s) { return Array.prototype.reduce.call(s, function(h, c) { return (((h << 5) + h) ^ c.charCodeAt(0)) >>> 0; }, 5381).toString(16); };
-  const frames = app.captureFramesAt(${timesJson}, {
+  // A VIDEO ON SCREEN IS WAITED FOR (round 12, 12.6): the sync capture drew
+  // before a clip's seek landed, so a frame showed the previous time's
+  // picture. captureFramesAtAsync waits per frame; older studios keep the
+  // sync one (and say video-not-synced themselves).
+  //
+  // What is REPORTED is what happened, not what exists (retest of 009f00e: a
+  // "videoSynced: true" capture right after an upload showed the video black).
+  // videoWait says whether the studio waited per frame; firstSeek is the
+  // studio's own answer for the first time (seeked / timedOut / skipped).
+  // A seek that times out later is an engine warning (video-seek-timeout),
+  // forwarded in governor.engineWarnings.
+  const __waits = typeof app.captureFramesAtAsync === 'function';
+  let __firstSeek = null;
+  if (typeof app.awaitMediaAt === 'function' && ${timesJson}.length) {
+    try { __firstSeek = await app.awaitMediaAt(${timesJson}[0]); } catch (e) { __firstSeek = { error: String(e && e.message || e) }; }
+  }
+  const __cap = __waits ? app.captureFramesAtAsync.bind(app) : app.captureFramesAt.bind(app);
+  const frames = await __cap(${timesJson}, {
     seed: ${seed},
     capture: function(c, t, i) {
       // Prefer app.captureFrameDataURL(): it renders only the used region, so an
@@ -9509,7 +9758,11 @@ ${checks.includes('contrast') ? `  const all = (app.itemRegistry && typeof app.i
     }
   });
   const uniqueHashes = new Set(frames.map(function(f) { return f.hash; })).size;
-  return { success: true, seed: ${seed}, frameCount: frames.length, uniqueHashes: uniqueHashes, allIdentical: uniqueHashes <= 1, frames: frames };
+  return { success: true, seed: ${seed}, frameCount: frames.length, uniqueHashes: uniqueHashes, allIdentical: uniqueHashes <= 1,
+    videoWait: __waits ? 'awaited per frame' : 'not supported by this studio (frames may show a video before its seek lands)',
+    ...(__firstSeek ? { firstSeek: __firstSeek } : {}),
+    ...(__firstSeek && __firstSeek.timedOut > 0 ? { videoWarning: 'the video seek for the first frame timed out: its video may show an earlier picture. Retry after the clip has loaded.' } : {}),
+    frames: frames };
 })();`.trim();
     }
     /**
@@ -9657,6 +9910,7 @@ ${checks.includes('contrast') ? `  const all = (app.itemRegistry && typeof app.i
                 const opts = JSON.stringify({
                     ...(input.position ? { position: input.position } : {}),
                     ...(input.scale !== undefined ? { scale: input.scale } : {}),
+                    ...(input.fit !== undefined ? { fit: input.fit } : {}),
                     ...(input.timeOffset !== undefined ? { timeOffset: input.timeOffset } : {}),
                     ...(input.clipInPoint !== undefined ? { clipInPoint: input.clipInPoint } : {}),
                     ...(input.clipOutPoint !== undefined ? { clipOutPoint: input.clipOutPoint } : {}),
@@ -9665,7 +9919,7 @@ ${checks.includes('contrast') ? `  const all = (app.itemRegistry && typeof app.i
 // Upload video from URL
 (async function() {
 ${guard}
-  const info = await A.uploadVideo(${srcExpr(input.url, 'video')}, ${opts});
+  const info = await A.uploadVideo(${srcExpr(input.url, 'video')}, ${input.atPlayhead ? `Object.assign(${opts}, { timeOffset: Number(app.playbackTime) || 0 })` : opts});
   return { success: true, action: 'upload_video', media: info };
 })();`.trim();
             }
@@ -9680,7 +9934,7 @@ ${guard}
 // Upload audio from URL
 (async function() {
 ${guard}
-  const info = await A.uploadAudio(${srcExpr(input.url, 'audio')}, ${opts});${input.volume !== undefined ? `
+  const info = await A.uploadAudio(${srcExpr(input.url, 'audio')}, ${input.atPlayhead ? `Object.assign(${opts}, { timeOffset: Number(app.playbackTime) || 0 })` : opts});${input.volume !== undefined ? `
   // THE LEVEL IS STORED UNDER ONE KEY AND EXPORTED FROM ANOTHER. The upload
   // records volume as \`gain\` on the registry entry; the video exporter's mix
   // reads \`audioGain\`. So a bed uploaded at 0.25 exported at unity (measured:
@@ -9729,10 +9983,37 @@ ${guard}
   if (typeof A.setMediaClip !== 'function') { return { success: false, error: 'setMediaClip unavailable — update FxTool' }; }
 ${resolveMedia}
   if (!__m) return __miss;
-  const ok = A.setMediaClip(__mid, ${input.inPoint}, ${input.outPoint});
+${input.timeOffset !== undefined ? `  // Moving the clip is the 4th argument, which older studios' setMediaClip
+  // does not take (it dropped it silently): its declared arity is the tell.
+  if (A.setMediaClip.length < 4) {
+    return { success: false, action: 'set_clip', id: __mid, error: 'this studio can re-trim a clip but not move it (setMediaClip takes no start time here) — nothing was changed. Update the studio, or remove and re-upload the clip with timeOffset.' };
+  }
+` : ''}  const ok = A.setMediaClip(__mid, ${input.inPoint}, ${input.outPoint}${input.timeOffset !== undefined ? `, ${input.timeOffset}` : ''});
   return ok
-    ? { success: true, action: 'set_clip', id: __mid, registryId: __m.registryId, inPoint: ${input.inPoint}, outPoint: ${input.outPoint} }
+    ? { success: true, action: 'set_clip', id: __mid, registryId: __m.registryId, inPoint: ${input.inPoint}, outPoint: ${input.outPoint}${input.timeOffset !== undefined ? `, timeOffset: ${input.timeOffset}` : ''} }
     : { success: false, action: 'set_clip', id: __mid, error: 'the studio refused the clip window ${input.inPoint}–${input.outPoint} for ' + __mid + '.' };
+})();`.trim();
+            // Split and transitions (FxTool, verified on main): the engine's own
+            // refusals come back as {ok:false, reason} and are errors here.
+            case 'split':
+                return `
+// Split a media clip at canvas time ${input.at}
+(async function() {
+${guard}
+  if (typeof A.splitMedia !== 'function') { return { success: false, action: 'split', error: 'this studio is too old to split a clip (no splitMedia) — nothing was changed.' }; }
+  const r = await A.splitMedia(${JSON.stringify(input.id)}, ${input.at});
+  if (!r || r.ok === false) return { success: false, action: 'split', error: (r && r.reason) || 'the studio refused the split' };
+  return Object.assign({ success: true, action: 'split' }, r);
+})();`.trim();
+            case 'add_transition':
+                return `
+// ${input.transition?.type ?? 'crossfade'} between ${input.fromItemId} and ${input.toItemId}
+(function() {
+${guard}
+  if (typeof A.addTransition !== 'function') { return { success: false, action: 'add_transition', error: 'this studio is too old for clip transitions (no addTransition) — nothing was changed.' }; }
+  const r = A.addTransition(${JSON.stringify(input.fromItemId)}, ${JSON.stringify(input.toItemId)}, ${JSON.stringify(input.transition ?? {})});
+  if (!r || r.ok === false) return { success: false, action: 'add_transition', error: (r && r.reason) || 'the studio refused the transition' };
+  return Object.assign({ success: true, action: 'add_transition' }, r);
 })();`.trim();
             // ── Video-editing actions (v1.6.4) — these live on `app` (PinePaper
             // facades), not the agent media API, so they carry their own guards.
@@ -9742,15 +10023,18 @@ ${resolveMedia}
                 return `
 // Remap a clip's time — speed ramps, freeze frames, reverse (null clears)
 (function() {
+  // A media id (vraster_ / araster_, what upload returns) is resolved to the
+  // registry id these app facades take (round 10, 10.12).
+  const __reg = function(r) { const __A = window.PinePaperAgent; const __m = (__A && typeof __A.listMedia === 'function') ? __A.listMedia().find(function(x) { return x.id === r; }) : null; return (__m && __m.registryId) || r; };
   if (typeof app.setTimeRemap !== 'function') { return { success: false, error: 'app.setTimeRemap unavailable — update FxTool to a time-remap-capable build' }; }
-  const r = app.setTimeRemap(${S(input.id)}, ${S(input.remapTrack ?? null)});
+  const r = app.setTimeRemap(__reg(${S(input.id)}), ${S(input.remapTrack ?? null)});
   if (!(r && r.ok)) return { success: false, error: (r && r.error) || 'remap failed' };
   // WHAT THE REMAP CANNOT DO, READ BACK FROM WHAT WAS STORED. The clip is on
   // the timeline only for its trimmed window, and past that it is HIDDEN
   // whatever the curve says — a remap to 6.5 s on a 5 s clip cut to black at
   // 5.0 s. Source values outside [inPoint, outPoint] are clamped, so that part
   // of the curve is a hold. Both answered success before.
-  const __rid = typeof app._resolveId === 'function' ? app._resolveId(${S(input.id)}) : ${S(input.id)};
+  const __rid = typeof app._resolveId === 'function' ? app._resolveId(__reg(${S(input.id)})) : ${S(input.id)};
   const __e = __rid && app.itemRegistry && app.itemRegistry.get(__rid);
   const __p = (__e && __e.properties) || {};
   const __tr = Array.isArray(__p.timeRemap) ? __p.timeRemap : [];
@@ -9778,15 +10062,18 @@ ${resolveMedia}
                 return `
 // Speed ramp: consecutive {duration, speed} segments compiled to a remap curve
 (function() {
+  // A media id (vraster_ / araster_, what upload returns) is resolved to the
+  // registry id these app facades take (round 10, 10.12).
+  const __reg = function(r) { const __A = window.PinePaperAgent; const __m = (__A && typeof __A.listMedia === 'function') ? __A.listMedia().find(function(x) { return x.id === r; }) : null; return (__m && __m.registryId) || r; };
   if (typeof app.speedRamp !== 'function') { return { success: false, error: 'app.speedRamp unavailable — update FxTool to a time-remap-capable build' }; }
-  const r = app.speedRamp(${S(input.id)}, ${S(input.segments)});
+  const r = app.speedRamp(__reg(${S(input.id)}), ${S(input.segments)});
   if (!(r && r.ok)) return { success: false, error: (r && r.error) || 'speed ramp failed' };
   // WHAT THE REMAP CANNOT DO, READ BACK FROM WHAT WAS STORED. The clip is on
   // the timeline only for its trimmed window, and past that it is HIDDEN
   // whatever the curve says — a remap to 6.5 s on a 5 s clip cut to black at
   // 5.0 s. Source values outside [inPoint, outPoint] are clamped, so that part
   // of the curve is a hold. Both answered success before.
-  const __rid = typeof app._resolveId === 'function' ? app._resolveId(${S(input.id)}) : ${S(input.id)};
+  const __rid = typeof app._resolveId === 'function' ? app._resolveId(__reg(${S(input.id)})) : ${S(input.id)};
   const __e = __rid && app.itemRegistry && app.itemRegistry.get(__rid);
   const __p = (__e && __e.properties) || {};
   const __tr = Array.isArray(__p.timeRemap) ? __p.timeRemap : [];
@@ -9822,8 +10109,11 @@ ${resolveMedia}
                 return `
 // Match cut: align the SUBJECT across the cut (on-device detection)
 (async function() {
+  // A media id (vraster_ / araster_, what upload returns) is resolved to the
+  // registry id these app facades take (round 10, 10.12).
+  const __reg = function(r) { const __A = window.PinePaperAgent; const __m = (__A && typeof __A.listMedia === 'function') ? __A.listMedia().find(function(x) { return x.id === r; }) : null; return (__m && __m.registryId) || r; };
   if (typeof app.matchCut !== 'function') { return { success: false, error: 'app.matchCut unavailable — update FxTool to a match-cut-capable build' }; }
-  const r = await app.matchCut(${S(input.fromItemId)}, ${S(input.toItemId)}, ${opts});
+  const r = await app.matchCut(__reg(${S(input.fromItemId)}), __reg(${S(input.toItemId)}), ${opts});
   if (r && r.needsConsent) { return { success: false, needsConsent: true, cost: r.cost, error: 'Detection model download needs consent — re-call with consent: true' }; }
   if (!r || !r.ok) { return { success: false, error: (r && r.error) || 'match cut failed' }; }
   return { success: true, action: 'match_cut', aspectMismatch: r.aspectMismatch || false };
@@ -9841,9 +10131,12 @@ ${resolveMedia}
                 return `
 // Track matte: the matte item's ${input.channel || 'luma'} drives the target's alpha${input.live ? ' (LIVE — re-cuts as the matte animates)' : ''}
 (async function() {
+  // A media id (vraster_ / araster_, what upload returns) is resolved to the
+  // registry id these app facades take (round 10, 10.12).
+  const __reg = function(r) { const __A = window.PinePaperAgent; const __m = (__A && typeof __A.listMedia === 'function') ? __A.listMedia().find(function(x) { return x.id === r; }) : null; return (__m && __m.registryId) || r; };
   if (typeof app.applyTrackMatte !== 'function') { return { success: false, error: 'app.applyTrackMatte unavailable — update FxTool to a track-matte-capable build' }; }
   try {
-    await app.applyTrackMatte(${S(input.id)}, ${S(input.matteItemId)}, ${opts});
+    await app.applyTrackMatte(__reg(${S(input.id)}), __reg(${S(input.matteItemId)}), ${opts});
     return { success: true, action: 'apply_track_matte', id: ${S(input.id)}, matte: ${S(input.matteItemId)}, live: ${S(!!input.live)} };
   } catch (e) {
     // The facade throws on a missing raster/matte rather than returning {ok:false}.
@@ -9856,8 +10149,11 @@ ${resolveMedia}
                 return `
 // Stop a live matte, leaving the last cut in place
 (function() {
+  // A media id (vraster_ / araster_, what upload returns) is resolved to the
+  // registry id these app facades take (round 10, 10.12).
+  const __reg = function(r) { const __A = window.PinePaperAgent; const __m = (__A && typeof __A.listMedia === 'function') ? __A.listMedia().find(function(x) { return x.id === r; }) : null; return (__m && __m.registryId) || r; };
   if (typeof app.stopLiveMatte !== 'function') { return { success: false, error: 'app.stopLiveMatte unavailable — update FxTool' }; }
-  const r = app.stopLiveMatte(${S(input.id)});
+  const r = app.stopLiveMatte(__reg(${S(input.id)}));
   return r && r.ok ? { success: true, action: 'stop_live_matte' } : { success: false, error: (r && r.error) || 'no live matte on that item' };
 })();`.trim();
             }
@@ -11096,7 +11392,10 @@ ${guard(fn)}
             }
             case 'render_soundtrack': {
                 const opts = {
-                    ...(typeof input.options?.duration === 'number' ? { duration: input.options.duration } : {}),
+                    // A top-level duration was stripped by the schema and the render
+                    // used its default length, silently; both spellings are read now.
+                    ...(typeof input.duration === 'number' ? { duration: input.duration }
+                        : typeof input.options?.duration === 'number' ? { duration: input.options.duration } : {}),
                     ...(input.sampleRate !== undefined ? { sampleRate: input.sampleRate } : {}),
                     ...(input.bitDepth !== undefined ? { bitDepth: input.bitDepth } : {}),
                 };
@@ -11876,4 +12175,213 @@ ${guard('unlockAllItems')}${pass('app.unlockAllItems()')}
 }
 // Export singleton instance
 export const codeGenerator = new PinePaperCodeGenerator();
+/**
+ * WORDS ARE VECTOR (cloud: every generated plate is text-free; the words come
+ * back as textLayers). Lays them out as real PinePaper text over a placed
+ * plate, by role, inside title-safe (5%), sized from the canvas height:
+ * headline top-left (Anton by default, fitted to the safe width), subhead
+ * under it, caption / cta stacked up from the bottom-left, label top-right.
+ * Each text is checked against the plate's average colour under it (WCAG:
+ * 4.5:1, 3:1 for large text) and gets the lightest dark scrim that passes
+ * when it falls short. A body for pinepaper_execute_custom_code (async).
+ */
+export function emitTextLayersPlacement(layers, plateRef) {
+    const ROLE_FONT = { headline: 'Anton' };
+    const families = [...new Set(layers.map((l) => l.font || ROLE_FONT[l.role ?? ''] || 'Inter'))];
+    const fontBlocks = families.map((f) => `{${emitEnsureFont(f)}
+  if (__font) fonts.push(__font);
+}`).join('\n');
+    return `
+const fonts = [];
+${fontBlocks}
+const plate = (function(r) {
+  let it = app.getItemById(r);
+  if (!it && window.PinePaperAgent && typeof window.PinePaperAgent.listMedia === 'function') {
+    const m = window.PinePaperAgent.listMedia().find(function(x) { return x.id === r || x.registryId === r; });
+    if (m) it = app.getItemById(m.registryId);
+  }
+  return it;
+})(${JSON.stringify(plateRef)});
+const cs = app.getCanvasSize();
+const W = cs.width, H = cs.height, mx = Math.round(W * 0.05), my = Math.round(H * 0.05);
+const LAYERS = ${JSON.stringify(layers)};
+const SPEC = {
+  headline: { size: 0.075, font: 'Anton', where: 'top' },
+  subhead: { size: 0.036, font: 'Inter', where: 'top' },
+  caption: { size: 0.028, font: 'Inter', where: 'bottom' },
+  cta: { size: 0.032, font: 'Inter', where: 'bottom', bold: true },
+  label: { size: 0.022, font: 'Inter', where: 'topright' },
+};
+const lin = function(v) { return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4); };
+const make = function(l, spec, x, y, anchor) {
+  const size = Math.max(8, Math.round(H * spec.size));
+  const it = app.create('text', { content: l.content, x: x, y: y, fontSize: size, fontFamily: l.font || spec.font, color: '#ffffff', anchor: anchor });
+  if (!it) return null;
+  if (spec.bold) it.fontWeight = 'bold';
+  if (typeof app.fitText === 'function') {
+    try { app.fitText(it, { maxWidth: W - 2 * mx, maxFontSize: size, minFontSize: Math.max(8, Math.round(size * 0.4)), hold: anchor.indexOf('bottom') === 0 ? 'bottom' : 'top' }); } catch (_) { /* keeps its size */ }
+  }
+  return it;
+};
+const contrast = function(it, spec) {
+  if (!plate || typeof plate.getAverageColor !== 'function') return { checked: false, note: 'the plate is not an image the studio can sample (a video plate): contrast was not checked.' };
+  // The BRIGHT end of what is under the text, not its mean: a caption across
+  // bright reflections on a dark road averaged to 15:1 and was unreadable in
+  // the bright part. An 8 x 3 grid of cells, each averaged, judged at the
+  // 90th percentile of luminance.
+  const b0 = it.bounds, lums = [];
+  for (let gy = 0; gy < 3; gy++) {
+    for (let gx = 0; gx < 8; gx++) {
+      const cw = b0.width / 8, ch = b0.height / 3;
+      const cc = plate.getAverageColor(new paper.Rectangle(b0.left + gx * cw, b0.top + gy * ch, cw, ch));
+      if (cc) lums.push(0.2126 * lin(cc.red) + 0.7152 * lin(cc.green) + 0.0722 * lin(cc.blue));
+    }
+  }
+  if (!lums.length) return { checked: false };
+  lums.sort(function(x, y) { return x - y; });
+  const L = lums[Math.floor(0.9 * (lums.length - 1))];
+  const ratio = 1.05 / (L + 0.05);
+  const large = it.fontSize >= 24 || (spec.bold && it.fontSize >= 18.66);
+  const required = large ? 3 : 4.5;
+  const out = { checked: true, ratio: Math.round(ratio * 100) / 100, required: required, approximate: 'against the bright end (90th percentile of 24 sampled cells) of the plate behind the text' };
+  if (ratio >= required) return out;
+  // The lightest black scrim that reaches the requirement: under it the
+  // background luminance is L * (1 - a).
+  const a = Math.min(0.85, Math.max(0.2, 1 - (1.05 / required - 0.05) / L));
+  const pad = Math.round(it.fontSize * 0.35);
+  const b = it.bounds;
+  const s = app.create('rectangle', { x: b.left - pad, y: b.top - pad, width: b.width + 2 * pad, height: b.height + 2 * pad, color: '#000000', anchor: 'top-left' });
+  if (s) { s.opacity = a; if (typeof s.insertBelow === 'function') s.insertBelow(it); }
+  out.scrim = { itemId: s && s.data && s.data.registryId, opacity: Math.round(a * 100) / 100 };
+  out.ratioAfter = Math.round(1.05 / (L * (1 - a) + 0.05) * 100) / 100;
+  return out;
+};
+const role = function(l) { return SPEC[l.role] ? l.role : 'caption'; };
+const placed = [];
+let top = my;
+LAYERS.filter(function(l) { return SPEC[role(l)].where === 'top'; }).forEach(function(l) {
+  const spec = SPEC[role(l)];
+  const it = make(l, spec, mx, top, 'top-left');
+  if (!it) return;
+  top = it.bounds.bottom + Math.round(H * 0.015);
+  placed.push({ it: it, l: l, spec: spec });
+});
+let bottom = H - my;
+LAYERS.filter(function(l) { return SPEC[role(l)].where === 'bottom'; }).slice().reverse().forEach(function(l) {
+  const spec = SPEC[role(l)];
+  const it = make(l, spec, mx, bottom, 'bottom-left');
+  if (!it) return;
+  bottom = it.bounds.top - Math.round(H * 0.012);
+  placed.unshift({ it: it, l: l, spec: spec });
+});
+let rtop = my;
+LAYERS.filter(function(l) { return SPEC[role(l)].where === 'topright'; }).forEach(function(l) {
+  const spec = SPEC[role(l)];
+  const it = make(l, spec, W - mx, rtop, 'top-right');
+  if (!it) return;
+  rtop = it.bounds.bottom + Math.round(H * 0.01);
+  placed.push({ it: it, l: l, spec: spec });
+});
+if (app.historyManager) app.historyManager.saveState();
+return {
+  textItems: placed.map(function(p) {
+    return { itemId: p.it.data && p.it.data.registryId, role: role(p.l), content: p.l.content, fontFamily: p.it.fontFamily, fontSize: Math.round(p.it.fontSize), contrast: contrast(p.it, p.spec) };
+  }),
+  fonts: fonts,
+};`;
+}
+/**
+ * AUTO-KEY FROM AN AGENT (plan C5a): "at t, make it orange" writes a key at t,
+ * the way a user's drag does with auto-key on — not a static edit.
+ *
+ * The key is MERGED into the item's track (addAnimation mode 'merge'): other
+ * keys stay. So the track stays whole:
+ * - the new key also carries every OTHER animated property's value at t
+ *   (getInterpolatedState), because a key missing a property the others
+ *   animate can break that property's curve;
+ * - a property the track did not animate yet is added to every existing key
+ *   (its old value before t, the new one from t), and a first key at 0 holds
+ *   the old value, so the change eases in from what it was instead of
+ *   jumping.
+ * No duration is passed: addAnimation starts timeline playback when given one.
+ * The result names each property's previous value and what was written.
+ */
+export function generateAutoKeyCode(itemId, props, atTime, easing) {
+    return `
+// Auto-key ${itemId} at ${atTime}s
+(function() {
+  const item = app.getItemById(${JSON.stringify(itemId)});
+  if (!item) return { success: false, error: ${JSON.stringify(`no item "${itemId}" on the canvas — check the id with pinepaper_get_items.`)} };
+  if (typeof app.addAnimation !== 'function') return { success: false, error: 'this studio cannot write keyframes (no addAnimation).' };
+  const AT = ${atTime};
+  const NEW = ${JSON.stringify(props)};
+  const track = (item.data && Array.isArray(item.data.keyframes)) ? item.data.keyframes : [];
+  const animated = track.reduce(function(a, k) { Object.keys((k && k.properties) || {}).forEach(function(p) { if (a.indexOf(p) < 0) a.push(p); }); return a; }, []);
+  // The static value of a property the track does not animate yet.
+  const read = function(p) {
+    const c = function(v) { return v && typeof v.toCSS === 'function' ? v.toCSS(true) : v; };
+    if (p === 'x') return item.position && item.position.x;
+    if (p === 'y') return item.position && item.position.y;
+    if (p === 'scale') return item.scaling ? item.scaling.x : 1;
+    if (p === 'scaleX') return item.scaling ? item.scaling.x : 1;
+    if (p === 'scaleY') return item.scaling ? item.scaling.y : 1;
+    if (p === 'color' || p === 'fillColor') return c(item.fillColor);
+    if (p === 'strokeColor') return c(item.strokeColor);
+    if (p === 'width') return item.bounds && item.bounds.width;
+    if (p === 'height') return item.bounds && item.bounds.height;
+    const v = item[p];
+    return (v === undefined || typeof v === 'function') ? undefined : c(v);
+  };
+  const state = (track.length && typeof app.getInterpolatedState === 'function') ? (app.getInterpolatedState(item, AT) || {}) : {};
+  const byTime = {};
+  const put = function(t, p, v, e) { const k = byTime[t] || (byTime[t] = { time: t, properties: {} }); k.properties[p] = v; if (e) k.easing = e; };
+  const changes = [];
+  Object.keys(NEW).forEach(function(p) {
+    const wasAnimated = animated.indexOf(p) >= 0;
+    const before = wasAnimated ? state[p] : read(p);
+    if (!wasAnimated && before !== undefined) {
+      track.forEach(function(k) { put(k.time, p, k.time < AT ? before : NEW[p]); });
+      if (!track.length && AT > 0) put(0, p, before);
+    }
+    changes.push({ property: p, before: before === undefined ? null : before, after: NEW[p], easedFrom: before === undefined ? 'unknown — keyed at t only' : (wasAnimated ? 'the track' : 'its value before t') });
+  });
+  // The key at t: the new values, plus every other animated property as it is at t.
+  animated.forEach(function(p) { if (!(p in NEW) && state[p] !== undefined) put(AT, p, state[p]); });
+  Object.keys(NEW).forEach(function(p) { put(AT, p, NEW[p], ${JSON.stringify(easing ?? null)}); });
+  const keys = Object.keys(byTime).map(function(t) { return byTime[t]; }).sort(function(a, b) { return a.time - b.time; });
+  const beforeTimes = track.map(function(k) { return k.time; });
+  app.addAnimation(${JSON.stringify(itemId)}, keys, { mode: 'merge' });
+  const after = (item.data && Array.isArray(item.data.keyframes)) ? item.data.keyframes : [];
+  const kept = beforeTimes.every(function(t) { return after.some(function(k) { return k.time === t; }); });
+  if (!kept) return { success: false, error: 'this studio replaced the track instead of merging into it (no merge mode): the earlier keys are gone. Put every key in one keyframe_animate call.', atTime: AT };
+  if (app.historyManager) app.historyManager.saveState();
+  return { success: true, itemId: ${JSON.stringify(itemId)}, atTime: AT, autoKeyed: true, changes: changes, keys: after.length,
+    note: 'written as keyframes (a temporal edit), not a static change; pinepaper_query_mutations shows the series.' };
+})();`.trim();
+}
+/**
+ * A property's time series (plan C5a): the item's own keyframe track, read
+ * back. Until the engine keeps a mutation log (C3) this is the keys, not the
+ * history of who changed what — the result says so.
+ */
+export function generateQueryMutationsCode(itemId, property, range, fps = 30) {
+    return `
+// Keyframe series for ${itemId}${property ? '.' + property : ''}
+(function() {
+  const item = app.getItemById(${JSON.stringify(itemId)});
+  if (!item) return { success: false, error: ${JSON.stringify(`no item "${itemId}" on the canvas.`)} };
+  const P = ${JSON.stringify(property ?? null)}, R = ${JSON.stringify(range ?? null)}, FPS = ${fps};
+  const track = (item.data && Array.isArray(item.data.keyframes)) ? item.data.keyframes : [];
+  const series = {};
+  track.forEach(function(k) {
+    if (R && (k.time < R[0] || k.time > R[1])) return;
+    Object.keys((k && k.properties) || {}).forEach(function(p) {
+      if (P && p !== P) return;
+      (series[p] = series[p] || []).push({ t: k.time, frame: Math.round(k.time * FPS), value: k.properties[p], easing: k.easing || null });
+    });
+  });
+  return { success: true, itemId: ${JSON.stringify(itemId)}, source: 'keyframes', series: series, keys: track.length,
+    note: 'the item\\'s keyframe track, read back. Who changed what and the before value per edit need the studio\\'s mutation log, which this studio does not expose yet.' };
+})();`.trim();
+}
 //# sourceMappingURL=code-generator.js.map