@engine-room/after-effects-mcp 0.5.0 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@engine-room/after-effects-mcp",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "type": "module",
   "description": "Control Adobe After Effects with AI — describe the animation you want and it gets built: layers, keyframes, effects, expressions and text, all editable afterwards.",
   "license": "MIT",
@@ -52,7 +52,7 @@
     "clean": "rm -rf dist bin panel"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.4",
+    "@modelcontextprotocol/sdk": "^1.32.0",
     "ws": "^8.21.3",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5"

package/panel/CSXS/manifest.xml

@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<ExtensionManifest Version="11.0" ExtensionBundleId="games.engine-room.ae-mcp" ExtensionBundleVersion="0.5.0"
+<ExtensionManifest Version="11.0" ExtensionBundleId="games.engine-room.ae-mcp" ExtensionBundleVersion="0.5.2"
                    ExtensionBundleName="AE MCP Bridge" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
   <ExtensionList>
-    <Extension Id="games.engine-room.ae-mcp.panel" Version="0.5.0" />
+    <Extension Id="games.engine-room.ae-mcp.panel" Version="0.5.2" />
   </ExtensionList>
   <ExecutionEnvironment>
     <HostList>

package/panel/client/main.js

@@ -234,6 +234,75 @@
     } catch (e) {}
   }
 
+  // ---------- Bridge token (issue #106) ----------
+  // Why a token and not a CORS rule, and why per port: docs/fragile-areas-bridge.md.
+  // One per panel session. 384 is 0600 for engines that predate 0o literals.
+  var sessionToken = crypto.randomBytes(32).toString("hex");
+  var TOKEN_MODE = 384;
+
+  function tokenFile(port) { return path.join(portDir, "token-" + port); }
+
+  function writeTokenFile(port) {
+    try { fs.mkdirSync(portDir, { recursive: true }); } catch (e) {}
+    try {
+      fs.writeFileSync(tokenFile(port), sessionToken, { encoding: "utf8", mode: TOKEN_MODE });
+      // writeFileSync applies `mode` only when it creates the file.
+      try { fs.chmodSync(tokenFile(port), TOKEN_MODE); } catch (e) {}
+    } catch (e) {
+      log("error", "could not write the bridge token file " + tokenFile(port) + ": " + e.message +
+        " — the MCP server will not be able to authenticate, and every tool call will be refused.");
+    }
+  }
+
+  // Same rule as the port file: only this panel's own entry.
+  function removeTokenFile(port) {
+    try {
+      if (fs.readFileSync(tokenFile(port), "utf8").trim() === sessionToken) fs.unlinkSync(tokenFile(port));
+    } catch (e) {}
+  }
+
+  function sameToken(given) {
+    if (typeof given !== "string" || given.length !== sessionToken.length) return false;
+    try {
+      return crypto.timingSafeEqual(Buffer.from(given, "utf8"), Buffer.from(sessionToken, "utf8"));
+    } catch (e) {
+      return false;
+    }
+  }
+
+  // The token is what holds. The Origin check is depth: browsers always send one,
+  // Node's fetch and `ws` never do.
+  function authFailure(req) {
+    var h = (req && req.headers) || {};
+    if (h.origin) return "it came from a web page (Origin: " + h.origin + ")";
+    if (!sameToken(h["x-ae-mcp-token"])) return "the bridge token was missing or did not match";
+    return null;
+  }
+
+  // Written for an MCP server older than this panel: it relays `error` verbatim,
+  // so the remedy has to be in here.
+  function denialMessage() {
+    return "This After Effects bridge requires a token and this request did not carry a valid one. " +
+      "Nothing was run in After Effects. The panel writes the token beside its port file, in " + portDir +
+      ", each time it binds; a local process can read it and a web page cannot, which is the entire point " +
+      "(issue #106). If you are the MCP server: you are older than the panel After Effects is running — " +
+      "update after-effects-mcp to 0.5.1 or newer and reconnect it.";
+  }
+
+  // Rate-limited: a page firing in a loop must not fill the panel's log.
+  var denied = 0;
+  var deniedLoggedAt = 0;
+  function noteDenial(what, why) {
+    denied += 1;
+    var now = Date.now();
+    if (denied === 1 || now - deniedLoggedAt > 10000) {
+      deniedLoggedAt = now;
+      log("warn", "refused a request to " + what + ": " + why +
+        (denied > 1 ? " (" + denied + " refused so far)" : "") +
+        ". If this is the MCP server rather than a web page, it is older than this panel: update it and reconnect.");
+    }
+  }
+
   // ---------- Config ----------
   // A CEP panel cannot read an environment variable the user set: it runs in
   // After Effects' process, with Adobe's environment. So its two knobs live in
