@engine-room/after-effects-mcp 0.1.0

package/panel/jsx/bundle.jsx

@@ -0,0 +1,1562 @@
+// Auto-generated bundle. Do not edit directly — edit files in packages/jsx/.
+// Generated 2026-08-10T14:20:22.883Z
+
+// ===== core.jsx =====
+
+// core.jsx — JSON polyfill, dispatcher, undo wrapper, async job table.
+// ExtendScript is ES3-ish; no let/const/arrow/template-literals.
+
+// ---------- JSON polyfill (defensive; AE 2026 has JSON natively but we never know) ----------
+if (typeof JSON === "undefined") { JSON = {}; }
+if (typeof JSON.stringify !== "function") {
+  JSON.stringify = (function () {
+    function quote(s) {
+      var r = '"';
+      for (var i = 0; i < s.length; i++) {
+        var c = s.charAt(i), cc = s.charCodeAt(i);
+        if (c === '"') r += '\\"';
+        else if (c === "\\") r += "\\\\";
+        else if (c === "\n") r += "\\n";
+        else if (c === "\r") r += "\\r";
+        else if (c === "\t") r += "\\t";
+        else if (c === "\b") r += "\\b";
+        else if (c === "\f") r += "\\f";
+        else if (cc < 0x20) {
+          var h = cc.toString(16); while (h.length < 4) h = "0" + h;
+          r += "\\u" + h;
+        } else r += c;
+      }
+      return r + '"';
+    }
+    function str(v) {
+      if (v === null) return "null";
+      if (v === undefined) return "null";
+      var t = typeof v;
+      if (t === "number") return isFinite(v) ? String(v) : "null";
+      if (t === "boolean") return v ? "true" : "false";
+      if (t === "string") return quote(v);
+      if (t === "object") {
+        if (v instanceof Array) {
+          var a = [];
+          for (var i = 0; i < v.length; i++) a.push(str(v[i]));
+          return "[" + a.join(",") + "]";
+        }
+        var keys = [];
+        for (var k in v) { if (v.hasOwnProperty(k)) keys.push(k); }
+        var parts = [];
+        for (var j = 0; j < keys.length; j++) {
+          var val = str(v[keys[j]]);
+          if (val !== undefined) parts.push(quote(keys[j]) + ":" + val);
+        }
+        return "{" + parts.join(",") + "}";
+      }
+      return "null";
+    }
+    return function (v) { return str(v); };
+  })();
+}
+if (typeof JSON.parse !== "function") {
+  JSON.parse = function (text) { return eval("(" + text + ")"); };
+}
+
+// ---------- Global registry ----------
+var OPS = OPS || {};
+var JOBS = JOBS || {};
+var __JOB_SEQ = __JOB_SEQ || 0;
+
+function __newJobId() {
+  __JOB_SEQ += 1;
+  return "j_" + (new Date().getTime()) + "_" + __JOB_SEQ;
+}
+
+// ---------- Undo wrapper ----------
+function withUndo(name, fn) {
+  app.beginUndoGroup(name || "AE MCP");
+  try { return fn(); }
+  finally { app.endUndoGroup(); }
+}
+
+// ---------- Error helper ----------
+function __mkError(e) {
+  var msg = e && e.message ? String(e.message) : String(e);
+  var stack = e && e.stack ? String(e.stack) : "";
+  var line = e && typeof e.line !== "undefined" ? e.line : null;
+  return { ok: false, error: msg, stack: stack, line: line };
+}
+
+// ---------- Main dispatch ----------
+// Called from panel with a JSON string payload {op, args, requestId}.
+// Returns a plain object {ok, result|error}. Panel JSON.stringifys.
+function dispatch(payloadJson) {
+  var payload;
+  try { payload = JSON.parse(payloadJson); }
+  catch (e) { return { ok: false, error: "Bad payload JSON: " + e.message }; }
+  var op = payload.op;
+  var args = payload.args || {};
+  if (!OPS.hasOwnProperty(op)) return { ok: false, error: "Unknown op: " + op };
+  try {
+    var handler = OPS[op];
+    var meta = handler.__meta || {};
+    if (meta.noUndo) {
+      return { ok: true, result: handler(args) };
+    }
+    var result = withUndo(meta.undoName || ("AE MCP: " + op), function () { return handler(args); });
+    return { ok: true, result: result };
+  } catch (e) {
+    return __mkError(e);
+  }
+}
+
+// Helper for handlers that don't want an undo group (read-only ops, job continuations).
+function noUndo(fn) { fn.__meta = { noUndo: true }; return fn; }
+function undoNamed(name, fn) { fn.__meta = { undoName: name }; return fn; }
+
+
+// ===== ids.jsx =====
+
+// ids.jsx — stable ID lookup helpers. (compId, layerId) is the canonical pair.
+
+function getCompById(id) {
+  if (id === null || id === undefined) throw new Error("compId required");
+  var item = app.project.itemByID(id);
+  if (!item) throw new Error("No comp with id " + id);
+  if (!(item instanceof CompItem)) throw new Error("Item " + id + " is not a CompItem");
+  return item;
+}
+
+function getItemById(id) {
+  if (id === null || id === undefined) throw new Error("itemId required");
+  var item = app.project.itemByID(id);
+  if (!item) throw new Error("No item with id " + id);
+  return item;
+}
+
+function getLayerById(comp, layerId) {
+  if (!(comp instanceof CompItem)) throw new Error("Expected CompItem");
+  if (layerId === null || layerId === undefined) throw new Error("layerId required");
+  for (var i = 1; i <= comp.numLayers; i++) {
+    var l = comp.layer(i);
+    if (l.id === layerId) return l;
+  }
+  throw new Error("No layer with id " + layerId + " in comp " + comp.id);
+}
+
+// Walk a propertyPath into a layer/group, e.g. ["Transform","Position"] or ["Effects","Gaussian Blur","Blurriness"].
+// Supports numeric indices (1-based) and string names. Returns the Property/PropertyGroup.
+function walkProperty(root, path) {
+  if (!path || !path.length) throw new Error("Empty propertyPath");
+  var cur = root;
+  for (var i = 0; i < path.length; i++) {
+    var seg = path[i];
+    try { cur = cur.property(seg); }
+    catch (e) { throw new Error("Property path segment failed at [" + i + "]=" + String(seg) + ": " + e.message); }
+    if (!cur) throw new Error("Property path segment returned null at [" + i + "]=" + String(seg));
+  }
+  return cur;
+}
+
+function colorOrDefault(c, fallback) {
+  if (!c) return fallback;
+  return [Number(c[0]), Number(c[1]), Number(c[2])];
+}
+
+
+// ===== comps.jsx =====
+
+// comps.jsx — composition ops.
+
+function __compSummary(c) {
+  return {
+    id: c.id,
+    name: c.name,
+    width: c.width,
+    height: c.height,
+    duration: c.duration,
+    frameRate: c.frameRate,
+    pixelAspect: c.pixelAspect,
+    bgColor: [c.bgColor[0], c.bgColor[1], c.bgColor[2]],
+    numLayers: c.numLayers,
+    workAreaStart: c.workAreaStart,
+    workAreaDuration: c.workAreaDuration,
+  };
+}
+
+OPS.list_comps = noUndo(function (args) {
+  var out = [];
+  for (var i = 1; i <= app.project.numItems; i++) {
+    var it = app.project.item(i);
+    if (it instanceof CompItem) out.push(__compSummary(it));
+  }
+  return out;
+});
+
+OPS.get_comp = noUndo(function (args) {
+  return __compSummary(getCompById(args.compId));
+});
+
+OPS.create_comp = function (args) {
+  var bg = args.bgColor || [0, 0, 0];
+  var c = app.project.items.addComp(
+    args.name || "Untitled",
+    args.width || 1920,
+    args.height || 1080,
+    args.pixelAspect || 1,
+    args.duration || 5,
+    args.frameRate || 30
+  );
+  c.bgColor = [bg[0], bg[1], bg[2]];
+  return __compSummary(c);
+};
+
+OPS.set_comp = function (args) {
+  var c = getCompById(args.compId);
+  if (args.name !== undefined) c.name = args.name;
+  if (args.width !== undefined) c.width = args.width;
+  if (args.height !== undefined) c.height = args.height;
+  if (args.frameRate !== undefined) c.frameRate = args.frameRate;
+  if (args.duration !== undefined) c.duration = args.duration;
+  if (args.workAreaStart !== undefined) c.workAreaStart = args.workAreaStart;
+  if (args.workAreaDuration !== undefined) c.workAreaDuration = args.workAreaDuration;
+  if (args.bgColor) c.bgColor = [args.bgColor[0], args.bgColor[1], args.bgColor[2]];
+  return __compSummary(c);
+};
+
+OPS.delete_comp = function (args) {
+  var c = getCompById(args.compId);
+  c.remove();
+  return { ok: true };
+};
+
+OPS.set_active_comp = function (args) {
+  var c = getCompById(args.compId);
+  c.openInViewer();
+  return { ok: true };
+};
+
+OPS.get_comp_tree = noUndo(function (args) {
+  var c = getCompById(args.compId);
+  var depth = args.depth || 2;
+  function summarize(comp, d) {
+    var s = __compSummary(comp);
+    s.layers = [];
+    for (var i = 1; i <= comp.numLayers; i++) {
+      var l = comp.layer(i);
+      var ls = __layerSummary(l);
+      if (d > 0 && l.source && l.source instanceof CompItem) {
+        ls.precomp = summarize(l.source, d - 1);
+      }
+      s.layers.push(ls);
+    }
+    return s;
+  }
+  return summarize(c, depth);
+});
+
+
+// ===== layers.jsx =====
+
+// layers.jsx — all layer-level ops.
+
+function __layerKind(l) {
+  if (l instanceof TextLayer) return "text";
+  if (l instanceof ShapeLayer) return "shape";
+  if (l instanceof CameraLayer) return "camera";
+  if (l instanceof LightLayer) return "light";
+  if (l.nullLayer) return "null";
+  if (l.adjustmentLayer) return "adjustment";
+  if (l.source && l.source instanceof CompItem) return "precomp";
+  if (l.source && l.source instanceof FootageItem) {
+    if (l.source.mainSource && l.source.mainSource.color !== undefined) return "solid";
+    return "footage";
+  }
+  return "unknown";
+}
+
+function __layerSummary(l) {
+  var parent = l.parent ? l.parent.id : null;
+  return {
+    id: l.id,
+    index: l.index,
+    name: l.name,
+    enabled: l.enabled,
+    solo: l.solo,
+    locked: l.locked,
+    shy: l.shy,
+    threeDLayer: l.threeDLayer,
+    label: l.label,
+    inPoint: l.inPoint,
+    outPoint: l.outPoint,
+    startTime: l.startTime,
+    stretch: l.stretch,
+    sourceType: __layerKind(l),
+    parent: parent,
+    blendingMode: l.blendingMode,
+  };
+}
+
+OPS.list_layers = noUndo(function (args) {
+  var c = getCompById(args.compId);
+  var out = [];
+  for (var i = 1; i <= c.numLayers; i++) out.push(__layerSummary(c.layer(i)));
+  return out;
+});
+
+OPS.create_text_layer = function (args) {
+  var c = getCompById(args.compId);
+  var l = c.layers.addText(args.text || "");
+  if (args.name) l.name = args.name;
+  // Apply font/size/color through TextDocument first — sourceRectAtTime depends on these.
+  if (args.font || args.size || args.color) {
+    var srcText = l.property("Source Text");
+    var td = srcText.value;
+    if (args.font) td.font = args.font;
+    if (args.size) td.fontSize = args.size;
+    if (args.color) { td.applyFill = true; td.fillColor = [args.color[0], args.color[1], args.color[2]]; }
+    srcText.setValue(td);
+  }
+  // AE's addText() puts the anchor at the bbox center, which surprises agents
+  // who expect position to mean the left edge. Default to 'left' so position
+  // semantically matches the visible start of the text. 'none' opts out.
+  var align = args.anchorAlign === undefined ? "left" : args.anchorAlign;
+  if (align !== "none") {
+    try {
+      var __rect = l.sourceRectAtTime(c.time, false);
+      var __ax = __rect.left;
+      if (align === "center") __ax = __rect.left + __rect.width / 2;
+      else if (align === "right") __ax = __rect.left + __rect.width;
+      l.property("Transform").property("Anchor Point").setValue([__ax, 0, 0]);
+    } catch (__e) {}
+  }
+  if (args.position) {
+    var p = args.position;
+    l.property("Transform").property("Position").setValue(p.length === 3 ? p : [p[0], p[1]]);
+  }
+  return __layerSummary(l);
+};
+
+OPS.create_solid_layer = function (args) {
+  var c = getCompById(args.compId);
+  var w = args.width || c.width;
+  var h = args.height || c.height;
+  var dur = args.duration || c.duration;
+  var col = args.color;
+  var l = c.layers.addSolid([col[0], col[1], col[2]], args.name || "Solid", w, h, c.pixelAspect, dur);
+  return __layerSummary(l);
+};
+
+OPS.create_null_layer = function (args) {
+  var c = getCompById(args.compId);
+  var l = c.layers.addNull();
+  if (args.name) l.name = args.name;
+  return __layerSummary(l);
+};
+
+OPS.create_adjustment_layer = function (args) {
+  var c = getCompById(args.compId);
+  var l = c.layers.addSolid([1, 1, 1], args.name || "Adjustment", c.width, c.height, c.pixelAspect, c.duration);
+  l.adjustmentLayer = true;
+  return __layerSummary(l);
+};
+
+OPS.create_shape_layer = function (args) {
+  var c = getCompById(args.compId);
+  var l = c.layers.addShape();
+  if (args.name) l.name = args.name;
+  // shapes payload kept loose for v1 — the agent can use add_shape_content for detail
+  return __layerSummary(l);
+};
+
+OPS.create_precomp_layer = function (args) {
+  var c = getCompById(args.compId);
+  var src = getCompById(args.sourceCompId);
+  var l = c.layers.add(src);
+  if (args.position) {
+    var p = args.position;
+    l.property("Transform").property("Position").setValue(p.length === 3 ? p : [p[0], p[1]]);
+  }
+  return __layerSummary(l);
+};
+
+OPS.create_camera_layer = function (args) {
+  var c = getCompById(args.compId);
+  var center = (args.position && args.position.length >= 2) ? [args.position[0], args.position[1]] : [c.width / 2, c.height / 2];
+  var l = c.layers.addCamera(args.name || "Camera", center);
+  if (args.oneNode) { try { l.autoOrient = AutoOrientType.NO_AUTO_ORIENT; } catch (e) {} }
+  return __layerSummary(l);
+};
+
+OPS.create_light_layer = function (args) {
+  var c = getCompById(args.compId);
+  var center = (args.position && args.position.length >= 2) ? [args.position[0], args.position[1]] : [c.width / 2, c.height / 2];
+  var l = c.layers.addLight(args.name || "Light", center);
+  var lightTypeMap = { parallel: LightType.PARALLEL, spot: LightType.SPOT, point: LightType.POINT, ambient: LightType.AMBIENT };
+  if (args.lightType && lightTypeMap[args.lightType]) l.lightType = lightTypeMap[args.lightType];
+  if (args.color) l.lightOption.property("Color").setValue([args.color[0], args.color[1], args.color[2]]);
+  if (args.intensity !== undefined) l.lightOption.property("Intensity").setValue(args.intensity);
+  return __layerSummary(l);
+};
+
+OPS.duplicate_layer = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var n = args.count || 1;
+  var out = [];
+  for (var i = 0; i < n; i++) {
+    var d = l.duplicate();
+    out.push(__layerSummary(d));
+  }
+  return out;
+};
+
+OPS.delete_layer = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  l.remove();
+  return { ok: true };
+};
+
+OPS.set_layer = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  if (args.name !== undefined) l.name = args.name;
+  if (args.enabled !== undefined) l.enabled = args.enabled;
+  if (args.locked !== undefined) l.locked = args.locked;
+  if (args.shy !== undefined) l.shy = args.shy;
+  if (args.solo !== undefined) l.solo = args.solo;
+  if (args.threeDLayer !== undefined) l.threeDLayer = args.threeDLayer;
+  if (args.blendingMode !== undefined) {
+    try { l.blendingMode = BlendingMode[args.blendingMode] || l.blendingMode; }
+    catch (e) {}
+  }
+  if (args.label !== undefined) l.label = args.label;
+  if (args.inPoint !== undefined) l.inPoint = args.inPoint;
+  if (args.outPoint !== undefined) l.outPoint = args.outPoint;
+  if (args.startTime !== undefined) l.startTime = args.startTime;
+  if (args.stretch !== undefined) l.stretch = args.stretch;
+  if (args.preserveTransparency !== undefined) l.preserveTransparency = args.preserveTransparency;
+  if (args.trackMatte) {
+    if (args.trackMatte.type) {
+      try { l.trackMatteType = TrackMatteType[args.trackMatte.type] || l.trackMatteType; }
+      catch (e2) {}
+    }
+  }
+  return __layerSummary(l);
+};
+
+OPS.parent_layer = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  if (args.parentLayerId === null) {
+    l.parent = null;
+  } else {
+    l.parent = getLayerById(c, args.parentLayerId);
+  }
+  return __layerSummary(l);
+};
+
+OPS.reorder_layer = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  l.moveTo(args.toIndex);
+  return __layerSummary(l);
+};
+
+
+// ===== transforms.jsx =====
+
+// transforms.jsx — fast-path for setting common transform properties.
+
+function __setOrKeyAtTime(prop, value, time, keyframe) {
+  if (keyframe && time !== undefined && time !== null) {
+    prop.setValueAtTime(time, value);
+  } else if (time !== undefined && time !== null && !keyframe) {
+    // Set value at time only meaningful if property has keyframes; else set static.
+    if (prop.numKeys > 0) prop.setValueAtTime(time, value);
+    else prop.setValue(value);
+  } else {
+    prop.setValue(value);
+  }
+}
+
+OPS.set_transform = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var t = args.time;
+  var kf = !!args.keyframe;
+  var tr = l.property("Transform");
+  var p = args.properties || {};
+  if (p.position !== undefined) __setOrKeyAtTime(tr.property("Position"), p.position, t, kf);
+  if (p.scale !== undefined) __setOrKeyAtTime(tr.property("Scale"), p.scale, t, kf);
+  if (p.rotation !== undefined) {
+    var rotProp = l.threeDLayer ? tr.property("Z Rotation") : tr.property("Rotation");
+    __setOrKeyAtTime(rotProp, p.rotation, t, kf);
+  }
+  if (p.anchorPoint !== undefined) __setOrKeyAtTime(tr.property("Anchor Point"), p.anchorPoint, t, kf);
+  if (p.opacity !== undefined) __setOrKeyAtTime(tr.property("Opacity"), p.opacity, t, kf);
+  if (p.orientation !== undefined && l.threeDLayer) __setOrKeyAtTime(tr.property("Orientation"), p.orientation, t, kf);
+  if (p.xRotation !== undefined && l.threeDLayer) __setOrKeyAtTime(tr.property("X Rotation"), p.xRotation, t, kf);
+  if (p.yRotation !== undefined && l.threeDLayer) __setOrKeyAtTime(tr.property("Y Rotation"), p.yRotation, t, kf);
+  if (p.zRotation !== undefined && l.threeDLayer) __setOrKeyAtTime(tr.property("Z Rotation"), p.zRotation, t, kf);
+  return { ok: true };
+};
+
+
+// ===== keyframes.jsx =====
+
+// keyframes.jsx — generic keyframe ops.
+
+var __INTERP_MAP = {
+  linear: KeyframeInterpolationType.LINEAR,
+  bezier: KeyframeInterpolationType.BEZIER,
+  hold: KeyframeInterpolationType.HOLD,
+};
+
+function __findKeyIndexAtTime(prop, time, eps) {
+  eps = eps || 0.001;
+  for (var i = 1; i <= prop.numKeys; i++) {
+    if (Math.abs(prop.keyTime(i) - time) < eps) return i;
+  }
+  return -1;
+}
+
+function __applyInterpolationToKey(prop, keyIndex, interp) {
+  if (!interp) return;
+  var inT = interp["in"] && __INTERP_MAP[interp["in"]] ? __INTERP_MAP[interp["in"]] : prop.keyInInterpolationType(keyIndex);
+  var outT = interp["out"] && __INTERP_MAP[interp["out"]] ? __INTERP_MAP[interp["out"]] : prop.keyOutInterpolationType(keyIndex);
+  prop.setInterpolationTypeAtKey(keyIndex, inT, outT);
+  if (interp.easeIn || interp.easeOut) {
+    // AE's setTemporalEaseAtKey expects an array of KeyframeEase per dimension —
+    // BUT spatial properties (Position, Anchor Point) use a single ease entry that
+    // applies along the motion path, regardless of 2D/3D. Non-spatial multi-dim
+    // properties (Scale, Color) need one entry per dimension.
+    var dim;
+    if (prop.isSpatial) {
+      dim = 1;
+    } else {
+      dim = (prop.value && prop.value.length) ? prop.value.length : 1;
+    }
+    var inEase = interp.easeIn || { influence: 33, speed: 0 };
+    var outEase = interp.easeOut || { influence: 33, speed: 0 };
+    var inArr = []; var outArr = [];
+    for (var d = 0; d < dim; d++) {
+      inArr.push(new KeyframeEase(inEase.speed, inEase.influence));
+      outArr.push(new KeyframeEase(outEase.speed, outEase.influence));
+    }
+    prop.setTemporalEaseAtKey(keyIndex, inArr, outArr);
+  }
+}
+
+OPS.add_keyframe = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var prop = walkProperty(l, args.propertyPath);
+  prop.setValueAtTime(args.time, args.value);
+  if (args.interpolation) {
+    var idx = __findKeyIndexAtTime(prop, args.time);
+    if (idx > 0) __applyInterpolationToKey(prop, idx, args.interpolation);
+  }
+  return { ok: true, keyIndex: __findKeyIndexAtTime(prop, args.time) };
+};
+
+OPS.remove_keyframe = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var prop = walkProperty(l, args.propertyPath);
+  var idx = __findKeyIndexAtTime(prop, args.time);
+  if (idx < 1) throw new Error("No keyframe at time " + args.time);
+  prop.removeKey(idx);
+  return { ok: true };
+};
+
+OPS.get_keyframes = noUndo(function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var prop = walkProperty(l, args.propertyPath);
+  var keys = [];
+  for (var i = 1; i <= prop.numKeys; i++) {
+    var ease = null;
+    try {
+      var inE = prop.keyInTemporalEase(i);
+      var outE = prop.keyOutTemporalEase(i);
+      ease = {
+        easeIn: { influence: inE[0].influence, speed: inE[0].speed },
+        easeOut: { influence: outE[0].influence, speed: outE[0].speed },
+      };
+    } catch (e) {}
+    var tangents = null;
+    if (prop.isSpatial) {
+      try { tangents = { inTangent: prop.keyInSpatialTangent(i), outTangent: prop.keyOutSpatialTangent(i) }; }
+      catch (e2) {}
+    }
+    keys.push({
+      index: i,
+      time: prop.keyTime(i),
+      value: prop.keyValue(i),
+      interpolation: {
+        "in": __invInterp(prop.keyInInterpolationType(i)),
+        "out": __invInterp(prop.keyOutInterpolationType(i)),
+      },
+      ease: ease,
+      tangents: tangents,
+    });
+  }
+  return keys;
+});
+
+function __invInterp(t) {
+  if (t === KeyframeInterpolationType.LINEAR) return "linear";
+  if (t === KeyframeInterpolationType.BEZIER) return "bezier";
+  if (t === KeyframeInterpolationType.HOLD) return "hold";
+  return "unknown";
+}
+
+OPS.set_interpolation = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var prop = walkProperty(l, args.propertyPath);
+  __applyInterpolationToKey(prop, args.keyIndex, { "in": args["in"], "out": args["out"] });
+  return { ok: true };
+};
+
+OPS.set_temporal_ease = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var prop = walkProperty(l, args.propertyPath);
+  __applyInterpolationToKey(prop, args.keyIndex, { easeIn: args.easeIn, easeOut: args.easeOut });
+  return { ok: true };
+};
+
+OPS.set_spatial_tangents = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var prop = walkProperty(l, args.propertyPath);
+  if (!prop.isSpatial) throw new Error("Property is not spatial");
+  prop.setSpatialTangentsAtKey(args.keyIndex, args.inTangent, args.outTangent);
+  return { ok: true };
+};
+
+
+// ===== expressions.jsx =====
+
+// expressions.jsx — get/set/toggle/clear expressions on any property.
+
+OPS.get_expression = noUndo(function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var prop = walkProperty(l, args.propertyPath);
+  return { expression: prop.expression || "", enabled: !!prop.expressionEnabled };
+});
+
+OPS.set_expression = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var prop = walkProperty(l, args.propertyPath);
+  prop.expression = args.expression || "";
+  prop.expressionEnabled = true;
+  return { ok: true };
+};
+
+OPS.toggle_expression = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var prop = walkProperty(l, args.propertyPath);
+  prop.expressionEnabled = !!args.enabled;
+  return { ok: true };
+};
+
+OPS.clear_expression = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var prop = walkProperty(l, args.propertyPath);
+  prop.expression = "";
+  return { ok: true };
+};
+
+
+// ===== effects.jsx =====
+
+// 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++) {
+    var p = eff.property(i);
+    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;
+    if (p.numKeys > 0) {
+      entry.keyframes = [];
+      for (var k = 1; k <= p.numKeys; k++) {
+        entry.keyframes.push({ time: p.keyTime(k), value: p.keyValue(k) });
+      }
+    }
+    out.params.push(entry);
+  }
+  return out;
+}
+
+OPS.list_effects = noUndo(function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var fx = l.property("Effects");
+  if (!fx) return [];
+  var out = [];
+  for (var i = 1; i <= fx.numProperties; i++) out.push(__serializeEffect(fx.property(i)));
+  return out;
+});
+
+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);
+};
+
+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();
+  return { ok: true };
+};
+
+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; }
+    }
+  }
+  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);
+  return { ok: true };
+};
+
+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;
+  return { ok: true };
+};
+
+OPS.list_available_effects = noUndo(function (args) {
+  // app.effects is an array of {displayName, matchName, category, version} on modern AE.
+  var out = [];
+  try {
+    var fx = app.effects;
+    for (var i = 0; i < fx.length; i++) {
+      out.push({ displayName: fx[i].displayName, matchName: fx[i].matchName, category: fx[i].category });
+    }
+  } catch (e) {
+    // Fallback: return a curated subset of common match names.
+    out = [
+      { displayName: "Gaussian Blur", matchName: "ADBE Gaussian Blur 2", category: "Blur & Sharpen" },
+      { displayName: "Fast Box Blur", matchName: "ADBE Box Blur2", category: "Blur & Sharpen" },
+      { displayName: "Glow", matchName: "ADBE Glo2", category: "Stylize" },
+      { displayName: "Drop Shadow", matchName: "ADBE Drop Shadow", category: "Perspective" },
+      { displayName: "Curves", matchName: "ADBE CurvesCustom", category: "Color Correction" },
+      { displayName: "Levels", matchName: "ADBE Easy Levels2", category: "Color Correction" },
+      { displayName: "Fill", matchName: "ADBE Fill", category: "Generate" },
+      { displayName: "CC Light Sweep", matchName: "CC Light Sweep", category: "Generate" },
+    ];
+  }
+  return out;
+});
+
+
+// ===== text.jsx =====
+
+// text.jsx — text layer styling.
+
+OPS.set_text = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  if (!(l instanceof TextLayer)) throw new Error("Layer is not a TextLayer");
+  var src = l.property("Source Text");
+  var td = src.value;
+  if (args.text !== undefined) td.text = args.text;
+  if (args.font !== undefined) td.font = args.font;
+  if (args.size !== undefined) td.fontSize = args.size;
+  if (args.fillColor) { td.applyFill = true; td.fillColor = [args.fillColor[0], args.fillColor[1], args.fillColor[2]]; }
+  if (args.strokeColor) { td.applyStroke = true; td.strokeColor = [args.strokeColor[0], args.strokeColor[1], args.strokeColor[2]]; }
+  if (args.strokeWidth !== undefined) td.strokeWidth = args.strokeWidth;
+  if (args.tracking !== undefined) td.tracking = args.tracking;
+  if (args.leading !== undefined) td.leading = args.leading;
+  if (args.justification !== undefined) {
+    var jmap = {
+      left: ParagraphJustification.LEFT_JUSTIFY,
+      center: ParagraphJustification.CENTER_JUSTIFY,
+      right: ParagraphJustification.RIGHT_JUSTIFY,
+      full: ParagraphJustification.FULL_JUSTIFY_LASTLINE_LEFT,
+    };
+    if (jmap[args.justification]) td.justification = jmap[args.justification];
+  }
+  if (args.applyFill !== undefined) td.applyFill = args.applyFill;
+  if (args.applyStroke !== undefined) td.applyStroke = args.applyStroke;
+  if (args.fauxBold !== undefined) td.fauxBold = args.fauxBold;
+  if (args.fauxItalic !== undefined) td.fauxItalic = args.fauxItalic;
+  if (args.allCaps !== undefined) td.allCaps = args.allCaps;
+  if (args.smallCaps !== undefined) td.smallCaps = args.smallCaps;
+  if (args.baselineShift !== undefined) td.baselineShift = args.baselineShift;
+  src.setValue(td);
+  return { ok: true };
+};
+
+OPS.add_text_animator = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  if (!(l instanceof TextLayer)) throw new Error("Layer is not a TextLayer");
+  var anims = l.property("Text").property("Animators");
+  var anim = anims.addProperty("ADBE Text Animator");
+  var typeMap = {
+    position: "ADBE Text Position 3D",
+    scale: "ADBE Text Scale 3D",
+    rotation: "ADBE Text Rotation",
+    opacity: "ADBE Text Opacity",
+    tracking: "ADBE Text Tracking Amount",
+    skew: "ADBE Text Skew",
+    fillColor: "ADBE Text Fill Color",
+    strokeColor: "ADBE Text Stroke Color",
+  };
+  var propsGroup = anim.property("ADBE Text Animator Properties");
+  if (typeMap[args.type]) {
+    try { propsGroup.addProperty(typeMap[args.type]); }
+    catch (e) {}
+  }
+  if (args.range) {
+    var selectors = anim.property("ADBE Text Selectors");
+    if (selectors.numProperties === 0) selectors.addProperty("ADBE Text Selector");
+    var sel = selectors.property(1);
+    if (args.range.start !== undefined) sel.property("ADBE Text Percent Start").setValue(args.range.start);
+    if (args.range.end !== undefined) sel.property("ADBE Text Percent End").setValue(args.range.end);
+    if (args.range.offset !== undefined) sel.property("ADBE Text Percent Offset").setValue(args.range.offset);
+  }
+  return { ok: true, animatorName: anim.name };
+};
+
+
+// ===== shapes.jsx =====
+
+// shapes.jsx — shape layer paths/fills/strokes/repeaters.
+
+function __makeShape(vertices, inT, outT, closed) {
+  var s = new Shape();
+  s.vertices = vertices;
+  if (inT) s.inTangents = inT;
+  if (outT) s.outTangents = outT;
+  s.closed = closed !== false;
+  return s;
+}
+
+OPS.set_shape_path = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var prop = walkProperty(l, args.shapePath);
+  // The shape path is usually a "Path" property whose value is a Shape.
+  var pathProp = prop;
+  // If user passed a group, dig down to "Path"
+  if (pathProp.propertyType === PropertyType.NAMED_GROUP || pathProp.propertyType === PropertyType.INDEXED_GROUP) {
+    try { pathProp = pathProp.property("Path"); } catch (e) {}
+  }
+  var shape = __makeShape(args.vertices, args.inTangents, args.outTangents, args.closed);
+  pathProp.setValue(shape);
+  return { ok: true };
+};
+
+var __SHAPE_MATCH = {
+  rect: "ADBE Vector Shape - Rect",
+  ellipse: "ADBE Vector Shape - Ellipse",
+  star: "ADBE Vector Shape - Star",
+  path: "ADBE Vector Shape - Group",
+  fill: "ADBE Vector Graphic - Fill",
+  stroke: "ADBE Vector Graphic - Stroke",
+  trim: "ADBE Vector Filter - Trim",
+  repeater: "ADBE Vector Filter - Repeater",
+  merge: "ADBE Vector Filter - Merge",
+  group: "ADBE Vector Group"
+};
+
+// Friendly key -> candidate property identifiers, tried in order. AE's own
+// matchNames are inconsistent (and some are misspelled upstream, e.g. the star
+// "Roundess" keys), so each entry is a list and the raw key is always tried
+// last. A key that resolves to nothing is reported, never silently dropped.
+var __SHAPE_ALIASES = {
+  rect: {
+    size: ["ADBE Vector Rect Size", "Size"],
+    position: ["ADBE Vector Rect Position", "Position"],
+    roundness: ["ADBE Vector Rect Roundness", "Roundness"]
+  },
+  ellipse: {
+    size: ["ADBE Vector Ellipse Size", "Size"],
+    position: ["ADBE Vector Ellipse Position", "Position"]
+  },
+  star: {
+    starType: ["ADBE Vector Star Type", "Type"],
+    points: ["ADBE Vector Star Points", "Points"],
+    position: ["ADBE Vector Star Position", "Position"],
+    rotation: ["ADBE Vector Star Rotation", "Rotation"],
+    innerRadius: ["ADBE Vector Star Inner Radius", "Inner Radius"],
+    outerRadius: ["ADBE Vector Star Outer Radius", "Outer Radius"],
+    innerRoundness: ["ADBE Vector Star Inner Roundess", "ADBE Vector Star Inner Roundness", "Inner Roundness"],
+    outerRoundness: ["ADBE Vector Star Outer Roundess", "ADBE Vector Star Outer Roundness", "Outer Roundness"]
+  },
+  fill: {
+    color: ["ADBE Vector Fill Color", "Color"],
+    opacity: ["ADBE Vector Fill Opacity", "Opacity"],
+    fillRule: ["ADBE Vector Fill Rule", "Fill Rule"]
+  },
+  stroke: {
+    color: ["ADBE Vector Stroke Color", "Color"],
+    opacity: ["ADBE Vector Stroke Opacity", "Opacity"],
+    width: ["ADBE Vector Stroke Width", "Stroke Width"],
+    lineCap: ["ADBE Vector Stroke Line Cap", "Line Cap"],
+    lineJoin: ["ADBE Vector Stroke Line Join", "Line Join"],
+    miterLimit: ["ADBE Vector Stroke Miter Limit", "Miter Limit"]
+  },
+  trim: {
+    start: ["ADBE Vector Trim Start", "Start"],
+    end: ["ADBE Vector Trim End", "End"],
+    offset: ["ADBE Vector Trim Offset", "Offset"]
+  },
+  repeater: {
+    copies: ["ADBE Vector Repeater Copies", "Copies"],
+    offset: ["ADBE Vector Repeater Offset", "Offset"]
+  },
+  merge: {
+    mode: ["ADBE Vector Merge Type", "Mode"]
+  }
+};
+
+// Keys consumed by the path builder rather than set as plain properties.
+var __PATH_KEYS = { vertices: 1, points: 1, inTangents: 1, outTangents: 1, closed: 1 };
+
+function __resolveShapeProp(node, type, key) {
+  var candidates = [];
+  var table = __SHAPE_ALIASES[type];
+  if (table && table[key]) {
+    var aliases = table[key];
+    for (var i = 0; i < aliases.length; i++) candidates.push(aliases[i]);
+  }
+  candidates.push(key);
+  for (var j = 0; j < candidates.length; j++) {
+    try {
+      var pp = node.property(candidates[j]);
+      if (pp) return pp;
+    } catch (e) {}
+  }
+  return null;
+}
+
+function __shapeTypeList() {
+  var names = [];
+  for (var k in __SHAPE_MATCH) { if (__SHAPE_MATCH.hasOwnProperty(k)) names.push(k); }
+  return names.join(", ");
+}
+
+OPS.add_shape_content = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var parent = l.property("Contents");
+  if (args.parentGroupPath && args.parentGroupPath.length > 0) {
+    parent = walkProperty(l, args.parentGroupPath);
+  }
+  var content = args.content || {};
+  var type = content.type;
+  var match = __SHAPE_MATCH[type];
+  if (!match) {
+    throw new Error("Unknown shape content type: " + String(type) + ". Expected one of: " + __shapeTypeList() + ".");
+  }
+
+  var node = parent.addProperty(match);
+  var applied = [];
+  var failed = [];
+
+  try {
+    // A "path" node is a Vector Group whose Path property holds a Shape; the
+    // vertex keys have to be folded into one setValue rather than set directly.
+    if (type === "path" && (content.vertices || content.points)) {
+      var verts = content.vertices || content.points;
+      var pathProp = __resolveShapeProp(node, "path", "ADBE Vector Shape");
+      if (!pathProp) pathProp = __resolveShapeProp(node, "path", "Path");
+      if (!pathProp) {
+        failed.push("vertices (no Path property on the created group)");
+      } else {
+        pathProp.setValue(__makeShape(verts, content.inTangents, content.outTangents, content.closed));
+        applied.push("vertices");
+      }
+    }
+
+    for (var k in content) {
+      if (!content.hasOwnProperty(k)) continue;
+      if (k === "type") continue;
+      if (type === "path" && __PATH_KEYS[k]) continue;
+      // `name` is a node attribute, not a child property.
+      if (k === "name") {
+        node.name = String(content[k]);
+        applied.push("name");
+        continue;
+      }
+      var target = __resolveShapeProp(node, type, k);
+      if (!target) { failed.push(k); continue; }
+      try {
+        target.setValue(content[k]);
+        applied.push(k);
+      } catch (e) {
+        failed.push(k + " (" + e.message + ")");
+      }
+    }
+  } catch (e) {
+    try { node.remove(); } catch (e2) {}
+    throw e;
+  }
+
+  // All-or-nothing: a partially built node that reports success is worse than a
+  // clear failure, because the caller cannot tell what actually landed.
+  if (failed.length > 0) {
+    try { node.remove(); } catch (e3) {}
+    throw new Error(
+      "add_shape_content could not apply these keys on '" + type + "': " + failed.join(", ") +
+      ". The node was removed, so nothing changed. Check the property names with get_layer_full, " +
+      "or set them afterwards with set_shape_property."
+    );
+  }
+
+  return { ok: true, name: node.name, matchName: match, index: node.propertyIndex, applied: applied };
+};
+
+OPS.set_shape_property = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var node = walkProperty(l, args.contentPath);
+  var pp = node.property(args.property);
+  if (!pp) throw new Error("No property: " + args.property);
+  if (args.keyframe && args.time !== undefined) pp.setValueAtTime(args.time, args.value);
+  else if (args.time !== undefined && pp.numKeys > 0) pp.setValueAtTime(args.time, args.value);
+  else pp.setValue(args.value);
+  return { ok: true };
+};
+
+
+// ===== masks.jsx =====
+
+// masks.jsx — layer mask ops.
+
+OPS.add_mask = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var masksGroup = l.property("Masks");
+  var m = masksGroup.addProperty("ADBE Mask Atom");
+  var maskPath = m.property("ADBE Mask Shape");
+  var shape = new Shape();
+  shape.vertices = args.vertices;
+  if (args.inTangents) shape.inTangents = args.inTangents;
+  if (args.outTangents) shape.outTangents = args.outTangents;
+  shape.closed = args.closed !== false;
+  maskPath.setValue(shape);
+  if (args.mode) {
+    try { m.maskMode = MaskMode[args.mode] || m.maskMode; } catch (e) {}
+  }
+  return { ok: true, maskIndex: m.propertyIndex };
+};
+
+OPS.set_mask = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var m = l.property("Masks").property(args.maskIndex);
+  if (args.vertices) {
+    var pathProp = m.property("ADBE Mask Shape");
+    var sh = pathProp.value;
+    if (args.vertices) sh.vertices = args.vertices;
+    if (args.inTangents) sh.inTangents = args.inTangents;
+    if (args.outTangents) sh.outTangents = args.outTangents;
+    if (args.closed !== undefined) sh.closed = args.closed;
+    pathProp.setValue(sh);
+  }
+  if (args.mode) { try { m.maskMode = MaskMode[args.mode] || m.maskMode; } catch (e) {} }
+  if (args.inverted !== undefined) m.inverted = args.inverted;
+  if (args.expansion !== undefined) m.property("ADBE Mask Offset").setValue(args.expansion);
+  if (args.feather !== undefined) m.property("ADBE Mask Feather").setValue(args.feather);
+  if (args.opacity !== undefined) m.property("ADBE Mask Opacity").setValue(args.opacity);
+  return { ok: true };
+};
+
+OPS.remove_mask = function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  l.property("Masks").property(args.maskIndex).remove();
+  return { ok: true };
+};
+
+
+// ===== markers.jsx =====
+
+// markers.jsx — comp markers and layer markers.
+
+function __mkMarkerValue(args) {
+  var mv = new MarkerValue(args.comment || "");
+  if (args.duration !== undefined) mv.duration = args.duration;
+  if (args.label !== undefined) mv.label = args.label;
+  if (args.chapter) mv.chapter = args.chapter;
+  if (args.url) mv.url = args.url;
+  if (args.frameTarget) mv.frameTarget = args.frameTarget;
+  return mv;
+}
+
+OPS.add_marker = function (args) {
+  var c = getCompById(args.compId);
+  var mv = __mkMarkerValue(args);
+  if (args.layerId !== undefined && args.layerId !== null) {
+    var l = getLayerById(c, args.layerId);
+    var mProp = l.property("Marker");
+    mProp.setValueAtTime(args.time, mv);
+  } else {
+    var compMarkers = c.markerProperty;
+    compMarkers.setValueAtTime(args.time, mv);
+  }
+  return { ok: true };
+};
+
+OPS.remove_marker = function (args) {
+  var c = getCompById(args.compId);
+  if (args.layerId !== undefined && args.layerId !== null) {
+    var l = getLayerById(c, args.layerId);
+    l.property("Marker").removeKey(args.markerIndex);
+  } else {
+    c.markerProperty.removeKey(args.markerIndex);
+  }
+  return { ok: true };
+};
+
+
+// ===== vision.jsx =====
+
+// vision.jsx — saveFrameToPng wrapper, returns the temp file path which the
+// panel then reads and base64-encodes.
+
+function __tmpPngPath() {
+  var folder = Folder.temp;
+  var name = "ae-mcp-" + (new Date().getTime()) + "-" + Math.floor(Math.random() * 1e6) + ".png";
+  return folder.fsName + "/" + name;
+}
+
+OPS.screenshot_frame = noUndo(function (args) {
+  var c = getCompById(args.compId);
+  var t = (args.time !== undefined && args.time !== null) ? args.time : c.time;
+  var path = __tmpPngPath();
+  var f = new File(path);
+  // saveFrameToPng is async-ish; the panel polls the file's existence/size.
+  c.saveFrameToPng(t, f);
+  return { path: path, width: c.width, height: c.height, time: t, compId: c.id };
+});
+
+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 = [];
+  for (var i = 1; i <= c.numLayers; i++) {
+    var ll = c.layer(i);
+    prevSolo.push({ idx: i, solo: ll.solo });
+    ll.solo = false;
+  }
+  l.solo = true;
+  var path = __tmpPngPath();
+  var f = new File(path);
+  try {
+    c.saveFrameToPng(t, f);
+  } 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) {}
+    }
+  }
+  return { path: path, width: c.width, height: c.height, time: t, compId: c.id, layerId: l.id };
+});
+
+
+// ===== batch.jsx =====
+
+// batch.jsx — execute many ops in one ExtendScript pass.
+// For huge batches, registers a job and processes in chunks via _continue_job.
+
+OPS.run_batch = function (args) {
+  var ops = args.ops || [];
+  var transactional = args.transactional !== false;
+  var name = args.undoGroupName || "AE MCP Batch";
+  // Short batches: run inline synchronously. Inline stays sub-second for
+  // typical create/keyframe ops up to a few hundred; the async-job overhead
+  // (jobId envelope, polling, progress notifications) is only worth it for
+  // genuinely long jobs.
+  if (ops.length <= 500) {
+    var results = []; var errors = [];
+    for (var i = 0; i < ops.length; i++) {
+      var step = ops[i];
+      try {
+        var handler = OPS[step.op];
+        if (!handler) throw new Error("Unknown op: " + step.op);
+        results.push(handler(step.args || {}));
+      } catch (e) {
+        errors.push({ index: i, op: step.op, error: e.message });
+        if (transactional) throw new Error("Batch failed at op[" + i + "] " + step.op + ": " + e.message);
+      }
+    }
+    return { results: results, errors: errors, total: ops.length };
+  }
+  // Long batches: register job, return jobId; panel polls _continue_job.
+  var jobId = __newJobId();
+  JOBS[jobId] = {
+    cursor: 0,
+    total: ops.length,
+    ops: ops,
+    results: [],
+    errors: [],
+    cancelled: false,
+    transactional: transactional,
+    name: name,
+  };
+  // Wrap async run already inside an undoGroup chain. We open it now, the
+  // continuations stay inside it until finalization.
+  app.beginUndoGroup(name);
+  JOBS[jobId].undoOpen = true;
+  return { jobId: jobId, async: true, total: ops.length };
+};
+// run_batch is allowed to manage its own undo (we open/close it manually for long jobs).
+OPS.run_batch.__meta = { noUndo: true };
+
+// Continuation step. Returns one chunk's worth of progress.
+OPS._continue_job = noUndo(function (args) {
+  var jobId = args.jobId;
+  var j = JOBS[jobId];
+  if (!j) throw new Error("No job: " + jobId);
+  if (j.cancelled) {
+    if (j.undoOpen) { app.endUndoGroup(); j.undoOpen = false; }
+    return { done: true, cancelled: true, jobId: jobId, results: j.results, errors: j.errors };
+  }
+  var chunkSize = args.chunkSize || 25;
+  var endAt = Math.min(j.cursor + chunkSize, j.total);
+  for (; j.cursor < endAt; j.cursor++) {
+    var step = j.ops[j.cursor];
+    try {
+      var handler = OPS[step.op];
+      if (!handler) throw new Error("Unknown op: " + step.op);
+      j.results.push(handler(step.args || {}));
+    } catch (e) {
+      j.errors.push({ index: j.cursor, op: step.op, error: e.message });
+      if (j.transactional) {
+        if (j.undoOpen) { app.endUndoGroup(); j.undoOpen = false; }
+        // Attempt rollback via undo
+        try { app.executeCommand(app.findMenuCommandId("Undo")); } catch (e2) {}
+        return { done: true, failed: true, jobId: jobId, error: e.message, atIndex: j.cursor, results: j.results, errors: j.errors };
+      }
+    }
+  }
+  if (j.cursor >= j.total) {
+    if (j.undoOpen) { app.endUndoGroup(); j.undoOpen = false; }
+    return { done: true, jobId: jobId, results: j.results, errors: j.errors, total: j.total };
+  }
+  return { done: false, jobId: jobId, progress: j.cursor, total: j.total };
+});
+
+OPS._cancel_job = noUndo(function (args) {
+  var j = JOBS[args.jobId];
+  if (!j) return { ok: false, error: "No such job" };
+  j.cancelled = true;
+  return { ok: true };
+});
+
+OPS._get_job = noUndo(function (args) {
+  var j = JOBS[args.jobId];
+  if (!j) return null;
+  return { cursor: j.cursor, total: j.total, cancelled: j.cancelled, errorCount: j.errors.length };
+});
+
+
+// ===== explore.jsx =====
+
+// explore.jsx — rich one-shot inspection. The whole reason this MCP exists.
+
+function __serializeProperty(p, deep) {
+  var out = {
+    name: p.name,
+    matchName: p.matchName,
+    propertyType: String(p.propertyType),
+    isTimeVarying: p.isTimeVarying,
+    canSetExpression: p.canSetExpression,
+  };
+  try { out.value = p.value; } catch (e) {}
+  if (p.canSetExpression && p.expression) out.expression = p.expression;
+  if (p.numKeys > 0) {
+    out.keyframes = [];
+    for (var k = 1; k <= p.numKeys; k++) {
+      var entry = { index: k, time: p.keyTime(k), value: p.keyValue(k) };
+      try {
+        entry["in"] = String(p.keyInInterpolationType(k));
+        entry["out"] = String(p.keyOutInterpolationType(k));
+      } catch (e1) {}
+      try {
+        var inE = p.keyInTemporalEase(k);
+        var outE = p.keyOutTemporalEase(k);
+        entry.easeIn = { influence: inE[0].influence, speed: inE[0].speed };
+        entry.easeOut = { influence: outE[0].influence, speed: outE[0].speed };
+      } catch (e2) {}
+      if (p.isSpatial) {
+        try {
+          entry.inTangent = p.keyInSpatialTangent(k);
+          entry.outTangent = p.keyOutSpatialTangent(k);
+        } catch (e3) {}
+      }
+      out.keyframes.push(entry);
+    }
+  }
+  return out;
+}
+
+function __serializeTransformGroup(tg) {
+  var out = {};
+  for (var i = 1; i <= tg.numProperties; i++) {
+    var p = tg.property(i);
+    out[p.name] = __serializeProperty(p);
+  }
+  return out;
+}
+
+function __serializeEffects(layer) {
+  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)));
+  return arr;
+}
+
+function __serializeMasks(layer) {
+  var masks = layer.property("Masks");
+  if (!masks || masks.numProperties === 0) return [];
+  var out = [];
+  for (var i = 1; i <= masks.numProperties; i++) {
+    var m = masks.property(i);
+    var entry = {
+      index: i,
+      name: m.name,
+      mode: String(m.maskMode),
+      inverted: m.inverted,
+    };
+    try { entry.shape = __serializeProperty(m.property("ADBE Mask Shape")); } catch (e1) {}
+    try { entry.opacity = __serializeProperty(m.property("ADBE Mask Opacity")); } catch (e2) {}
+    try { entry.expansion = __serializeProperty(m.property("ADBE Mask Offset")); } catch (e3) {}
+    try { entry.feather = __serializeProperty(m.property("ADBE Mask Feather")); } catch (e4) {}
+    out.push(entry);
+  }
+  return out;
+}
+
+function __serializeMarkers(layer) {
+  var mp = layer.property("Marker");
+  if (!mp || mp.numKeys === 0) return [];
+  var out = [];
+  for (var i = 1; i <= mp.numKeys; i++) {
+    var mv = mp.keyValue(i);
+    out.push({
+      index: i,
+      time: mp.keyTime(i),
+      comment: mv.comment,
+      duration: mv.duration,
+      label: mv.label,
+      chapter: mv.chapter,
+      url: mv.url,
+      frameTarget: mv.frameTarget,
+    });
+  }
+  return out;
+}
+
+function __serializeText(layer) {
+  try {
+    var td = layer.property("Source Text").value;
+    return {
+      text: td.text,
+      font: td.font,
+      fontSize: td.fontSize,
+      fillColor: td.applyFill ? [td.fillColor[0], td.fillColor[1], td.fillColor[2]] : null,
+      strokeColor: td.applyStroke ? [td.strokeColor[0], td.strokeColor[1], td.strokeColor[2]] : null,
+      strokeWidth: td.strokeWidth,
+      tracking: td.tracking,
+      leading: td.leading,
+      justification: String(td.justification),
+      fauxBold: td.fauxBold,
+      fauxItalic: td.fauxItalic,
+      allCaps: td.allCaps,
+      smallCaps: td.smallCaps,
+    };
+  } catch (e) { return null; }
+}
+
+function __serializeShapeContents(group, depth) {
+  if (!group || !group.numProperties) return [];
+  var out = [];
+  for (var i = 1; i <= group.numProperties; i++) {
+    var p = group.property(i);
+    var entry = { name: p.name, matchName: p.matchName, index: i };
+    if (p.propertyType === PropertyType.NAMED_GROUP || p.propertyType === PropertyType.INDEXED_GROUP) {
+      if (depth > 0) entry.children = __serializeShapeContents(p, depth - 1);
+    } else {
+      try { entry.value = p.value; } catch (e) {}
+    }
+    out.push(entry);
+  }
+  return out;
+}
+
+OPS.get_layer_full = noUndo(function (args) {
+  var c = getCompById(args.compId);
+  var l = getLayerById(c, args.layerId);
+  var out = {
+    id: l.id,
+    index: l.index,
+    name: l.name,
+    enabled: l.enabled,
+    solo: l.solo,
+    locked: l.locked,
+    shy: l.shy,
+    threeDLayer: l.threeDLayer,
+    label: l.label,
+    inPoint: l.inPoint,
+    outPoint: l.outPoint,
+    startTime: l.startTime,
+    stretch: l.stretch,
+    blendingMode: String(l.blendingMode),
+    preserveTransparency: l.preserveTransparency,
+    parent: l.parent ? { layerId: l.parent.id, name: l.parent.name } : null,
+    sourceType: __layerKind(l),
+    transform: __serializeTransformGroup(l.property("Transform")),
+    effects: __serializeEffects(l),
+    masks: __serializeMasks(l),
+    markers: __serializeMarkers(l),
+  };
+  // Visual bounds at the comp's current time — cheap to fetch and removes a
+  // class of "I need to screenshot to know where this renders" round-trips.
+  // Coordinates are in the layer's local space (origin at the Anchor Point).
+  try {
+    var __rect = l.sourceRectAtTime(c.time, false);
+    out.sourceRect = { left: __rect.left, top: __rect.top, width: __rect.width, height: __rect.height, time: c.time };
+  } catch (__e) {}
+  if (l instanceof TextLayer) out.text = __serializeText(l);
+  if (l instanceof ShapeLayer) {
+    try { out.shape = { contents: __serializeShapeContents(l.property("Contents"), 4) }; }
+    catch (e) {}
+  }
+  if (l.source && l.source instanceof CompItem) {
+    out.precomp = { compId: l.source.id, compName: l.source.name };
+    if (args.includeChildren) {
+      out.children = [];
+      for (var i = 1; i <= l.source.numLayers; i++) out.children.push(__layerSummary(l.source.layer(i)));
+    }
+  } else if (l.source && l.source instanceof FootageItem) {
+    var src = l.source;
+    out.footage = {
+      itemId: src.id,
+      name: src.name,
+      hasAlpha: src.hasAlpha,
+      duration: src.duration,
+      width: src.width,
+      height: src.height,
+    };
+    try { if (src.file) out.footage.path = src.file.fsName; } catch (e2) {}
+  }
+  return out;
+});
+
+OPS.get_project_summary = noUndo(function (args) {
+  var p = app.project;
+  var items = [];
+  for (var i = 1; i <= p.numItems; i++) {
+    var it = p.item(i);
+    items.push({
+      id: it.id,
+      name: it.name,
+      type: (it instanceof CompItem) ? "comp" : (it instanceof FootageItem) ? "footage" : (it instanceof FolderItem) ? "folder" : "unknown",
+    });
+  }
+  return {
+    path: p.file ? p.file.fsName : null,
+    numItems: p.numItems,
+    activeItemId: p.activeItem ? p.activeItem.id : null,
+    items: items,
+  };
+});
+
+OPS.find_layers = noUndo(function (args) {
+  var out = [];
+  var comps = [];
+  if (args.compId) comps.push(getCompById(args.compId));
+  else {
+    for (var i = 1; i <= app.project.numItems; i++) {
+      var it = app.project.item(i);
+      if (it instanceof CompItem) comps.push(it);
+    }
+  }
+  var pat = args.namePattern ? new RegExp(args.namePattern, "i") : null;
+  for (var ci = 0; ci < comps.length; ci++) {
+    var c = comps[ci];
+    for (var li = 1; li <= c.numLayers; li++) {
+      var l = c.layer(li);
+      if (pat && !pat.test(l.name)) continue;
+      if (args.type && __layerKind(l) !== args.type) continue;
+      if (args.hasEffectMatchName) {
+        var fx = l.property("Effects");
+        var hit = false;
+        if (fx) {
+          for (var fi = 1; fi <= fx.numProperties; fi++) {
+            if (fx.property(fi).matchName === args.hasEffectMatchName) { hit = true; break; }
+          }
+        }
+        if (!hit) continue;
+      }
+      var s = __layerSummary(l);
+      s.compId = c.id;
+      s.compName = c.name;
+      out.push(s);
+    }
+  }
+  return out;
+});
+
+
+// ===== raw.jsx =====
+
+// raw.jsx — escape hatch. Eval arbitrary ExtendScript and return the value.
+
+OPS.run_jsx = function (args) {
+  var code = args.code || "";
+  // We wrap in a function so `return` works.
+  var wrapper = "(function(){ " + code + " })()";
+  var result;
+  try { result = eval(wrapper); }
+  catch (e) { throw e; }
+  // ExtendScript objects can be unserializable; coerce sparingly.
+  if (typeof result === "undefined") return null;
+  if (result === null) return null;
+  var t = typeof result;
+  if (t === "number" || t === "string" || t === "boolean") return result;
+  if (result instanceof Array) return result;
+  // Object: pull plain own props
+  try {
+    var out = {};
+    for (var k in result) {
+      if (result.hasOwnProperty(k)) {
+        var v = result[k];
+        var vt = typeof v;
+        if (v === null || vt === "number" || vt === "string" || vt === "boolean") out[k] = v;
+      }
+    }
+    return out;
+  } catch (e2) { return String(result); }
+};