@@ -864,8 +933,9 @@
     return new Promise(function (resolve, reject) {
       var server = http.createServer(function (req, res) {
         var url = req.url || "/";
-        res.setHeader("Access-Control-Allow-Origin", "*");
-        res.setHeader("Access-Control-Allow-Headers", "content-type");
+
+        // No CORS headers, deliberately: nothing that legitimately calls this
+        // bridge is a web page (issue #106).
 
         if (url === "/health") {
           res.statusCode = 200;
@@ -883,6 +953,10 @@
             port: addr && addr.port ? addr.port : port,
             bundleLoaded: true,
             bundleHash: loadedBundleHash,
+            // The gate exists, never anything about the token. Absent on a
+            // pre-#106 panel, which is how the server tells "needs a token"
+            // from "too old to want one".
+            auth: true,
             ts: Date.now()
           }));
           return;
@@ -893,6 +967,17 @@
           return;
         }
 
+        // Every route below reaches After Effects. Checked before the body is
+        // read, so an unidentified caller cannot make us buffer anything.
+        var denial = authFailure(req);
+        if (denial) {
+          noteDenial(url, denial);
+          res.statusCode = 403;
+          res.setHeader("content-type", "application/json");
+          res.end(JSON.stringify({ ok: false, error: denialMessage(), code: "bridge_unauthorized" }));
+          return;
+        }
+
         var bufs = [];
         req.on("data", function (c) { bufs.push(c); });
         req.on("end", function () {
@@ -1017,8 +1102,22 @@
       return startHttp(p).then(function (server) {
         // Read back rather than assumed: port 0 binds an ephemeral one.
         var bound = server.address().port;
+        // The socket is already accepting, so the token must be on disk before
+        // this promise resolves — not later in the boot.
+        writeTokenFile(bound);
         // Mount WS on the same HTTP server.
-        var wss = new WebSocket.Server({ server: server, path: "/events" });
+        var wss = new WebSocket.Server({
+          server: server,
+          path: "/events",
+          // WebSockets ignore the same-origin policy entirely, so without this
+          // any page could watch the user's event stream (issue #106).
+          verifyClient: function (info, cb) {
+            var why = authFailure(info.req);
+            if (!why) return cb(true);
+            noteDenial("/events", why);
+            cb(false, 403, "Forbidden");
+          },
+        });
         wss.on("connection", function (ws) {
           wsClients.add(ws);
           ws.on("close", function () { wsClients.delete(ws); });
@@ -1097,6 +1196,7 @@
     try { if (typeof s.server.closeAllConnections === "function") s.server.closeAllConnections(); } catch (e) {}
     try { s.server.close(); } catch (e) {}
     removePortFile(s.port);
+    removeTokenFile(s.port);
   }
   if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
     window.addEventListener("beforeunload", shutdown);
@@ -1126,6 +1226,7 @@
       setStatus("ready", "ok");
       log("info", "Bridge listening on http://127.0.0.1:" + s.port +
         (s.port !== config.port && config.port !== 0 ? " (configured port " + config.port + " was taken — see above)" : ""));
+      log("info", "Calls are authenticated: the MCP server reads this session's token from " + tokenFile(s.port) + ".");
     })
     .catch(function (e) {
       setStatus("failed", "err");

package/panel/jsx/bundle.jsx

@@ -934,7 +934,10 @@ function __ptLocalMatrix(l, t) {
 function __ptChain(l, t, depth) {
   if (!l) return { ok: true, m: __ptMId(), wb: [0, 0], animated: false };
   if (depth > 32) return { ok: false, reason: "parent chain deeper than 32 layers" };
-  if (!(l instanceof AVLayer)) return { ok: false, reason: 'a camera or light in the chain ("' + l.name + '") has no 2D transform' };
+  // Name the exclusions rather than testing for AVLayer: in ExtendScript a
+  // ShapeLayer or TextLayer is not `instanceof AVLayer`, despite Adobe's class
+  // docs, so that test refused every shape and text layer as a "camera" (#120).
+  if (l instanceof CameraLayer || l instanceof LightLayer) return { ok: false, reason: 'a camera or light in the chain ("' + l.name + '") has no 2D transform' };
   if (l.threeDLayer) return { ok: false, reason: 'a 3D layer in the chain ("' + l.name + '")' };
   var up = __ptChain(l.parent, t, depth + 1);
   if (!up.ok) return up;
@@ -2142,10 +2145,61 @@ OPS.clear_expression = function (args) {
 
 // effects.jsx — effect graph ops.
 
-function __serializeEffect(eff) {
-  var out = { name: eff.name, matchName: eff.matchName, enabled: eff.enabled, index: eff.propertyIndex, params: [] };
-  for (var i = 1; i <= eff.numProperties; i++) {
+// Effect parameters are bounded by default (issue #115). Every built-in
+// effect has under 15 parameters and the heaviest common third-party ones
+// (Saber, Warp Stabilizer) under 100, but Trapcode Particular exposes 7,401 —
+// one list_effects on it was 1 MB, ~265k tokens, re-sent on every later
+// request. 200 returns every ordinary effect whole and caps a pathological one
+// at a few thousand tokens. This is a deliberate exception to "absent means
+// everything", the same way find_layers' bounded default is: what is left out
+// is always counted (paramCount, paramsOmitted) and named (paramsTruncated),
+// so a capped effect never passes for a complete one.
+var __EFFECT_PARAMS_DEFAULT = 200;
+
+// One parse of maxParams/paramFilter per call, shared by every effect in it.
+// paramFilter is a case-insensitive regex over each parameter's name and
+// matchName, the same convention as find_layers' name filter.
+function __effectParamOpts(args) {
+  var max = (args && args.maxParams > 0) ? args.maxParams : __EFFECT_PARAMS_DEFAULT;
+  var re = null;
+  if (args && typeof args.paramFilter === "string" && args.paramFilter.length > 0) {
+    try { re = new RegExp(args.paramFilter, "i"); }
+    catch (e) { throw new Error("paramFilter is not a valid regular expression: " + args.paramFilter); }
+  }
+  return { maxParams: max, paramFilter: re, paramFilterSource: re ? args.paramFilter : null };
+}
+
+function __paramsTruncationNote(total, returned, matched, popts) {
+  if (popts.paramFilter) {
+    var head = "paramFilter /" + popts.paramFilterSource + "/ matched " + matched + " of " + total + " parameters";
+    if (matched > returned) {
+      return head + "; first " + returned + " returned, " + (matched - returned) + " more matches omitted — raise maxParams";
+    }
+    return head + "; the other " + (total - matched) + " omitted";
+  }
+  return "first " + returned + " of " + total + " parameters; " + (total - returned) + " omitted — raise maxParams " +
+    "(up to " + total + "), or pass paramFilter, a regex over parameter name/matchName, to read only the ones you need";
+}
+
+// `popts` comes from __effectParamOpts; absent means the default cap, never
+// "everything".
+function __serializeEffect(eff, popts) {
+  if (!popts) popts = __effectParamOpts(null);
+  var max = popts.maxParams;
+  var re = popts.paramFilter;
+  var total = eff.numProperties;
+  var out = { name: eff.name, matchName: eff.matchName, enabled: eff.enabled, index: eff.propertyIndex, paramCount: total, params: [] };
+  var matched = 0;
+  for (var i = 1; i <= total; i++) {
     var p = eff.property(i);
+    if (re && !(re.test(p.name) || re.test(p.matchName))) continue;
+    matched++;
+    if (out.params.length >= max) {
+      // Unfiltered, the rest is only counted, so stop walking; filtered, keep
+      // going so the matched count is exact.
+      if (!re) break;
+      continue;
+    }
     var entry = { name: p.name, matchName: p.matchName, propertyType: String(p.propertyType) };
     try { entry.value = p.value; } catch (e) {}
     if (p.canSetExpression && p.expression) entry.expression = p.expression;
@@ -2157,6 +2211,13 @@ function __serializeEffect(eff) {
     }
     out.params.push(entry);
   }
+  if (re) out.paramsMatched = matched;
+  else matched = total;
+  var omitted = total - out.params.length;
+  if (omitted > 0) {
+    out.paramsOmitted = omitted;
+    out.paramsTruncated = __paramsTruncationNote(total, out.params.length, matched, popts);
+  }
   return out;
 }
 
@@ -2165,39 +2226,109 @@ OPS.list_effects = noUndo(function (args) {
   var l = getLayerById(c, args.layerId);
   var fx = l.property("Effects");
   if (!fx) return [];
+  var popts = __effectParamOpts(args);
   var out = [];
-  for (var i = 1; i <= fx.numProperties; i++) out.push(__serializeEffect(fx.property(i)));
+  for (var i = 1; i <= fx.numProperties; i++) out.push(__serializeEffect(fx.property(i), popts));
   return out;
 });
 
+// The new effect comes back under the default parameter cap: adding Particular
+// should not return 265k tokens nobody asked to read.
 OPS.add_effect = function (args) {
   var c = getCompById(args.compId);
   var l = getLayerById(c, args.layerId);
   var fx = l.property("Effects");
   var eff = fx.addProperty(args.matchName);
-  return __serializeEffect(eff);
+  return __serializeEffect(eff, __effectParamOpts(null));
 };
 
 OPS.remove_effect = function (args) {
   var c = getCompById(args.compId);
   var l = getLayerById(c, args.layerId);
-  var fx = l.property("Effects");
-  fx.property(args.effectIndex).remove();
+  __effectAt(l, args.effectIndex).remove();
   return { ok: true };
 };
 
+// Resolve an effect by its 1-based index, or say what is there. A bare
+// `property(n)` past the end answers null and the caller's next line throws a
+// TypeError that names nothing. The group is looked up by matchName, which is
+// the same in every UI language.
+function __effectAt(layer, index) {
+  var fx = layer.property("ADBE Effect Parade");
+  var n = fx ? fx.numProperties : 0;
+  var eff = (fx && index >= 1 && index <= n) ? fx.property(index) : null;
+  if (!eff) {
+    throw new Error(
+      "No effect at effectIndex " + index + " on layer '" + layer.name + "': it has " + n +
+      " effect" + (n === 1 ? "" : "s") + ". list_effects reports each one with its index."
+    );
+  }
+  return eff;
+}
+
+// The cap on parameters named in a miss. Most effects have under twenty; a
+// Trapcode-sized one has thousands, and the error must not become the payload.
+var __PARAM_LIST_CAP = 40;
+
+// Issue #121. `Property.property(name)` matches the display name in the UI's
+// language only, so an English 'Distance' is null on a zh_CN After Effects
+// while 'ADBE Drop Shadow-0004' resolves everywhere. The display-name lookup
+// stays (it is what a localised user would type), but a miss now names the
+// effect, lists what it does have, and points at the language-proof field.
+function __findEffectParam(eff, args) {
+  var i;
+  if (args.paramMatchName) {
+    for (i = 1; i <= eff.numProperties; i++) {
+      if (eff.property(i).matchName === args.paramMatchName) return eff.property(i);
+    }
+  }
+  if (args.paramName) {
+    var p = null;
+    try { p = eff.property(args.paramName); } catch (e) { p = null; }
+    if (p) return p;
+    // A case slip is not a localisation problem; forgive it before failing.
+    var want = String(args.paramName).toLowerCase();
+    for (i = 1; i <= eff.numProperties; i++) {
+      if (String(eff.property(i).name).toLowerCase() === want) return eff.property(i);
+    }
+  }
+  return null;
+}
+
+function __effectParamMissMessage(eff, args, lang) {
+  var asked = [];
+  if (args.paramMatchName) asked.push("paramMatchName '" + args.paramMatchName + "'");
+  if (args.paramName) asked.push("paramName '" + args.paramName + "'");
+  var msg = "Effect '" + eff.name + "' (" + eff.matchName + ") has no parameter matching " + asked.join(" or ") + ".";
+
+  var n = eff.numProperties;
+  var shown = [];
+  for (var i = 1; i <= n && shown.length < __PARAM_LIST_CAP; i++) {
+    var q = eff.property(i);
+    shown.push("'" + q.name + "' = " + q.matchName);
+  }
+  msg += " Its parameters (name = matchName): " + shown.join("; ");
+  if (n > shown.length) msg += "; ... and " + (n - shown.length) + " more not listed (list_effects has them all)";
+  msg += ".";
+
+  if (args.paramName) {
+    msg += " Display names are in After Effects' UI language";
+    if (lang && lang !== "en_US") msg += ", and this one runs in " + lang + ", so an English name will not match";
+    msg += ". Use paramMatchName instead: it is the same in every language.";
+  }
+  return msg;
+}
+
 OPS.set_effect_param = function (args) {
   var c = getCompById(args.compId);
   var l = getLayerById(c, args.layerId);
-  var eff = l.property("Effects").property(args.effectIndex);
-  var p = null;
-  if (args.paramMatchName) {
-    for (var i = 1; i <= eff.numProperties; i++) {
-      if (eff.property(i).matchName === args.paramMatchName) { p = eff.property(i); break; }
-    }
+  var eff = __effectAt(l, args.effectIndex);
+  var p = __findEffectParam(eff, args);
+  if (!p) {
+    var lang = null;
+    try { lang = app.isoLanguage; } catch (e) { lang = null; }
+    throw new Error(__effectParamMissMessage(eff, args, lang));
   }
-  if (!p && args.paramName) p = eff.property(args.paramName);
-  if (!p) throw new Error("Effect param not found");
   if (args.keyframe && args.time !== undefined) p.setValueAtTime(args.time, args.value);
   else if (args.time !== undefined && p.numKeys > 0) p.setValueAtTime(args.time, args.value);
   else p.setValue(args.value);
@@ -2207,7 +2338,7 @@ OPS.set_effect_param = function (args) {
 OPS.set_effect_enabled = function (args) {
   var c = getCompById(args.compId);
   var l = getLayerById(c, args.layerId);
-  l.property("Effects").property(args.effectIndex).enabled = !!args.enabled;
+  __effectAt(l, args.effectIndex).enabled = !!args.enabled;
   return { ok: true };
 };
 
@@ -2783,18 +2914,38 @@ function __resolveDownsample(comp, requested) {
 // afterwards. That is faster (a quarter of the pixels at factor 2) and needs no
 // external image tool, which is what makes it work off macOS.
 //
-// Factor 1 is *set*, not skipped. Skipping it rendered at whatever the user had
-// left the viewer on, so a comp parked at Quarter answered `downsample: 1` with
-// a quarter-size frame and `downsample: 2` came back **larger** than
-// `downsample: 1` (issue #72). Designers leave heavy comps at Quarter or Third
-// as a matter of course, so that was the common case rather than a corner. The
-// panel reads the real dimensions out of the PNG's IHDR, which means the
-// response stayed honest while the *picture* was not the one asked for — the
-// worse of the two failures, because an agent that can see a frame believes it.
-// Every factor reaching this function now names the resolution it renders at.
+// The factor always *names* the resolution the render happens at. Leaving it to
+// the viewer rendered at whatever the user had left the Resolution dropdown on,
+// so a comp parked at Quarter answered `downsample: 1` with a quarter-size frame
+// and `downsample: 2` came back **larger** than `downsample: 1` (issue #72).
+// Designers leave heavy comps at Quarter or Third as a matter of course, so that
+// was the common case rather than a corner. The panel reads the real dimensions
+// out of the PNG's IHDR, which means the response stayed honest while the
+// *picture* was not the one asked for — the worse of the two failures, because
+// an agent that can see a frame believes it.
+//
+// What is skipped is only the *assignment*, and only when the comp is already
+// at the factor asked for. Every assignment to resolutionFactor is its own undo
+// step in After Effects ("Resolution change"), so set-and-restore cost two steps
+// per rendered frame — ten for one frame plus a four-tile sheet — and buried the
+// user's real edits under no-ops (issue #116). When the factor already matches,
+// the render happens at the requested resolution with nothing assigned, which
+// keeps #72's guarantee and leaves the project untouched.
+function __factorIs(rf, f) {
+  return !!rf && rf[0] === f && rf[1] === f;
+}
+
+function __factorFor(factor) {
+  return (factor > 1) ? Math.round(factor) : 1;
+}
+
 function __saveFrameAt(comp, time, file, factor) {
-  var f = (factor > 1) ? Math.round(factor) : 1;
+  var f = __factorFor(factor);
   var previous = comp.resolutionFactor;
+  if (__factorIs(previous, f)) {
+    comp.saveFrameToPng(time, file);
+    return;
+  }
   try {
     comp.resolutionFactor = [f, f];
     comp.saveFrameToPng(time, file);
@@ -2806,6 +2957,32 @@ function __saveFrameAt(comp, time, file, factor) {
   }
 }
 
+// The one undo step a screenshot is allowed to cost (issue #116).
+//
+// A screenshot changes nothing, but it has to *borrow* the comp's resolution
+// and, for screenshot_layer, every layer's solo switch — and After Effects
+// records each of those assignments as its own step, restore included. Grouped,
+// the borrow and the restore collapse into one step the user can recognise by
+// name in Edit > History, instead of 2 + 2N anonymous ones.
+//
+// Three rules, all of which the tests hold:
+//   * no group at all when nothing will be assigned — a comp already at the
+//     requested factor, e.g. Full at downsample 1 — so that case costs zero steps;
+//   * no group of our own when one of ours is already open (a screenshot inside
+//     run_batch, or the dispatcher's group around another op): AE's groups do
+//     not nest, and an inner endUndoGroup would close the outer one and leave
+//     the rest of that batch ungrouped. The borrow joins the step already open;
+//   * the group goes through withUndo, so it opens and closes inside this one
+//     evalScript call and is counted by __beginUndoGroup like every other.
+// The ops stay `noUndo` at the dispatcher for exactly this reason: the decision
+// depends on the comp's state, which dispatch() cannot see.
+var __SCREENSHOT_UNDO_NAME = "AE MCP: screenshot";
+
+function __screenshotGroup(needed, fn) {
+  if (!needed || __UNDO_OPEN) return fn();
+  return withUndo(__SCREENSHOT_UNDO_NAME, fn);
+}
+
 // Several times in one call. Every requested time gets an entry, in order,
 // whether or not it rendered — the panel draws a marked block for the ones that
 // did not, so the sheet it composes still lines up with the times that were
@@ -2820,18 +2997,22 @@ function __contactSheetFrames(comp, args) {
     ds = __clampDownsample(args.downsample);
   }
   var tiles = [];
-  for (var i = 0; i < times.length; i++) {
-    var entry = { time: times[i], downsample: ds };
-    try {
-      var p = __tmpPngPath();
-      __saveFrameAt(comp, times[i], new File(p), ds);
-      entry.path = p;
-    } catch (e) {
-      // One time that will not render must not cost the other five.
-      entry.error = String(e && e.message ? e.message : e);
+  // Every tile renders at the same factor, so the whole sheet is one undo step
+  // at most rather than two per tile.
+  __screenshotGroup(!__factorIs(comp.resolutionFactor, __factorFor(ds)), function () {
+    for (var i = 0; i < times.length; i++) {
+      var entry = { time: times[i], downsample: ds };
+      try {
+        var p = __tmpPngPath();
+        __saveFrameAt(comp, times[i], new File(p), ds);
+        entry.path = p;
+      } catch (e) {
+        // One time that will not render must not cost the other five.
+        entry.error = String(e && e.message ? e.message : e);
+      }
+      tiles.push(entry);
     }
-    tiles.push(entry);
-  }
+  });
   return {
     contactSheet: true,
     tiles: tiles,
@@ -2849,7 +3030,9 @@ OPS.screenshot_frame = noUndo(function (args) {
   var path = __tmpPngPath();
   var f = new File(path);
   // saveFrameToPng is async-ish; the panel polls the file's existence/size.
-  __saveFrameAt(c, t, f, ds);
+  __screenshotGroup(!__factorIs(c.resolutionFactor, __factorFor(ds)), function () {
+    __saveFrameAt(c, t, f, ds);
+  });
   return {
     path: path,
     width: c.width, height: c.height,
@@ -2862,26 +3045,35 @@ OPS.screenshot_layer = noUndo(function (args) {
   var c = getCompById(args.compId);
   var l = getLayerById(c, args.layerId);
   var t = (args.time !== undefined && args.time !== null) ? args.time : c.time;
-  // Capture all current solo states; solo target; capture; restore.
-  var prevSolo = [];
+  // Solo the target alone, render, put every switch back. Only the switches
+  // that are actually wrong get assigned: each assignment is an undo step of
+  // its own, and a layer already in the right state has nothing to restore.
+  var changed = [];
   for (var i = 1; i <= c.numLayers; i++) {
     var ll = c.layer(i);
-    prevSolo.push({ idx: i, solo: ll.solo });
-    ll.solo = false;
+    var want = (ll.id === l.id);
+    if (ll.solo !== want) changed.push({ layer: ll, was: ll.solo, want: want });
   }
-  l.solo = true;
   var ds = __resolveDownsample(c, args.downsample);
   var path = __tmpPngPath();
   var f = new File(path);
-  try {
-    __saveFrameAt(c, t, f, ds);
-  } finally {
-    // restore
-    l.solo = false;
-    for (var j = 0; j < prevSolo.length; j++) {
-      try { c.layer(prevSolo[j].idx).solo = prevSolo[j].solo; } catch (e) {}
+  var needed = changed.length > 0 || !__factorIs(c.resolutionFactor, __factorFor(ds));
+  __screenshotGroup(needed, function () {
+    // Inside the try, so a switch AE refuses part-way still restores the ones
+    // that were already flipped.
+    var applied = 0;
+    try {
+      for (var k = 0; k < changed.length; k++) {
+        changed[k].layer.solo = changed[k].want;
+        applied = k + 1;
+      }
+      __saveFrameAt(c, t, f, ds);
+    } finally {
+      for (var j = applied - 1; j >= 0; j--) {
+        try { changed[j].layer.solo = changed[j].was; } catch (e) {}
+      }
     }
-  }
+  });
   return {
     path: path,
     width: c.width, height: c.height,
@@ -4956,9 +5148,10 @@ function __serializeTransformGroup(tg, opts) {
   return out;
 }
 
-// The cap is applied after the fact rather than inside __serializeEffect,
-// which effects.jsx also uses for list_effects and add_effect — those return
-// one effect and have no size problem to solve.
+// The keyframe cap is applied after the fact rather than inside
+// __serializeEffect, which effects.jsx also uses for list_effects and
+// add_effect. The parameter cap (maxParams/paramFilter, issue #115) is applied
+// inside it, by all three.
 function __capEffectKeyframes(effects, max) {
   if (!(max > 0)) return effects;
   for (var i = 0; i < effects.length; i++) {
@@ -4986,7 +5179,8 @@ function __serializeEffects(layer, opts) {
   var fx = layer.property("Effects");
   if (!fx || fx.numProperties === 0) return [];
   var arr = [];
-  for (var i = 1; i <= fx.numProperties; i++) arr.push(__serializeEffect(fx.property(i)));
+  var popts = (opts && opts.effectParams) ? opts.effectParams : __effectParamOpts(null);
+  for (var i = 1; i <= fx.numProperties; i++) arr.push(__serializeEffect(fx.property(i), popts));
   return __capEffectKeyframes(arr, (opts && opts.maxKeyframes) ? opts.maxKeyframes : 0);
 }
 
@@ -5276,6 +5470,8 @@ OPS.get_layer_full = noUndo(function (args) {
   // absent by default, and absent means "everything", exactly as before.
   var want = (args && args.include) ? args.include : null;
   var opts = { maxKeyframes: (args && args.maxKeyframes > 0) ? args.maxKeyframes : 0 };
+  // Effect parameters are the exception: bounded by default (issue #115).
+  if (__wantsSection(want, "effects")) opts.effectParams = __effectParamOpts(args);
   var out = {
     id: l.id,
     index: l.index,

package/panel/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@engineroom/ae-panel",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "private": true,
   "description": "Invisible CEP extension hosting an HTTP+WS bridge inside After Effects.",
   "dependencies": {