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

package/panel/jsx/bundle.jsx

@@ -69,13 +69,33 @@ function __newJobId() {
 }
 
 // ---------- Undo wrapper ----------
-// __UNDO_OPEN tracks only the group *dispatch* opened. Nothing else may set it:
-// it is what lets withoutUndoGroup() reopen exactly what it closed, and leave
-// undo state alone entirely when we never opened a group in the first place.
+// __UNDO_OPEN tracks whether a group *this bundle* opened is currently open.
+// withUndo() is the only thing that may set it — dispatch and run_batch both
+// group through there — because it is what lets withoutUndoGroup() reopen
+// exactly what it closed, and leave undo state alone entirely when we never
+// opened a group in the first place.
 var __UNDO_OPEN = false;
 
-function withUndo(name, fn) {
+// Every undo group this bundle opens is counted here, and __beginUndoGroup is
+// the only place allowed to call app.beginUndoGroup. run_batch reports the
+// number of undo steps it cost as the *delta* of this counter, so the number an
+// agent repeats to the user as "press Cmd-Z N times" is measured rather than
+// predicted — a chunk that threw still opened its group, and a batched op that
+// called withoutUndoGroup() really did split itself into two steps.
+var __UNDO_GROUPS = 0;
+
+function __beginUndoGroup(name) {
+  __UNDO_GROUPS += 1;
   app.beginUndoGroup(name || "AE MCP");
+}
+
+function __undoGroupsOpened() { return __UNDO_GROUPS; }
+
+// An undo group must open and close inside ONE evalScript call. After Effects
+// discards one that spans two — see the note in CLAUDE.md; measured, not
+// inferred. Everything that groups goes through here for that reason.
+function withUndo(name, fn) {
+  __beginUndoGroup(name || "AE MCP");
   __UNDO_OPEN = true;
   try { return fn(); }
   finally { __UNDO_OPEN = false; app.endUndoGroup(); }
@@ -91,15 +111,28 @@ function withoutUndoGroup(fn) {
   app.endUndoGroup();
   __UNDO_OPEN = false;
   try { return fn(); }
-  finally { app.beginUndoGroup("AE MCP: continue"); __UNDO_OPEN = true; }
+  finally { __beginUndoGroup("AE MCP: continue"); __UNDO_OPEN = true; }
 }
 
 // ---------- Error helper ----------
+// A handler that can say more about *where* it failed than "an error happened"
+// attaches that on `aeDetail` and it is copied onto the result verbatim —
+// run_jsx maps After Effects' line number back onto the script the caller
+// actually submitted (issue #46). The bag is free-form here on purpose; the
+// panel forwards a named list of fields, which is where the contract is kept.
 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 };
+  var out = { ok: false, error: msg, stack: stack, line: line };
+  var detail = null;
+  try { if (e && e.aeDetail) detail = e.aeDetail; } catch (ed) {}
+  if (detail) {
+    for (var k in detail) {
+      if (detail.hasOwnProperty(k)) out[k] = detail[k];
+    }
+  }
+  return out;
 }
 
 // ---------- Main dispatch ----------
@@ -262,10 +295,221 @@ OPS.set_comp = function (args) {
   return __compSummary(c);
 };
 
+// A solid layer's source is a FootageItem in the project's Solids folder, and
+// removing the comp removes the layer, not the item (issue #83). The solids
+// this comp used are collected from ITS OWN layers before the removal and
+// nothing else — deleting comp A must never reach a solid that only some other
+// comp uses — and after it, `usedIn` decides: an item some other comp still
+// places is kept and reported with the comps using it. The helpers live in
+// footage.jsx beside purge_unused_footage, the project-wide sweep.
 OPS.delete_comp = function (args) {
   var c = getCompById(args.compId);
+  var compId = c.id;
+  var compName = c.name;
+  var purge = (args.purgeUnusedSolids === true);
+
+  var solids = __solidItemsOf(c);
+
   c.remove();
-  return { ok: true };
+
+  var out = { ok: true, compId: compId, name: compName };
+  var kept = [];
+  var toRemove = [];
+  var gone = [];
+  for (var i = 0; i < solids.length; i++) {
+    // Re-fetched by id after the removal rather than held across it — the
+    // handle staleness this repo has measured elsewhere is not worth risking
+    // for one lookup per solid.
+    var item = app.project.itemByID(solids[i].id);
+    if (!item) { gone.push(solids[i]); continue; }
+    var uses = __usedInList(item);
+    if (uses.length > 0) {
+      kept.push({ id: item.id, name: item.name, usedIn: uses });
+      continue;
+    }
+    toRemove.push({ item: item, id: item.id, name: item.name, kind: "solid" });
+  }
+  if (gone.length > 0) out.solidsAlreadyGone = gone;
+
+  if (!purge) {
+    out.unusedSolidsLeft = toRemove.length;
+    if (toRemove.length > 0) {
+      out.note = toRemove.length + " solid item(s) this comp used are now used by nothing and remain in the project's Solids folder. " +
+        "Pass purgeUnusedSolids:true to remove them with the comp, or purge_unused_footage to sweep the whole project.";
+    }
+    return out;
+  }
+
+  var r = __removeItems(toRemove);
+  out.removedSolids = r.removed;
+  out.keptSolids = kept;
+  if (r.failed) {
+    var msg = "delete_comp removed comp \"" + compName + "\" (id " + compId + "), then failed purging its solids at \"" +
+      r.failed.name + "\" (id " + r.failed.id + "): " + r.error + ".";
+    if (r.removed.length > 0) msg += " Removed before it: " + __nameList(r.removed, 20) + ".";
+    else msg += " No solid had been removed yet.";
+    if (r.notAttempted.length > 0) msg += " Not attempted: " + __nameList(r.notAttempted, 20) + ".";
+    msg += " The comp is gone, so do not call delete_comp for it again. One Undo in After Effects restores the comp and " +
+      "these solids together; purge_unused_footage removes whatever is still left.";
+    throw new Error(msg);
+  }
+  if (kept.length > 0) {
+    out.note = kept.length + " solid item(s) were kept because another comp still uses them; see keptSolids.usedIn.";
+  }
+  return out;
+};
+
+// ---------------------------------------------------------------------------
+// duplicate_comp
+// ---------------------------------------------------------------------------
+// There was duplicate_layer, create_comp and delete_comp but no way to copy a
+// comp, so every rig workflow detoured through run_jsx and CompItem.duplicate()
+// (issue #54). Two things that detour never got right:
+//
+//   * AE's own Duplicate is SHALLOW. The copy's precomp layers point at the
+//     same source comps as the original, so "make a variant of this rig" and
+//     then editing the variant edits the original too. `deep:true` duplicates
+//     the nested comps as well and re-points the copy's layers at them, which
+//     is the entire value of the flag.
+//   * The same nested comp usually appears on several layers. Duplicating per
+//     layer fans out one copy per reference; __dupNested keeps a map from
+//     original id to its copy and reuses it, and registers the copy *before*
+//     recursing so a cycle terminates instead of recursing for ever.
+
+// AE happily allows two project items with the same name, which makes a
+// deep-duplicated rig unreadable in the project panel. Appending a counter is
+// the smaller evil, and the chosen name is reported either way.
+function __dupNameTaken(name) {
+  for (var i = 1; i <= app.project.numItems; i++) {
+    if (app.project.item(i).name === name) return true;
+  }
+  return false;
+}
+
+function __dupUniqueName(base) {
+  if (!__dupNameTaken(base)) return base;
+  for (var n = 2; n < 1000; n++) {
+    var candidate = base + " " + n;
+    if (!__dupNameTaken(candidate)) return candidate;
+  }
+  return base;
+}
+
+// Depth is a backstop, not the cycle guard — `seen` is. AE refuses to nest a
+// comp inside itself, but nothing here should recurse for ever if a future
+// build ever allows it.
+var __DUP_MAX_DEPTH = 32;
+
+function __dupNested(src, opts, depth) {
+  var key = "C" + src.id;
+  if (opts.seen.hasOwnProperty(key)) return opts.seen[key];
+  if (depth > __DUP_MAX_DEPTH) {
+    throw new Error("nested comps are more than " + __DUP_MAX_DEPTH + " deep below the comp being duplicated");
+  }
+  var srcId = src.id;
+  var srcName = src.name;
+  var dup = src.duplicate();
+  opts.seen[key] = dup;
+  if (opts.nameSuffix) dup.name = __dupUniqueName(srcName + opts.nameSuffix);
+  opts.created.push({ fromCompId: srcId, fromName: srcName, compId: dup.id, name: dup.name });
+  __dupRepoint(dup, opts, depth);
+  return dup;
+}
+
+// Re-point every precomp layer of a freshly duplicated comp at the duplicate of
+// its source rather than the original. Layers whose source is footage, and
+// layers with no source at all, are left alone.
+function __dupRepoint(comp, opts, depth) {
+  for (var i = 1; i <= comp.numLayers; i++) {
+    var l = comp.layer(i);
+    if (!(l instanceof AVLayer)) continue;
+    var srcItem = null;
+    try { srcItem = l.source; } catch (e) { continue; }
+    if (!srcItem || !(srcItem instanceof CompItem)) continue;
+    var replacement = __dupNested(srcItem, opts, depth + 1);
+    // fixExpressions:false — the layer keeps its name and its own properties,
+    // so there is nothing for AE to rewrite, and letting it rewrite expressions
+    // on a rig is a change nobody asked for.
+    l.replaceSource(replacement, false);
+    opts.repointed += 1;
+  }
+}
+
+// A `folderId` argument resolved to a FolderItem, or a thrown error naming the
+// id and what it actually is. Shared by duplicate_comp and purge_unused_footage.
+function __folderArg(id) {
+  var f = app.project.itemByID(id);
+  if (!f) throw new Error("No project item with id " + id + " to use as folderId");
+  if (!(f instanceof FolderItem)) {
+    throw new Error(
+      "folderId " + id + ' ("' + f.name + '") is a ' + __itemKind(f) +
+      ", not a project folder. Pass the id of a folder from get_project_summary, or omit folderId."
+    );
+  }
+  return f;
+}
+
+OPS.duplicate_comp = function (args) {
+  var src = getCompById(args.compId);
+  var folder = null;
+  if (args.folderId !== undefined && args.folderId !== null) folder = __folderArg(args.folderId);
+
+  var opts = { seen: {}, created: [], repointed: 0, nameSuffix: null };
+  if (args.nameSuffix) opts.nameSuffix = args.nameSuffix;
+
+  // Captured as primitives before the duplicate. Some AE calls invalidate every
+  // handle held across them (exportAsMotionGraphicsTemplate is the measured
+  // one), so nothing below reads `src` again.
+  var srcId = src.id;
+  var srcName = src.name;
+  var dup = src.duplicate();
+  var newId = dup.id;
+  if (args.name) dup.name = args.name;
+
+  if (args.deep) {
+    opts.seen["C" + srcId] = dup;
+    try {
+      __dupRepoint(dup, opts, 1);
+    } catch (e) {
+      // The copy and any nested copies made before the failure are real and
+      // nothing rolled them back. Reporting {ok:true} over a half-built rig, or
+      // an error that does not name what exists, are the same class of lie.
+      var madeIds = [];
+      madeIds.push(String(newId));
+      for (var m = 0; m < opts.created.length; m++) madeIds.push(String(opts.created[m].compId));
+      throw new Error(
+        "duplicate_comp deep failed part-way: " + e.message +
+        ". These comps were created and still exist: ids " + madeIds.join(", ") +
+        ". Undo once in After Effects to back the whole thing out, or delete_comp them."
+      );
+    }
+  }
+
+  // Re-fetch by id rather than trusting the handle held across the duplication.
+  var made = app.project.itemByID(newId);
+  if (!made) throw new Error("duplicate_comp created comp " + newId + " but it could not be read back");
+  if (folder) made.parentFolder = folder;
+
+  var out = __compSummary(made);
+  out.fromCompId = srcId;
+  out.fromName = srcName;
+  out.deep = !!args.deep;
+  if (folder) {
+    out.folderId = folder.id;
+    out.folderName = folder.name;
+  }
+  if (args.deep) {
+    out.nestedDuplicated = opts.created;
+    out.nestedCount = opts.created.length;
+    out.layersRepointed = opts.repointed;
+    if (opts.created.length === 0) {
+      out.note = "deep:true had nothing to do - this comp has no precomp layers.";
+    }
+  } else {
+    out.note = "Shallow copy: its precomp layers still point at the SAME nested comps as the original, " +
+      "so editing one of those edits both. Pass deep:true to duplicate the nested comps too.";
+  }
+  return out;
 };
 
 OPS.set_active_comp = function (args) {
@@ -371,15 +615,33 @@ OPS.create_text_layer = function (args) {
   var align = args.anchorAlign === undefined ? "left" : args.anchorAlign;
   var wantJustify = align !== "none" && __JUSTIFICATION[align] !== undefined;
   var wantTracking = args.tracking !== undefined || align !== "none";
+  var verified = null;
   if (args.font || args.size || args.color || wantJustify || wantTracking) {
     var srcText = l.property("Source Text");
     var td = srcText.value;
+    // The same TextDocument round trip set_text does, so the same read-back
+    // (issue #93 / #94, see __verifyJustification in text.jsx): the requested
+    // justification if there is one, otherwise whatever addText() gave the
+    // layer — 'none' promised to leave it alone, and that is checked too.
+    var justificationWanted = wantJustify ? __JUSTIFICATION[align] : td.justification;
     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]]; }
     if (wantTracking) td.tracking = (args.tracking !== undefined ? args.tracking : 0);
-    if (wantJustify) td.justification = __JUSTIFICATION[align];
+    if (wantJustify) td.justification = justificationWanted;
     srcText.setValue(td);
+    try {
+      verified = __verifyJustification(srcText, justificationWanted);
+    } catch (e) {
+      // A throw here would leave a layer the caller has no id for, and the
+      // natural next move — call again — makes two. Same rule as
+      // add_shape_content: take the node back, then say so. The message is
+      // amended on the same Error object so nothing about it is lost.
+      try { l.remove(); } catch (e2) {}
+      e.message = String(e.message) + " The new layer was removed, so nothing was created; " +
+        "create it with anchorAlign:\"none\" and set the alignment afterwards with set_text.";
+      throw e;
+    }
   }
   if (align !== "none") {
     l.property("Transform").property("Anchor Point").setValue([0, 0, 0]);
@@ -388,7 +650,12 @@ OPS.create_text_layer = function (args) {
     var p = args.position;
     l.property("Transform").property("Position").setValue(p.length === 3 ? p : [p[0], p[1]]);
   }
-  return __layerSummary(l);
+  var out = __layerSummary(l);
+  if (verified) {
+    out.justification = __justificationName(verified.justification);
+    out.justificationReasserted = verified.reasserted;
+  }
+  return out;
 };
 
 OPS.create_solid_layer = function (args) {
@@ -415,12 +682,59 @@ OPS.create_adjustment_layer = function (args) {
   return __layerSummary(l);
 };
 
+// Where a new shape layer's origin goes (issue #51).
+//
+// AE's addShape() leaves Position at the comp centre with the Anchor Point at
+// [0,0], so layer space is offset from comp space by half a frame. Every path
+// this toolset can write — set_shape_path vertices, add_shape_content vertices,
+// a rect/ellipse `position` — is expressed in *layer* space, and nothing in the
+// response says where that space starts. An agent authoring in comp pixels gets
+// the whole drawing shifted by (width/2, height/2), and the check that would
+// catch it is a downsampled screenshot.
+//
+// Default [0,0] makes layer space and comp space the same space for a fresh
+// shape layer, which is the only arrangement in which a vertex list means what
+// it says. "center" is AE's own spawn point, kept as one word so the old
+// behaviour is still one argument away.
+function __shapeSpawnPosition(comp, position) {
+  if (position === undefined || position === null) return [0, 0];
+  if (position === "center") return [comp.width / 2, comp.height / 2];
+  if (position instanceof Array && position.length >= 2) {
+    if (position.length === 3) return [position[0], position[1], position[2]];
+    return [position[0], position[1]];
+  }
+  throw new Error(
+    "create_shape_layer: position must be [x,y], [x,y,z] or the string \"center\" (After Effects' own " +
+    "spawn point, the comp centre). Got: " + String(position)
+  );
+}
+
 OPS.create_shape_layer = function (args) {
   var c = getCompById(args.compId);
+  var pos = __shapeSpawnPosition(c, args.position);
   var l = c.layers.addShape();
   if (args.name) l.name = args.name;
+  try {
+    l.property("Transform").property("Position").setValue(pos);
+  } catch (ePos) {
+    // The shape that can still get here is three components on a 2D layer, which
+    // AE refuses. Leaving an empty shape layer in the timeline behind a thrown
+    // error is the half-built failure add_shape_content refuses to produce.
+    try { l.remove(); } catch (eRm) {}
+    throw new Error(
+      "create_shape_layer could not set position to [" + pos.join(", ") + "]: " + ePos.message +
+      ". (A three-component position needs a 3D layer; create it 2D and set threeDLayer with set_layer first.) " +
+      "The empty layer was removed, so nothing changed."
+    );
+  }
   // shapes payload kept loose for v1 — the agent can use add_shape_content for detail
-  return __layerSummary(l);
+  var out = __layerSummary(l);
+  // Read both back rather than echoing what we asked for: together they are the
+  // coordinate space every subsequent path on this layer is measured in, and a
+  // caller should never have to render a frame to find out what it is.
+  out.position = l.property("Transform").property("Position").value;
+  out.anchorPoint = l.property("Transform").property("Anchor Point").value;
+  return out;
 };
 
 OPS.create_precomp_layer = function (args) {
@@ -824,165 +1138,894 @@ OPS.parent_layer = function (args) {
   return out;
 };
 
+// Layers do not reorder with moveTo. `moveTo` is a PropertyBase method for
+// re-ranking a property inside an indexed group, and calling it on a Layer
+// throws "parent is not an INDEXED_GROUP" — which is every call this op has
+// ever served (issue #70). AE's layer-level primitives are moveBefore,
+// moveAfter, moveToBeginning and moveToEnd, and all four take a *layer*, never
+// an index. (The one legitimate moveTo in this codebase is the shape-property
+// one in shapes.jsx; it is on a PropertyBase and stays.)
+//
+// Two ways in, because reorder is the op that invalidates indexes:
+//
+//   * `beforeLayerId` / `afterLayerId` — place this layer relative to another
+//     one by id. Nothing about the answer depends on the stack not having moved
+//     since the caller last read it, which is why these are the preferred form.
+//   * `toIndex` — the index the layer ends up at, counting from the front.
+//     Stated as the *landing* index because "the index it displaces" and "the
+//     index it lands on" differ by one when moving down the stack and the
+//     caller cannot tell which one a tool meant.
+//
+// The two directions need different primitives, and swapping them is off by one
+// with no error. Moving up (toIndex < from), the layer currently at the target
+// is pushed down, so moveBefore lands exactly on it. Moving down, that layer
+// shifts up by one as this one leaves, so moveAfter is what lands on the target.
 OPS.reorder_layer = function (args) {
   var c = getCompById(args.compId);
   var l = getLayerById(c, args.layerId);
-  l.moveTo(args.toIndex);
-  return __layerSummary(l);
+  var from = l.index;
+  var n = c.numLayers;
+  var to;
+
+  if (args.beforeLayerId !== undefined && args.beforeLayerId !== null) {
+    var b = getLayerById(c, args.beforeLayerId);
+    if (b.id === l.id) throw new Error("reorder_layer: beforeLayerId is the layer being moved (" + l.id + ").");
+    l.moveBefore(b);
+  } else if (args.afterLayerId !== undefined && args.afterLayerId !== null) {
+    var a = getLayerById(c, args.afterLayerId);
+    if (a.id === l.id) throw new Error("reorder_layer: afterLayerId is the layer being moved (" + l.id + ").");
+    l.moveAfter(a);
+  } else if (args.toIndex !== undefined && args.toIndex !== null) {
+    to = Math.round(args.toIndex);
+    if (to < 1) to = 1;
+    if (to > n) to = n;
+    if (to === from) {
+      // Nothing to do. Saying so beats an AE call that is a no-op anyway.
+    } else if (to === 1) {
+      l.moveToBeginning();
+    } else if (to === n) {
+      l.moveToEnd();
+    } else if (to < from) {
+      l.moveBefore(c.layer(to));
+    } else {
+      l.moveAfter(c.layer(to));
+    }
+  } else {
+    throw new Error("reorder_layer: pass one of toIndex, beforeLayerId or afterLayerId.");
+  }
+
+  // Report both ends of the move. The landing index is read back off the layer
+  // rather than assumed, so a result can never claim a position AE did not
+  // give it — and `movedFrom === index` is how a caller sees a no-op.
+  var out = __layerSummary(l);
+  out.movedFrom = from;
+  return out;
 };
 
 
-// ===== transforms.jsx =====
+// ===== snapshot.jsx =====
 
-// transforms.jsx — fast-path for setting common transform properties.
+// snapshot.jsx — a cheap structural fingerprint of a comp, and the diff
+// between two of them.
+//
+// Verifying a write today means reading the comp back and comparing by eye,
+// and every one of those reads is re-sent on every later request for the rest
+// of the session. A fingerprint is the other end of that trade: it records
+// what an agent actually checks after a write — which layers exist, what they
+// are called, where they sit in time, what they are parented to, how many
+// keyframes/expressions/effects they carry — and nothing else. The diff of two
+// of them is a few dozen tokens for "3 layers added: ids 512-514; layer 498
+// Opacity keys 0 -> 4" (issue #52).
+//
+// Cheapness is the whole point, so the walk stops at the layer's own Transform
+// group plus four named properties. It never opens an effect's parameters or a
+// shape layer's Contents — those are what make get_layer_full expensive, and a
+// fingerprint that costs as much as the read it replaces is worth nothing.
+//
+// That has a cost of its own, and per the "a scoped read must say what it left
+// out" rule it is stated rather than left to be discovered: a diff can only
+// report a field it records. __DIFF_COVERS travels with every diff for exactly
+// that reason — "no differences" must never be read as "identical".
+
+var __DIFF_COVERS = "Compares recorded fields only - not property values, expression text, " +
+  "effect parameters, masks or shape contents. \"No differences\" means none of the recorded fields moved, " +
+  "not that the two states render identically.";
+
+var __FP_COVERS = "A snapshot records, per layer: id, name, index, type, inPoint, outPoint, startTime, " +
+  "parentId, enabled, keyframe counts per Transform property (plus Marker, Time Remap and Source Text), " +
+  "expression count and effect count. Per comp: name, size, duration, frame rate, work area and markers. " +
+  "It does NOT record property values, expression text, effect parameters, mask shapes or shape contents, " +
+  "because reading those costs as much as the read this replaces.";
+
+// Times are floats out of AE and are compared, not displayed, so they are
+// rounded once here rather than at every comparison site.
+var __FP_PRECISION = 1000000;
+
+function __fpRound(n) {
+  if (typeof n !== "number") return n;
+  if (!isFinite(n)) return null;
+  return Math.round(n * __FP_PRECISION) / __FP_PRECISION;
+}
 
-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);
+// Properties worth a fingerprint that do not live under Transform. Each is one
+// guarded lookup; a layer that has none of them pays four null checks.
+var __FP_EXTRA_PROPS = ["Marker", "Time Remap", "Source Text", "Audio Levels"];
+
+function __fpCountProperty(p, out) {
+  if (!p) return;
+  var keys = 0;
+  try { keys = p.numKeys; } catch (e) { return; }
+  if (typeof keys !== "number") return;
+  if (keys > 0) out.keyCounts[p.name] = keys;
+  try {
+    if (p.canSetExpression && p.expression) out.expressionCount += 1;
+  } catch (e2) {}
+}
+
+function __fpLayer(l) {
+  var out = {
+    id: l.id,
+    name: l.name,
+    index: l.index,
+    type: __layerKind(l),
+    inPoint: __fpRound(l.inPoint),
+    outPoint: __fpRound(l.outPoint),
+    startTime: __fpRound(l.startTime),
+    parentId: null,
+    enabled: l.enabled,
+    keyCounts: {},
+    expressionCount: 0,
+    effectCount: 0
+  };
+  try { if (l.parent) out.parentId = l.parent.id; } catch (e0) {}
+
+  var tr = null;
+  try { tr = l.property("Transform"); } catch (e1) {}
+  if (tr) {
+    for (var i = 1; i <= tr.numProperties; i++) __fpCountProperty(tr.property(i), out);
   }
+  for (var j = 0; j < __FP_EXTRA_PROPS.length; j++) {
+    var extra = null;
+    try { extra = l.property(__FP_EXTRA_PROPS[j]); } catch (e2) {}
+    __fpCountProperty(extra, out);
+  }
+  // Effects are counted, never walked. The parameter tree is the expensive
+  // part and an agent checking "did my effect land" only needs the count plus
+  // list_effects when it did not.
+  try {
+    var fx = l.property("Effects");
+    if (fx) out.effectCount = fx.numProperties;
+  } catch (e3) {}
+  return out;
 }
 
-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);
+function __fpCompMarkers(c) {
+  var out = [];
+  var mp = null;
+  try { mp = c.markerProperty; } catch (e) { return out; }
+  if (!mp) return out;
+  var n = 0;
+  try { n = mp.numKeys; } catch (e2) { return out; }
+  for (var i = 1; i <= n; i++) {
+    var mv = mp.keyValue(i);
+    out.push(String(__fpRound(mp.keyTime(i))) + "|" + String(mv.comment) + "|" + String(__fpRound(mv.duration)));
   }
-  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 };
-};
+  return out;
+}
 
+function __compFingerprint(compId) {
+  var c = getCompById(compId);
+  var fp = {
+    compId: c.id,
+    name: c.name,
+    width: c.width,
+    height: c.height,
+    duration: __fpRound(c.duration),
+    frameRate: __fpRound(c.frameRate),
+    workAreaStart: __fpRound(c.workAreaStart),
+    workAreaDuration: __fpRound(c.workAreaDuration),
+    numLayers: c.numLayers,
+    markers: __fpCompMarkers(c),
+    layers: []
+  };
+  for (var i = 1; i <= c.numLayers; i++) fp.layers.push(__fpLayer(c.layer(i)));
+  return fp;
+}
 
-// ===== keyframes.jsx =====
+// ---------------------------------------------------------------------------
+// The diff
+// ---------------------------------------------------------------------------
+// Pure: two fingerprints in, one object out, no AE. That is what lets it be
+// tested against synthetic input (tests/unit/comp-snapshot.mjs) — there is no
+// ExtendScript runtime on a runner and this is the part that has to be right.
+
+// Below a frame at any sane frame rate, above the float noise a round-trip
+// through JSON leaves behind. Without it a comp re-read after a frame-rate
+// change reports every layer "retimed" by 1e-15.
+var __DIFF_EPS = 0.000001;
+
+function __diffMoved(a, b) {
+  if (typeof a !== "number") return a !== b;
+  if (typeof b !== "number") return true;
+  return Math.abs(a - b) > __DIFF_EPS;
+}
 
-// keyframes.jsx — generic keyframe ops.
+// ES3 has no Map. The "L" prefix keeps a numeric id away from anything already
+// on Object.prototype.
+function __fpById(fp) {
+  var m = {};
+  for (var i = 0; i < fp.layers.length; i++) m["L" + fp.layers[i].id] = fp.layers[i];
+  return m;
+}
 
-var __INTERP_MAP = {
-  linear: KeyframeInterpolationType.LINEAR,
-  bezier: KeyframeInterpolationType.BEZIER,
-  hold: KeyframeInterpolationType.HOLD,
-};
+function __diffKeyCounts(a, b) {
+  var out = null;
+  var seen = {};
+  var k;
+  for (k in a) {
+    if (!a.hasOwnProperty(k)) continue;
+    seen[k] = true;
+    var bv = 0;
+    if (b.hasOwnProperty(k)) bv = b[k];
+    if (a[k] !== bv) {
+      if (!out) out = {};
+      out[k] = { from: a[k], to: bv };
+    }
+  }
+  for (k in b) {
+    if (!b.hasOwnProperty(k)) continue;
+    if (seen[k]) continue;
+    if (!out) out = {};
+    out[k] = { from: 0, to: b[k] };
+  }
+  return out;
+}
 
-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;
+var __DIFF_EXACT_FIELDS = ["name", "type", "enabled"];
+var __DIFF_TIME_FIELDS = ["inPoint", "outPoint", "startTime"];
+var __DIFF_COUNT_FIELDS = ["expressionCount", "effectCount"];
+
+// `index` is deliberately not compared here: inserting one layer shifts every
+// index below it, which would report twenty changed layers for one addition.
+// Relative order is compared separately, in __diffReordered.
+function __diffLayer(a, b) {
+  var ch = {};
+  var n = 0;
+  var i, k;
+  for (i = 0; i < __DIFF_EXACT_FIELDS.length; i++) {
+    k = __DIFF_EXACT_FIELDS[i];
+    if (a[k] !== b[k]) { ch[k] = { from: a[k], to: b[k] }; n += 1; }
   }
-  return -1;
+  for (i = 0; i < __DIFF_TIME_FIELDS.length; i++) {
+    k = __DIFF_TIME_FIELDS[i];
+    if (__diffMoved(a[k], b[k])) { ch[k] = { from: a[k], to: b[k] }; n += 1; }
+  }
+  for (i = 0; i < __DIFF_COUNT_FIELDS.length; i++) {
+    k = __DIFF_COUNT_FIELDS[i];
+    if (a[k] !== b[k]) { ch[k] = { from: a[k], to: b[k] }; n += 1; }
+  }
+  if (a.parentId !== b.parentId) { ch.parentId = { from: a.parentId, to: b.parentId }; n += 1; }
+  var kc = __diffKeyCounts(a.keyCounts || {}, b.keyCounts || {});
+  if (kc) { ch.keyCounts = kc; n += 1; }
+  if (n === 0) return null;
+  return { id: b.id, name: b.name, changes: ch };
 }
 
-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);
+// Only layers present on both sides, and only when their order relative to one
+// another actually changed. A layer added or removed elsewhere in the stack is
+// not a reorder of anything.
+function __diffReordered(before, after, aMap, bMap) {
+  var seqA = [];
+  var seqB = [];
+  var i;
+  for (i = 0; i < before.layers.length; i++) {
+    var idA = before.layers[i].id;
+    if (bMap.hasOwnProperty("L" + idA)) seqA.push(idA);
+  }
+  for (i = 0; i < after.layers.length; i++) {
+    var idB = after.layers[i].id;
+    if (aMap.hasOwnProperty("L" + idB)) seqB.push(idB);
   }
+  if (seqA.length !== seqB.length) return null;
+  var same = true;
+  for (i = 0; i < seqA.length; i++) {
+    if (seqA[i] !== seqB[i]) { same = false; break; }
+  }
+  if (same) return null;
+  var posA = {};
+  for (i = 0; i < seqA.length; i++) posA["L" + seqA[i]] = i;
+  var moved = [];
+  for (i = 0; i < seqB.length; i++) {
+    var id = seqB[i];
+    if (posA["L" + id] === i) continue;
+    moved.push({
+      id: id,
+      name: bMap["L" + id].name,
+      fromIndex: aMap["L" + id].index,
+      toIndex: bMap["L" + id].index
+    });
+  }
+  if (moved.length === 0) return null;
+  return moved;
 }
 
-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);
+function __diffMarkers(a, b) {
+  if (a.length !== b.length) return { from: a.length, to: b.length };
+  for (var i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return { count: a.length, edited: true };
   }
-  return { ok: true, keyIndex: __findKeyIndexAtTime(prop, args.time) };
-};
+  return null;
+}
 
-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 };
-};
+function __diffCompFields(a, b) {
+  var ch = {};
+  var n = 0;
+  if (a.name !== b.name) { ch.name = { from: a.name, to: b.name }; n += 1; }
+  if (a.width !== b.width || a.height !== b.height) {
+    ch.size = { from: [a.width, a.height], to: [b.width, b.height] };
+    n += 1;
+  }
+  if (__diffMoved(a.duration, b.duration)) { ch.duration = { from: a.duration, to: b.duration }; n += 1; }
+  if (__diffMoved(a.frameRate, b.frameRate)) { ch.frameRate = { from: a.frameRate, to: b.frameRate }; n += 1; }
+  if (__diffMoved(a.workAreaStart, b.workAreaStart) || __diffMoved(a.workAreaDuration, b.workAreaDuration)) {
+    ch.workArea = {
+      from: [a.workAreaStart, a.workAreaDuration],
+      to: [b.workAreaStart, b.workAreaDuration]
+    };
+    n += 1;
+  }
+  var mk = __diffMarkers(a.markers || [], b.markers || []);
+  if (mk) { ch.markers = mk; n += 1; }
+  if (n === 0) return null;
+  return ch;
+}
 
-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) {}
+// ---------- summary prose ----------
+
+function __diffPlural(n) {
+  if (n === 1) return "";
+  return "s";
+}
+
+// "512-514" for a run, "512, 517" otherwise. Ids come out of AE in creation
+// order, so a batch of new layers is nearly always consecutive and this is the
+// difference between a readable line and a wall of numbers.
+function __diffIdList(ids) {
+  if (!ids.length) return "";
+  var sorted = [];
+  for (var i = 0; i < ids.length; i++) sorted.push(ids[i]);
+  sorted.sort(function (x, y) { return x - y; });
+  var parts = [];
+  var start = sorted[0];
+  var prev = sorted[0];
+  for (var j = 1; j <= sorted.length; j++) {
+    var cur = sorted[j];
+    var breaks = true;
+    if (j < sorted.length && cur === prev + 1) breaks = false;
+    if (breaks) {
+      if (start === prev) parts.push(String(start));
+      else if (prev === start + 1) parts.push(String(start) + ", " + String(prev));
+      else parts.push(String(start) + "-" + String(prev));
+      start = cur;
     }
-    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,
-    });
+    prev = cur;
   }
-  return keys;
-});
+  return parts.join(", ");
+}
 
-function __invInterp(t) {
-  if (t === KeyframeInterpolationType.LINEAR) return "linear";
-  if (t === KeyframeInterpolationType.BEZIER) return "bezier";
-  if (t === KeyframeInterpolationType.HOLD) return "hold";
-  return "unknown";
+function __diffParentLabel(v) {
+  if (v === null || v === undefined) return "none";
+  return String(v);
 }
 
-OPS.set_interpolation = function (args) {
-  var c = getCompById(args.compId);
-  var l = getLayerById(c, args.layerId);
+function __diffLayerPhrases(entry) {
+  var label = "layer " + entry.id;
+  var c = entry.changes;
+  var out = [];
+  if (c.name) out.push(label + ' renamed "' + c.name.from + '" -> "' + c.name.to + '"');
+  if (c.enabled) {
+    if (c.enabled.to) out.push(label + " enabled");
+    else out.push(label + " disabled");
+  }
+  var times = [];
+  if (c.inPoint) times.push("in " + c.inPoint.from + " -> " + c.inPoint.to);
+  if (c.outPoint) times.push("out " + c.outPoint.from + " -> " + c.outPoint.to);
+  if (c.startTime) times.push("start " + c.startTime.from + " -> " + c.startTime.to);
+  if (times.length) out.push(label + " retimed (" + times.join(", ") + ")");
+  if (c.parentId) {
+    out.push(label + " re-parented " + __diffParentLabel(c.parentId.from) + " -> " + __diffParentLabel(c.parentId.to));
+  }
+  if (c.keyCounts) {
+    for (var k in c.keyCounts) {
+      if (!c.keyCounts.hasOwnProperty(k)) continue;
+      out.push(label + " " + k + " keys " + c.keyCounts[k].from + " -> " + c.keyCounts[k].to);
+    }
+  }
+  if (c.effectCount) out.push(label + " effects " + c.effectCount.from + " -> " + c.effectCount.to);
+  if (c.expressionCount) {
+    out.push(label + " expressions " + c.expressionCount.from + " -> " + c.expressionCount.to);
+  }
+  if (c.type) out.push(label + " type " + c.type.from + " -> " + c.type.to);
+  return out;
+}
+
+function __diffCompPhrases(ch) {
+  var out = [];
+  if (ch.name) out.push('comp renamed "' + ch.name.from + '" -> "' + ch.name.to + '"');
+  if (ch.size) {
+    out.push("comp resized " + ch.size.from[0] + "x" + ch.size.from[1] + " -> " + ch.size.to[0] + "x" + ch.size.to[1]);
+  }
+  if (ch.duration) out.push("comp duration " + ch.duration.from + " -> " + ch.duration.to);
+  if (ch.frameRate) out.push("comp frame rate " + ch.frameRate.from + " -> " + ch.frameRate.to);
+  if (ch.workArea) out.push("comp work area moved");
+  if (ch.markers) {
+    if (ch.markers.edited) out.push("comp markers edited");
+    else out.push("comp markers " + ch.markers.from + " -> " + ch.markers.to);
+  }
+  return out;
+}
+
+// One line. Past this many clauses the rest is counted rather than spelled out
+// — the structured fields carry everything, and a summary nobody reads to the
+// end is worse than a short one that names where to look.
+var __DIFF_SUMMARY_CLAUSES = 8;
+
+function __diffSummary(d) {
+  var parts = [];
+  var i;
+  if (d.added) {
+    var addedIds = [];
+    for (i = 0; i < d.added.length; i++) addedIds.push(d.added[i].id);
+    parts.push(d.added.length + " layer" + __diffPlural(d.added.length) + " added: ids " + __diffIdList(addedIds));
+  }
+  if (d.removed) {
+    var removedIds = [];
+    for (i = 0; i < d.removed.length; i++) removedIds.push(d.removed[i].id);
+    parts.push(d.removed.length + " layer" + __diffPlural(d.removed.length) + " removed: ids " + __diffIdList(removedIds));
+  }
+  if (d.reordered) {
+    parts.push(d.reordered.length + " layer" + __diffPlural(d.reordered.length) + " moved in the stack");
+  }
+  if (d.changed) {
+    for (i = 0; i < d.changed.length; i++) {
+      var phrases = __diffLayerPhrases(d.changed[i]);
+      for (var p = 0; p < phrases.length; p++) parts.push(phrases[p]);
+    }
+  }
+  if (d.comp) {
+    var compPhrases = __diffCompPhrases(d.comp);
+    for (i = 0; i < compPhrases.length; i++) parts.push(compPhrases[i]);
+  }
+  if (parts.length === 0) {
+    return "No differences in the recorded fields. Property values, expression text, effect parameters " +
+      "and shape contents are not compared, so this is not a claim that nothing changed at all.";
+  }
+  if (parts.length > __DIFF_SUMMARY_CLAUSES) {
+    var extra = parts.length - __DIFF_SUMMARY_CLAUSES;
+    parts = parts.slice(0, __DIFF_SUMMARY_CLAUSES);
+    parts.push("and " + extra + " more change" + __diffPlural(extra) + " (see the fields below)");
+  }
+  return parts.join("; ");
+}
+
+// Two fingerprints -> only what moved. Unchanged layers are counted, never
+// listed: listing them is the cost this whole thing exists to avoid.
+function __diffFingerprints(before, after) {
+  var aMap = __fpById(before);
+  var bMap = __fpById(after);
+  var added = [];
+  var removed = [];
+  var changed = [];
+  var unchanged = 0;
+  var i, l;
+  for (i = 0; i < after.layers.length; i++) {
+    l = after.layers[i];
+    var prev = aMap["L" + l.id];
+    if (!prev) {
+      added.push({ id: l.id, name: l.name, index: l.index, type: l.type });
+      continue;
+    }
+    var d = __diffLayer(prev, l);
+    if (d) changed.push(d);
+    else unchanged += 1;
+  }
+  for (i = 0; i < before.layers.length; i++) {
+    l = before.layers[i];
+    if (bMap.hasOwnProperty("L" + l.id)) continue;
+    removed.push({ id: l.id, name: l.name, index: l.index, type: l.type });
+  }
+  var reordered = __diffReordered(before, after, aMap, bMap);
+  var comp = __diffCompFields(before, after);
+
+  var out = { compId: after.compId, compName: after.name };
+  if (added.length) out.added = added;
+  if (removed.length) out.removed = removed;
+  if (changed.length) out.changed = changed;
+  if (reordered) out.reordered = reordered;
+  if (comp) out.comp = comp;
+  out.unchangedLayers = unchanged;
+  var count = added.length + removed.length + changed.length;
+  if (reordered) count += reordered.length;
+  if (comp) count += 1;
+  out.changeCount = count;
+  out.summary = __diffSummary(out);
+  out.covers = __DIFF_COVERS;
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Ops
+// ---------------------------------------------------------------------------
+// Both are internal: the tools an agent sees are snapshot_comp and diff_comp,
+// and those are half server-resident. Only the panel can read After Effects,
+// and only the server can remember anything between calls — so the server
+// keeps the fingerprint and these two gather it. See snapshots/store.ts.
+
+OPS._comp_fingerprint = noUndo(function (args) {
+  return __compFingerprint(args.compId);
+});
+
+OPS._comp_diff = noUndo(function (args) {
+  var before = args.since;
+  if (!before || !before.layers) {
+    throw new Error("_comp_diff needs a stored fingerprint in `since` (the MCP server supplies it from the snapshot id)");
+  }
+  var compId = args.compId;
+  if (compId === undefined || compId === null) compId = before.compId;
+  var after = __compFingerprint(compId);
+  return { diff: __diffFingerprints(before, after), fingerprint: after };
+});
+
+// ---------------------------------------------------------------------------
+// diff:true on the write ops
+// ---------------------------------------------------------------------------
+// The before-fingerprint has to be taken inside the same bridge call as the
+// write, or it is not a before at all: a separate snapshot_comp is a second
+// round-trip during which anything can happen, and the agent has to remember to
+// make it. run_jsx and run_batch therefore fingerprint, run, fingerprint again,
+// and diff — one call, one answer.
+
+function __diffPushUnique(list, v) {
+  for (var i = 0; i < list.length; i++) {
+    if (list[i] === v) return;
+  }
+  list.push(v);
+}
+
+// Explicit diffCompId wins. Otherwise a batch names its own comps in its ops,
+// and a script gets the comp the user is looking at. When none of the three
+// yields anything the diff is refused with a reason rather than quietly
+// skipped — a missing diff that looks like "nothing changed" is the failure
+// this whole feature exists to prevent.
+function __diffCompIds(args, ops) {
+  var ids = [];
+  if (args && args.diffCompId !== undefined && args.diffCompId !== null) {
+    __diffPushUnique(ids, args.diffCompId);
+    return ids;
+  }
+  if (ops) {
+    for (var i = 0; i < ops.length; i++) {
+      var a = ops[i].args;
+      if (a && typeof a.compId === "number") __diffPushUnique(ids, a.compId);
+    }
+    if (ids.length > 0) return ids;
+  }
+  var active = null;
+  try { active = app.project.activeItem; } catch (e) {}
+  if (active && active instanceof CompItem) __diffPushUnique(ids, active.id);
+  return ids;
+}
+
+function __diffStart(args, ops) {
+  if (!args || !args.diff) return null;
+  var ids = __diffCompIds(args, ops);
+  if (ids.length === 0) {
+    return {
+      unavailable: true,
+      reason: "no compId appeared in this call and no composition is open in the viewer — pass diffCompId to name the comp to fingerprint"
+    };
+  }
+  var state = { ids: ids, before: [], unavailable: false };
+  for (var i = 0; i < ids.length; i++) {
+    try {
+      state.before.push(__compFingerprint(ids[i]));
+    } catch (e) {
+      return { unavailable: true, reason: "comp " + ids[i] + " could not be fingerprinted before the call: " + e.message };
+    }
+  }
+  return state;
+}
+
+function __diffFinish(state) {
+  if (!state) return null;
+  if (state.unavailable) {
+    return {
+      unavailable: true,
+      reason: state.reason,
+      summary: "No diff was taken: " + state.reason + ". The call itself is unaffected."
+    };
+  }
+  var comps = [];
+  var total = 0;
+  for (var i = 0; i < state.before.length; i++) {
+    var b = state.before[i];
+    var after = null;
+    try {
+      after = __compFingerprint(b.compId);
+    } catch (e) {
+      comps.push({
+        compId: b.compId,
+        compName: b.name,
+        gone: true,
+        changeCount: 1,
+        summary: "comp " + b.compId + ' ("' + b.name + '") can no longer be read: ' + e.message
+      });
+      total += 1;
+      continue;
+    }
+    var d = __diffFingerprints(b, after);
+    comps.push(d);
+    total += d.changeCount;
+  }
+  if (comps.length === 1) return comps[0];
+  var parts = [];
+  for (var j = 0; j < comps.length; j++) parts.push("comp " + comps[j].compId + ": " + comps[j].summary);
+  return { comps: comps, changeCount: total, summary: parts.join(" | "), covers: __DIFF_COVERS };
+}
+
+// A script or batch that threw still changed whatever it changed before it
+// stopped, and nothing rolls back. Finding that stop point by reading the comp
+// back is one of the three cases issue #52 was opened for, so the diff is put
+// where the agent will actually see it: on the error. The error object itself
+// is mutated rather than replaced, so `line` and `stack` survive for the
+// caller's own reporting.
+function __diffAnnotateError(e, state) {
+  if (!state) return;
+  var d = null;
+  try { d = __diffFinish(state); } catch (e2) { return; }
+  if (!d || !d.summary) return;
+  try {
+    e.message = String(e.message) + " || Changed before it stopped: " + d.summary +
+      " (nothing rolls back - read the state back rather than re-running)";
+  } catch (e3) {}
+}
+
+// run_jsx returns whatever the script returned, which may be a number or a
+// string with nowhere to hang a diff on. With diff:true it is enveloped
+// instead. The null envelope __rjResult already builds is the right shape
+// already, so that one is extended rather than nested inside a second one.
+function __rjWithDiff(out, diff, undoGroupName) {
+  if (out && typeof out === "object" && !(out instanceof Array) &&
+      out.ok === true && out.returned === null && out.note) {
+    out.diff = diff;
+    return out;
+  }
+  return { ok: true, returned: out, undoGroup: undoGroupName, diff: diff };
+}
+
+
+// ===== 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;
+}
+
+// ---------- ease array sizing (issue #50) ----------
+//
+// setTemporalEaseAtKey wants an array of KeyframeEase whose length belongs to
+// the *property*, and it is not derivable from the value: a 2D layer Scale
+// wants 3, a shape Ellipse Size wants 2 while its value reads [w,h], Opacity
+// and a slider want 1, and a spatial Position wants 1 whether the layer is 2D
+// or 3D because the ease runs along the motion path. Get it wrong and AE throws
+// "parameter 2" and says nothing else — no property name, no expected count.
+//
+// So: derive the likely count from the property, then try the others. The
+// derivation is the fast path; the retry is the safety net, because the Ellipse
+// Size case is precisely the one no table gets right from the outside. Whatever
+// AE accepted is reported back, so the answer for a given property stops being
+// folklore and becomes something a caller can read off a result.
+var __EASE_ARITIES = [1, 2, 3, 4];
+
+/** The count to try first, from the property rather than from the value passed in. */
+function __easePropertyArity(prop) {
+  // Spatial first and unconditionally: a 3D Position is ThreeD_SPATIAL and
+  // still takes one entry, so the value type must not get a say here.
+  if (prop.isSpatial) return 1;
+  var vt = null;
+  try { vt = prop.propertyValueType; } catch (eType) {}
+  if (vt !== null && vt !== undefined && typeof PropertyValueType !== "undefined") {
+    if (vt === PropertyValueType.OneD) return 1;
+    if (vt === PropertyValueType.TwoD) return 2;
+    if (vt === PropertyValueType.TwoD_SPATIAL) return 1;
+    if (vt === PropertyValueType.ThreeD) return 3;
+    if (vt === PropertyValueType.ThreeD_SPATIAL) return 1;
+    if (vt === PropertyValueType.COLOR) return 4;
+  }
+  var v = null;
+  try { v = prop.value; } catch (eVal) {}
+  if (v && v.length) return v.length;
+  return 1;
+}
+
+/** Derived count first, then every other plausible one, no repeats. */
+function __easeArityCandidates(prop) {
+  var first = __easePropertyArity(prop);
+  var out = [first];
+  for (var i = 0; i < __EASE_ARITIES.length; i++) {
+    if (__EASE_ARITIES[i] !== first) out.push(__EASE_ARITIES[i]);
+  }
+  return out;
+}
+
+function __easeArray(ease, n) {
+  var arr = [];
+  for (var i = 0; i < n; i++) arr.push(new KeyframeEase(ease.speed, ease.influence));
+  return arr;
+}
+
+/**
+ * Apply one {influence, speed} pair to every dimension of `prop` at `keyIndex`,
+ * and return the number of KeyframeEase entries After Effects accepted.
+ *
+ * Throws only when no count works, naming every one it tried. An ease that
+ * quietly failed to land is invisible until someone watches the render, which
+ * is the same class of lie as a swallowed error.
+ */
+function __applyTemporalEase(prop, keyIndex, easeIn, easeOut) {
+  var inEase = easeIn || { influence: 33, speed: 0 };
+  var outEase = easeOut || { influence: 33, speed: 0 };
+  var candidates = __easeArityCandidates(prop);
+  var lastMessage = "";
+  for (var i = 0; i < candidates.length; i++) {
+    var n = candidates[i];
+    try {
+      prop.setTemporalEaseAtKey(keyIndex, __easeArray(inEase, n), __easeArray(outEase, n));
+      return n;
+    } catch (e) {
+      lastMessage = (e && e.message) ? String(e.message) : String(e);
+    }
+  }
+  var label = "the property";
+  try { label = "'" + prop.name + "'"; } catch (eName) {}
+  throw new Error(
+    "Could not set the temporal ease on " + label + " at key " + keyIndex + ": After Effects rejected ease " +
+    "arrays of " + candidates.join(", ") + " entries. Last error from AE: " + lastMessage
+  );
+}
+
+/** Returns the ease arity that was used, or null when no ease was requested. */
+function __applyInterpolationToKey(prop, keyIndex, interp) {
+  if (!interp) return null;
+  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) {
+    return __applyTemporalEase(prop, keyIndex, interp.easeIn, interp.easeOut);
+  }
+  return null;
+}
+
+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);
+  var easeDimensions = null;
+  if (args.interpolation) {
+    var idx = __findKeyIndexAtTime(prop, args.time);
+    if (idx > 0) easeDimensions = __applyInterpolationToKey(prop, idx, args.interpolation);
+  }
+  var out = { ok: true, keyIndex: __findKeyIndexAtTime(prop, args.time) };
+  if (easeDimensions !== null) out.easeDimensions = easeDimensions;
+  return out;
+};
+
+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 };
@@ -992,8 +2035,13 @@ 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 };
+  // A call with neither ease would previously return {ok:true} having done
+  // nothing at all, which reads as "the ease is set" to whoever asked for it.
+  if (!args.easeIn && !args.easeOut) {
+    throw new Error("set_temporal_ease needs easeIn, easeOut or both — nothing was changed.");
+  }
+  var n = __applyTemporalEase(prop, args.keyIndex, args.easeIn, args.easeOut);
+  return { ok: true, easeDimensions: n };
 };
 
 OPS.set_spatial_tangents = function (args) {
@@ -1010,11 +2058,54 @@ OPS.set_spatial_tangents = function (args) {
 
 // expressions.jsx — get/set/toggle/clear expressions on any property.
 
+// After Effects reports a broken expression on `Property.expressionError` and
+// nowhere a script can otherwise see: assigning `.expression` succeeds whatever
+// the text says, and the failure is a warning banner in the UI (issue #97).
+// The field is filled in when the expression is *evaluated*, which a bare
+// assignment does not necessarily do — so the value is read first, inside a
+// try, purely to force one evaluation. Whether AE would populate the field
+// without that nudge cannot be settled offline; forcing it costs one evaluation
+// and makes the answer independent of the question. `.value` throws on a
+// property that has none (a group), which is also not an expression error.
+function __expressionError(prop) {
+  try { var forced = prop.value; } catch (e) {}
+  var err = "";
+  try { err = prop.expressionError; } catch (e2) { err = ""; }
+  return err ? String(err) : "";
+}
+
+function __propertyPathLabel(path) {
+  var parts = [];
+  for (var i = 0; i < path.length; i++) parts.push(String(path[i]));
+  return parts.join(" > ");
+}
+
+// Throws if the expression on `prop` does not evaluate, naming the property,
+// AE's own message and both ways forward. The expression stays written — the
+// message says so — because nothing here rolls back and a caller fixing a
+// typo wants the property it was aimed at, not a cleared one.
+function __assertExpressionEvaluates(prop, path, verb) {
+  var err = __expressionError(prop);
+  if (!err) return;
+  var enabledNow;
+  try { enabledNow = !!prop.expressionEnabled; } catch (e) { enabledNow = null; }
+  throw new Error(
+    "Expression on " + __propertyPathLabel(path) + " was " + verb +
+    " but After Effects cannot evaluate it: " + err +
+    (enabledNow === false ? " (After Effects has disabled it.)" : "") +
+    " Fix the expression and call set_expression again, or clear_expression to remove it."
+  );
+}
+
 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 };
+  return {
+    expression: prop.expression || "",
+    enabled: !!prop.expressionEnabled,
+    expressionError: __expressionError(prop),
+  };
 });
 
 OPS.set_expression = function (args) {
@@ -1023,6 +2114,7 @@ OPS.set_expression = function (args) {
   var prop = walkProperty(l, args.propertyPath);
   prop.expression = args.expression || "";
   prop.expressionEnabled = true;
+  __assertExpressionEvaluates(prop, args.propertyPath, "written");
   return { ok: true };
 };
 
@@ -1031,6 +2123,9 @@ OPS.toggle_expression = function (args) {
   var l = getLayerById(c, args.layerId);
   var prop = walkProperty(l, args.propertyPath);
   prop.expressionEnabled = !!args.enabled;
+  // Disabling cannot fail this way; enabling can surface an error that has
+  // been sitting on the property since it was disabled.
+  if (args.enabled) __assertExpressionEvaluates(prop, args.propertyPath, "enabled");
   return { ok: true };
 };
 
@@ -1184,12 +2279,63 @@ var __JUSTIFICATION = {
   full: ParagraphJustification.FULL_JUSTIFY_LASTLINE_LEFT,
 };
 
-OPS.set_text = function (args) {
-  var c = getCompById(args.compId);
-  var l = getLayerById(c, args.layerId);
+// The name for an enum value, for results and errors. AE has more FULL_JUSTIFY
+// variants than the map offers, so a value the map does not know comes back as
+// its number rather than as the nearest name.
+function __justificationName(v) {
+  for (var k in __JUSTIFICATION) {
+    if (__JUSTIFICATION.hasOwnProperty(k) && __JUSTIFICATION[k] === v) return k;
+  }
+  return String(v);
+}
+
+// Issue #93: on AE 26.3 the TextDocument round trip — read `.value`, change
+// `.text`, `setValue()` — has come back with justification reset to CENTER
+// even though the document that went in still said LEFT; issue #94 reports the
+// setter storing RIGHT when handed CENTER from a script. Nothing raises in
+// either case and the mechanism is unknown, so the only guard that can be built
+// blind is the one this repo asks for anyway: read the property back and
+// compare with what should be there. A second write of the justification alone
+// has been seen to land (`set_text({justification})` on its own always did), so
+// one re-assert is tried before giving up. If that also disagrees, the caller
+// is told what was expected and what the layer actually shows — a text layer
+// that silently re-centres is the failure this codebase refuses everywhere.
+//
+// `expected` is an enum value: the requested one, or the one read before the
+// mutation. Returns {justification, reasserted}; throws when it cannot deliver.
+function __verifyJustification(src, expected) {
+  var actual = src.value.justification;
+  if (actual === expected) return { justification: actual, reasserted: false };
+  var again = src.value;
+  again.justification = expected;
+  src.setValue(again);
+  actual = src.value.justification;
+  if (actual === expected) return { justification: actual, reasserted: true };
+  throw new Error(
+    "Source Text justification did not land: expected " + __justificationName(expected) +
+    " (" + String(expected) + "), the layer reads " + __justificationName(actual) +
+    " (" + String(actual) + ") after a second write. The other fields were written. " +
+    "Read the layer back with get_layer_full include:[\"text\"] before relying on its alignment."
+  );
+}
+
+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;
+  // Captured before anything is touched: "undefined fields unchanged" is a
+  // claim about this value, and it is what the read-back is checked against
+  // when no justification was asked for.
+  var justificationBefore = td.justification;
+  var justificationWanted = justificationBefore;
+  if (args.justification !== undefined) {
+    if (__JUSTIFICATION[args.justification] === undefined) {
+      throw new Error("Unknown justification '" + String(args.justification) + "'; expected one of left, center, right, full. Nothing was changed.");
+    }
+    justificationWanted = __JUSTIFICATION[args.justification];
+  }
   if (args.text !== undefined) td.text = args.text;
   if (args.font !== undefined) td.font = args.font;
   if (args.size !== undefined) td.fontSize = args.size;
@@ -1198,9 +2344,7 @@ OPS.set_text = function (args) {
   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) {
-    if (__JUSTIFICATION[args.justification]) td.justification = __JUSTIFICATION[args.justification];
-  }
+  if (args.justification !== undefined) td.justification = justificationWanted;
   if (args.applyFill !== undefined) td.applyFill = args.applyFill;
   if (args.applyStroke !== undefined) td.applyStroke = args.applyStroke;
   if (args.fauxBold !== undefined) td.fauxBold = args.fauxBold;
@@ -1209,7 +2353,12 @@ OPS.set_text = function (args) {
   if (args.smallCaps !== undefined) td.smallCaps = args.smallCaps;
   if (args.baselineShift !== undefined) td.baselineShift = args.baselineShift;
   src.setValue(td);
-  return { ok: true };
+  var verified = __verifyJustification(src, justificationWanted);
+  return {
+    ok: true,
+    justification: __justificationName(verified.justification),
+    justificationReasserted: verified.reasserted,
+  };
 };
 
 OPS.add_text_animator = function (args) {
@@ -1600,10 +2749,26 @@ var __SCREENSHOT_TARGET_PX = 1280;
 // The correct downsample was always derivable from the comp, and an agent that
 // forgot it got a full-resolution 4K frame — the most expensive accident
 // available through these tools. So derive it, and let an explicit value win.
+function __autoDownsampleFor(comp, targetPx) {
+  var longEdge = comp.width > comp.height ? comp.width : comp.height;
+  var n = Math.ceil(longEdge / targetPx);
+  if (!(n > 1)) return 1;
+  return n > 8 ? 8 : n;
+}
+
 // 1080p -> 2 (960px), 4K -> 3 (1280px), and anything already small -> 1.
 function __autoDownsample(comp) {
-  var longEdge = comp.width > comp.height ? comp.width : comp.height;
-  var n = Math.ceil(longEdge / __SCREENSHOT_TARGET_PX);
+  return __autoDownsampleFor(comp, __SCREENSHOT_TARGET_PX);
+}
+
+// A contact sheet of N frames has to cost about what one frame costs, so each
+// tile gets 1/sqrt(N) of the single-frame long edge — N tiles of 1/N the area
+// each. Expressed as a multiple of what this comp's *single* frame would have
+// used rather than as its own target, for two reasons: it cannot drift from
+// __autoDownsample, and the factor is an integer, so deriving from the target
+// instead would let the rounding leave a 1080p sheet at nearly twice the budget.
+function __tileDownsample(comp, count) {
+  var n = Math.ceil(__autoDownsample(comp) * Math.sqrt(count));
   if (!(n > 1)) return 1;
   return n > 8 ? 8 : n;
 }
@@ -1617,24 +2782,68 @@ function __resolveDownsample(comp, requested) {
 // reduced frame directly instead of writing full size and resampling
 // 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.
 function __saveFrameAt(comp, time, file, factor) {
-  if (factor <= 1) {
-    comp.saveFrameToPng(time, file);
-    return;
-  }
+  var f = (factor > 1) ? Math.round(factor) : 1;
   var previous = comp.resolutionFactor;
   try {
-    comp.resolutionFactor = [factor, factor];
+    comp.resolutionFactor = [f, f];
     comp.saveFrameToPng(time, file);
   } finally {
     // Restore unconditionally — a failed render must never leave the user
-    // looking at a half-resolution comp.
+    // looking at a half-resolution comp. This covers factor 1 too: the render
+    // happens at Full and the viewer goes back to Quarter afterwards.
     comp.resolutionFactor = previous;
   }
 }
 
+// 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
+// asked for. Dropping a failed tile would silently renumber the rest, which is
+// the same class of lie as swallowing an error.
+function __contactSheetFrames(comp, args) {
+  var times = args.times;
+  var ds;
+  if (args.downsample === undefined || args.downsample === null) {
+    ds = __tileDownsample(comp, times.length);
+  } else {
+    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);
+    }
+    tiles.push(entry);
+  }
+  return {
+    contactSheet: true,
+    tiles: tiles,
+    downsample: ds,
+    width: comp.width, height: comp.height,
+    times: times, compId: comp.id
+  };
+}
+
 OPS.screenshot_frame = noUndo(function (args) {
   var c = getCompById(args.compId);
+  if (args.times && args.times.length) return __contactSheetFrames(c, args);
   var t = (args.time !== undefined && args.time !== null) ? args.time : c.time;
   var ds = __resolveDownsample(c, args.downsample);
   var path = __tmpPngPath();
@@ -1789,22 +2998,53 @@ function __brokenSvgAdvice() {
   );
 }
 
-OPS.import_footage = function (args) {
-  var path = args && args.path;
-  if (typeof path !== "string" || path.length === 0) throw new Error("path is required");
-
-  var file = new File(path);
-  if (!file.exists) throw new Error("No file at " + path);
-
+/**
+ * The bare import — ImportOptions, importFile, and the two ways AE can decline.
+ * Kept as its own function because it is the only import in the codebase and
+ * anything else that needs a file in the project (audio.jsx) must go through
+ * exactly this, not a second copy that drifts.
+ */
+function __importFile(file, path, sequence) {
   var opts = new ImportOptions(file);
-  if (args.sequence === true) {
+  if (sequence === true) {
     if (!opts.canImportAs(ImportAsType.FOOTAGE)) throw new Error("Cannot import " + path + " as footage, so it cannot be a sequence either");
     opts.importAs = ImportAsType.FOOTAGE;
     opts.sequence = true;
   }
-
   var item = app.project.importFile(opts);
   if (!item) throw new Error("After Effects returned no item for " + path);
+  return item;
+}
+
+/**
+ * fsName -> project item, for every item in the project that came from a file.
+ * One pass: the caller with N paths to resolve would otherwise walk the project
+ * N times, and a project with a few hundred items makes that visible.
+ */
+function __itemPathMap() {
+  var map = {};
+  var proj = app.project;
+  for (var i = 1; i <= proj.numItems; i++) {
+    var it = proj.item(i);
+    var key = null;
+    try {
+      if (it.mainSource && it.mainSource.file) key = String(it.mainSource.file.fsName);
+    } catch (e) {}
+    // First one wins: two items on the same file are a duplicate import, and
+    // reusing the earlier is what the user would have done by hand.
+    if (key && !map.hasOwnProperty(key)) map[key] = it;
+  }
+  return map;
+}
+
+OPS.import_footage = function (args) {
+  var path = args && args.path;
+  if (typeof path !== "string" || path.length === 0) throw new Error("path is required");
+
+  var file = new File(path);
+  if (!file.exists) throw new Error("No file at " + path);
+
+  var item = __importFile(file, path, args.sequence);
 
   if (typeof args.name === "string" && args.name.length > 0) item.name = args.name;
 
@@ -1843,29 +3083,985 @@ OPS.import_footage = function (args) {
   );
 };
 
-OPS.create_footage_layer = function (args) {
-  var comp = getCompById(args.compId);
-  var item = app.project.itemByID(args.itemId);
-  if (!item) throw new Error("No project item with id " + args.itemId);
-  if (item instanceof FolderItem) throw new Error("Item " + args.itemId + " (\"" + item.name + "\") is a folder, not footage");
+OPS.create_footage_layer = function (args) {
+  var comp = getCompById(args.compId);
+  var item = app.project.itemByID(args.itemId);
+  if (!item) throw new Error("No project item with id " + args.itemId);
+  if (item instanceof FolderItem) throw new Error("Item " + args.itemId + " (\"" + item.name + "\") is a folder, not footage");
+
+  var layer = comp.layers.add(item);
+  if (typeof args.name === "string" && args.name.length > 0) layer.name = args.name;
+  if (args.position !== undefined && args.position !== null) {
+    layer.property("Transform").property("Position").setValue(args.position);
+  }
+  if (args.startTime !== undefined && args.startTime !== null) layer.startTime = args.startTime;
+
+  return {
+    layerId: layer.id,
+    index: layer.index,
+    name: layer.name,
+    compId: comp.id,
+    itemId: item.id,
+    inPoint: layer.inPoint,
+    outPoint: layer.outPoint
+  };
+};
+
+// ---------------------------------------------------------------------------
+// Unused footage, and the solids delete_comp leaves behind (issue #83)
+// ---------------------------------------------------------------------------
+// A solid layer's source is a FootageItem in the project's Solids folder, not
+// something the comp owns. Deleting the comp (or the layer) deletes the layer
+// and leaves the item: nothing in AE's DOM ties the two lifetimes together and
+// nothing warns, so a session that builds and discards comps grows the project
+// bin without bound — a verification pass had to sweep 1,863 of them out by
+// name. Once orphaned they are indistinguishable from solids still in use
+// unless something reads `usedIn`, which is what everything below does.
+//
+// Two ops share these helpers. `delete_comp` (comps.jsx) can purge the solids
+// the deleted comp referenced — only those, and only the ones nothing else
+// still uses — and `purge_unused_footage` is the project-wide sweep: AE's own
+// Remove Unused Footage, with a dryRun and a report of what went.
+
+/** The item behind a solid or adjustment layer: a FootageItem whose source is a SolidSource. */
+function __isSolidItem(it) {
+  if (!(it instanceof FootageItem)) return false;
+  var src = null;
+  try { src = it.mainSource; } catch (e) { return false; }
+  if (!src) return false;
+  return (src instanceof SolidSource);
+}
+
+/** "solid" | "placeholder" | "footage". Only ever called on a FootageItem — a comp or folder is never footage. */
+function __footageKind(it) {
+  if (__isSolidItem(it)) return "solid";
+  try {
+    if (typeof PlaceholderSource !== "undefined" && it.mainSource instanceof PlaceholderSource) return "placeholder";
+  } catch (e) {}
+  return "footage";
+}
+
+/**
+ * The comps an item is placed in, as {id, name}. Read from After Effects on
+ * every call rather than inferred from anything this bundle remembers — the
+ * whole safety of a purge is that the answer is AE's, at the moment of asking.
+ */
+function __usedInList(it) {
+  var out = [];
+  var comps = null;
+  try { comps = it.usedIn; } catch (e) { comps = null; }
+  if (!comps) return out;
+  for (var i = 0; i < comps.length; i++) {
+    var c = comps[i];
+    if (!c) continue;
+    out.push({ id: c.id, name: c.name });
+  }
+  return out;
+}
+
+/** True when `it` sits in `folder` or in any folder nested under it. */
+function __isInFolder(it, folder) {
+  var cur = null;
+  try { cur = it.parentFolder; } catch (e) { return false; }
+  for (var depth = 0; cur && depth < 64; depth++) {
+    if (cur.id === folder.id) return true;
+    var next = null;
+    try { next = cur.parentFolder; } catch (e2) { next = null; }
+    cur = next;
+  }
+  return false;
+}
+
+/** The distinct solid items this comp's own layers point at, as {id, name}. Nothing from any other comp. */
+function __solidItemsOf(comp) {
+  var out = [];
+  var seen = {};
+  for (var i = 1; i <= comp.numLayers; i++) {
+    var l = comp.layer(i);
+    if (!(l instanceof AVLayer)) continue;
+    var src = null;
+    try { src = l.source; } catch (e) { continue; }
+    if (!src || !__isSolidItem(src)) continue;
+    var key = "I" + src.id;
+    if (seen.hasOwnProperty(key)) continue;
+    seen[key] = true;
+    out.push({ id: src.id, name: src.name });
+  }
+  return out;
+}
+
+function __itemReport(entry) {
+  var r = { id: entry.id, name: entry.name, kind: entry.kind };
+  if (entry.footageMissing) r.footageMissing = true;
+  return r;
+}
+
+function __nameList(reports, cap) {
+  var names = [];
+  for (var i = 0; i < reports.length && i < cap; i++) names.push("\"" + reports[i].name + "\" (id " + reports[i].id + ")");
+  var s = names.join(", ");
+  if (reports.length > cap) s += " and " + (reports.length - cap) + " more";
+  return s;
+}
+
+/**
+ * Remove a list of project items. Entries are {item, id, name, kind, index?}.
+ *
+ * Highest project index first when indices are known, so no removal shifts an
+ * item still to be visited — the entries were collected in one pass over
+ * app.project.item(i) and removed in a second, never removed mid-walk. It stops
+ * at the first failure: nothing rolls back, so the caller is handed what went
+ * before the failure and what was never attempted, and reports that, rather
+ * than a sweep that claims to have finished.
+ */
+function __removeItems(entries) {
+  var ordered = entries.slice(0);
+  ordered.sort(function (a, b) { return (b.index || 0) - (a.index || 0); });
+  var removed = [];
+  for (var i = 0; i < ordered.length; i++) {
+    var entry = ordered[i];
+    try {
+      entry.item.remove();
+    } catch (e) {
+      var pending = [];
+      for (var j = i + 1; j < ordered.length; j++) pending.push(__itemReport(ordered[j]));
+      return {
+        removed: removed,
+        failed: __itemReport(entry),
+        error: (e && e.message) ? String(e.message) : String(e),
+        notAttempted: pending
+      };
+    }
+    removed.push(__itemReport(entry));
+  }
+  return { removed: removed, failed: null, error: null, notAttempted: [] };
+}
+
+OPS.purge_unused_footage = noUndoWhen(
+  // A dry run is not an undo step. A sweep that changed nothing appearing in
+  // the user's undo history would make "this changed nothing" false in the one
+  // place they can see it — the same stance place_audio_cues takes.
+  function (args) { return !!(args && args.dryRun === true); },
+  function (args) {
+    args = args || {};
+    var solidsOnly = (args.solidsOnly !== false);
+    var dryRun = (args.dryRun === true);
+    var folder = null;
+    if (args.folderId !== undefined && args.folderId !== null) folder = __folderArg(args.folderId);
+    var what = "footage item";
+    if (solidsOnly) what = "solid";
+
+    // One pass to decide, a second to remove. Removing inside the walk would
+    // shift every index above the removed item under the loop's feet.
+    var candidates = [];
+    var scanned = 0;
+    var inUse = 0;
+    var proj = app.project;
+    for (var i = 1; i <= proj.numItems; i++) {
+      var it = proj.item(i);
+      // A comp is an AVItem with a usedIn of its own, and a nested comp nothing
+      // uses any more is exactly what a naive sweep would delete. Only footage.
+      if (!(it instanceof FootageItem)) continue;
+      if (solidsOnly && !__isSolidItem(it)) continue;
+      if (folder && !__isInFolder(it, folder)) continue;
+      scanned += 1;
+      if (__usedInList(it).length > 0) { inUse += 1; continue; }
+      var missing = false;
+      try { missing = !!it.footageMissing; } catch (eMissing) {}
+      candidates.push({ item: it, id: it.id, name: it.name, kind: __footageKind(it), index: i, footageMissing: missing });
+    }
+    // Sorted here, once, so a dry run lists items in exactly the order a real
+    // run removes them — the plan has to be the truth about order too.
+    candidates.sort(function (a, b) { return b.index - a.index; });
+
+    var out = { solidsOnly: solidsOnly, scanned: scanned, inUse: inUse };
+    var where = "in the project";
+    if (folder) {
+      out.folderId = folder.id;
+      out.folderName = folder.name;
+      where = "in folder \"" + folder.name + "\"";
+    }
+    var nothingWhy = "every " + what + " " + where + " is still used in a comp";
+    if (scanned === 0) nothingWhy = "no " + what + "s " + where;
+
+    if (dryRun) {
+      var would = [];
+      for (var w = 0; w < candidates.length; w++) would.push(__itemReport(candidates[w]));
+      out.dryRun = true;
+      out.wouldRemove = would;
+      out.wouldRemoveCount = would.length;
+      if (would.length === 0) {
+        out.note = "Nothing to remove: " + nothingWhy + ". Nothing was changed and this call is not an undo step.";
+      } else {
+        out.note = "Nothing was removed and this call is not an undo step. Call again without dryRun to remove these " +
+          would.length + " " + what + (would.length === 1 ? "" : "s") + " " + where + ".";
+      }
+      return out;
+    }
+
+    var r = __removeItems(candidates);
+    out.removed = r.removed;
+    out.removedCount = r.removed.length;
+    if (r.failed) {
+      var msg = "purge_unused_footage stopped at \"" + r.failed.name + "\" (id " + r.failed.id + ", " + r.failed.kind + "): " + r.error + ".";
+      if (r.removed.length > 0) {
+        msg += " " + r.removed.length + " item(s) were removed before it: " + __nameList(r.removed, 20) + ".";
+      } else {
+        msg += " Nothing had been removed yet.";
+      }
+      msg += " " + r.notAttempted.length + " unused item(s) were not attempted." +
+        " Nothing rolls back; one Undo in After Effects restores what this call removed. Run again, or with dryRun:true, to see what is left.";
+      throw new Error(msg);
+    }
+    if (r.removed.length === 0) {
+      out.note = "Nothing to remove: " + nothingWhy + ".";
+    } else {
+      out.note = "Removed " + r.removed.length + " unused " + what + (r.removed.length === 1 ? "" : "s") + " " + where + ", as one undo step.";
+    }
+    return out;
+  }
+);
+
+
+// ===== audio.jsx =====
+
+// audio.jsx — place a list of sound effects into a comp in one pass.
+//
+// Scoring a scene is 40-90 layers: import or reuse the file, add a layer, set
+// its start time, set its level in dB, name it, sometimes trim it. Done through
+// the general tools that is dozens of round trips; done through run_jsx it is a
+// hand-written loop that has to know the one thing nothing tells you —
+// `layer.property("ADBE Audio Levels")` returns **null** on an audio layer,
+// because Audio Levels lives under the layer's "Audio" group and the only
+// reliable handle is the `layer.audioLevels` shortcut (issue #48).
+//
+// Two properties carry the design:
+//
+//   - Nothing is created until every cue has been checked. A run that dies on
+//     cue 30 of 90 leaves 29 sound effects in someone's timeline and an error
+//     that does not say which ones — the same half-built failure
+//     add_shape_content refuses to produce. So: plan first with no side
+//     effects, throw naming the offending cue indices, and if a creation still
+//     fails, remove everything this call made before rethrowing.
+//   - A file named by several cues is imported once. Repeated imports of one
+//     .wav are the normal shape of a cue list ("whoosh" nine times), and each
+//     one would otherwise add another project item. Anything already in the
+//     project from that path is reused rather than imported a second time.
+//
+// Three per-cue options (issue #85) — `loop`, `fadeIn`/`fadeOut`, `stretch` —
+// are the patterns every scoring pass used to re-implement in a run_jsx
+// follow-up. Each one moves something After Effects then quietly resets, so
+// the order inside __placeAudioCue is load-bearing; see the comment there.
+
+var __MAX_AUDIO_CUES = 200;
+var __CUE_TIME_EPS = 1e-6;
+
+// The level a fade starts from and ends at when the caller gives none. -48 dB
+// is the bottom of the range After Effects' own Audio Levels slider offers, and
+// 1/256 of the recorded amplitude — near-silence for a fade to begin from while
+// staying inside the range a user can drag the property through by hand.
+var __DEFAULT_FADE_FLOOR_DB = -48;
+
+// AE's layer label colours. Users can rename them in preferences, but the tool
+// takes an index and the indices do not move, so the names are accepted as a
+// convenience and translated here. 0 is "None".
+var __LABEL_NAMES = {
+  none: 0, red: 1, yellow: 2, aqua: 3, pink: 4, lavender: 5, peach: 6,
+  seafoam: 7, blue: 8, green: 9, purple: 10, orange: 11, brown: 12,
+  fuchsia: 13, cyan: 14, sandstone: 15, darkgreen: 16
+};
+
+function __labelKey(s) {
+  return String(s).toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+function __labelNameList() {
+  var names = [];
+  for (var k in __LABEL_NAMES) {
+    if (__LABEL_NAMES.hasOwnProperty(k)) names.push(k);
+  }
+  return names.join(", ");
+}
+
+/** 0..16, or a thrown error naming everything it would have taken. */
+function __resolveLabel(label) {
+  if (typeof label === "number") {
+    if (label !== Math.floor(label) || label < 0 || label > 16) {
+      throw new Error("label must be a whole number 0-16 or a colour name (" + __labelNameList() + "); got " + label);
+    }
+    return label;
+  }
+  var key = __labelKey(label);
+  if (__LABEL_NAMES.hasOwnProperty(key)) return __LABEL_NAMES[key];
+  throw new Error("unknown label \"" + label + "\" — use 0-16 or one of: " + __labelNameList());
+}
+
+function __basename(p) {
+  var s = String(p).replace(/\\/g, "/");
+  var slash = s.lastIndexOf("/");
+  if (slash >= 0) s = s.substring(slash + 1);
+  return s;
+}
+
+function __stripExtension(name) {
+  var s = String(name);
+  var dot = s.lastIndexOf(".");
+  if (dot > 0) return s.substring(0, dot);
+  return s;
+}
+
+function __isFiniteNumber(v) {
+  return typeof v === "number" && isFinite(v);
+}
+
+/**
+ * The Audio Levels property of a layer.
+ *
+ * `layer.audioLevels` is the shortcut that works. `layer.property("ADBE Audio
+ * Levels")` returns null on an audio layer — the property sits inside the
+ * layer's "Audio" group, not on the layer — and a null there is what silently
+ * turns a scripted level into no level at all. The group walk is only a
+ * fallback for a layer whose shortcut is somehow absent; if neither answers,
+ * the caller is told rather than left with an unset level.
+ */
+function __audioLevelsProperty(layer) {
+  var p = null;
+  try { p = layer.audioLevels; } catch (e) {}
+  if (p) return p;
+  try {
+    var g = layer.property("Audio");
+    if (g) p = g.property("Audio Levels");
+  } catch (e2) {}
+  return p;
+}
+
+/**
+ * The Time Remap property of a layer that has remapping enabled. Same shape of
+ * trap as Audio Levels: `layer.property("ADBE Time Remap")` is null on an
+ * audio layer even after `timeRemapEnabled = true`, and the shortcut
+ * `layer.timeRemap` is the handle that answers. The match-name lookup is kept
+ * only as a fallback; a null from both is reported, never worked around.
+ */
+function __timeRemapProperty(layer) {
+  var p = null;
+  try { p = layer.timeRemap; } catch (e) {}
+  if (p) return p;
+  try { p = layer.property("ADBE Time Remapping"); } catch (e2) {}
+  return p;
+}
+
+/** null when the item can carry an audio cue, else the reason it cannot. */
+function __audioItemProblem(item) {
+  if (item instanceof FolderItem) return "\"" + item.name + "\" is a folder, not footage";
+  if (item instanceof CompItem) return "\"" + item.name + "\" is a comp — use create_precomp_layer for that";
+  if (item.footageMissing) return "\"" + item.name + "\" is offline; the file it points at is missing";
+  // Explicitly `=== false`, not `!item.hasAudio`: an item that does not report
+  // the flag at all must not be refused on the strength of a missing property.
+  if (item.hasAudio === false) return "\"" + item.name + "\" has no audio track";
+  return null;
+}
+
+function __sourceReport(item, path) {
+  return { itemId: item.id, name: item.name, path: path };
+}
+
+/** The duration of a project item, or null when it does not say. */
+function __itemDuration(item) {
+  if (!item) return null;
+  var d = null;
+  try { d = item.duration; } catch (e) {}
+  if (__isFiniteNumber(d)) return d;
+  return null;
+}
+
+/**
+ * Where a planned cue's layer will start and end, in comp time, given what is
+ * known about its source. `end` is null when it cannot be known yet — an
+ * unlooped cue on a file that has not been imported, with no outPoint to cap
+ * it — and the caller decides what to do with that.
+ */
+function __cueExtent(p, itemDuration) {
+  var start = p.time;
+  if (p.inPoint !== null) start = p.inPoint;
+  var end = null;
+  if (p.loop) {
+    // A loop has no natural end, so its end is the one the caller gave or the
+    // comp's, whichever the planner settled on.
+    end = p.loopEnd;
+  } else {
+    var natural = null;
+    if (__isFiniteNumber(itemDuration)) natural = p.time + itemDuration * p.stretchFactor;
+    end = p.outPoint;
+    // AE clamps an out point to what the source can supply, so a requested
+    // outPoint past the file's end is not where the layer will end.
+    if (end === null || (natural !== null && natural < end)) end = natural;
+  }
+  return { start: start, end: end };
+}
+
+function __fmtSeconds(n) {
+  // Rounded for prose only; nothing downstream reads these numbers back.
+  return String(Math.round(n * 1000) / 1000) + "s";
+}
+
+/**
+ * null when the cue's fades fit inside its extent; a reason string when they
+ * do not; and the string "unknown" when the extent cannot be computed yet.
+ * Pure — used at plan time and again after the imports, on the same plan.
+ */
+function __fadeFitProblem(p, extent) {
+  var total = p.fadeIn + p.fadeOut;
+  if (total <= 0 && !p.loop) return null;
+  if (extent.end === null) {
+    if (total <= 0) return null;
+    return "unknown";
+  }
+  var dur = extent.end - extent.start;
+  var span = " (from " + __fmtSeconds(extent.start) + " to " + __fmtSeconds(extent.end) + ")";
+  if (dur <= __CUE_TIME_EPS) {
+    if (p.loop) {
+      var why = "the comp's end, since no outPoint was given";
+      if (p.outPoint !== null) why = "its outPoint";
+      return "inPoint " + __fmtSeconds(extent.start) + " is not before the end of the loop at " + __fmtSeconds(extent.end) + " (" + why + ")";
+    }
+    return "inPoint " + __fmtSeconds(extent.start) + " is past where the cue ends" + span;
+  }
+  if (total <= 0) return null;
+  if (total > dur + __CUE_TIME_EPS) {
+    var what;
+    if (p.fadeIn > 0 && p.fadeOut > 0) {
+      what = "fadeIn " + __fmtSeconds(p.fadeIn) + " + fadeOut " + __fmtSeconds(p.fadeOut) + " = " + __fmtSeconds(total);
+    } else if (p.fadeIn > 0) {
+      what = "fadeIn " + __fmtSeconds(p.fadeIn);
+    } else {
+      what = "fadeOut " + __fmtSeconds(p.fadeOut);
+    }
+    var tail = "";
+    if (!p.loop && p.outPoint === null) tail = " — the file's own length, with no outPoint to extend it and no loop";
+    return what + " is longer than the cue, which runs " + __fmtSeconds(dur) + span + tail;
+  }
+  return null;
+}
+
+/**
+ * Turn the cue list into a plan, touching nothing. Every problem found is
+ * collected with the index of the cue that caused it rather than thrown on the
+ * spot, so one call reports all of them instead of one per round trip.
+ */
+function __planAudioCues(comp, args) {
+  var cues = args.cues;
+  if (!(cues instanceof Array) || cues.length === 0) {
+    throw new Error("place_audio_cues needs a non-empty `cues` array.");
+  }
+  if (cues.length > __MAX_AUDIO_CUES) {
+    throw new Error(
+      "place_audio_cues was given " + cues.length + " cues and the limit is " + __MAX_AUDIO_CUES + " per call. " +
+      "ExtendScript is single-threaded, so one long run freezes After Effects' interface for its whole duration. " +
+      "Split the list into calls of " + __MAX_AUDIO_CUES + " or fewer."
+    );
+  }
+
+  var prefix = "SFX_";
+  if (typeof args.namePrefix === "string") prefix = args.namePrefix;
+
+  // One floor for the whole list: it is a property of the mix, not of a cue.
+  var floorDb = __DEFAULT_FADE_FLOOR_DB;
+  if (args.fadeFloorDb !== undefined && args.fadeFloorDb !== null) {
+    if (!__isFiniteNumber(args.fadeFloorDb)) {
+      throw new Error("fadeFloorDb must be a number of decibels (the default is " + __DEFAULT_FADE_FLOOR_DB + "); got " + String(args.fadeFloorDb));
+    }
+    floorDb = args.fadeFloorDb;
+  }
+
+  var byPath = __itemPathMap();
+  var problems = [];
+  var planned = [];
+  var toImport = [];
+  var toImportSeen = {};
+
+  for (var i = 0; i < cues.length; i++) {
+    var cue = cues[i];
+    if (!cue) { problems.push({ cue: i, reason: "is empty" }); continue; }
+
+    var hasId = (cue.footageId !== undefined && cue.footageId !== null);
+    var hasPath = (typeof cue.path === "string" && cue.path.length > 0);
+    if (hasId && hasPath) { problems.push({ cue: i, reason: "has both footageId and path — give exactly one" }); continue; }
+    if (!hasId && !hasPath) { problems.push({ cue: i, reason: "has neither footageId nor path — give exactly one" }); continue; }
+
+    var time = cue.time;
+    if (!__isFiniteNumber(time)) {
+      problems.push({ cue: i, reason: "time must be a number of seconds; got " + String(time) });
+      continue;
+    }
+    if (time < -__CUE_TIME_EPS || time > comp.duration + __CUE_TIME_EPS) {
+      problems.push({ cue: i, reason: "time " + time + "s is outside the comp, which runs 0 to " + comp.duration + "s" });
+      continue;
+    }
+
+    var levelDb = 0;
+    if (cue.levelDb !== undefined && cue.levelDb !== null) {
+      if (!__isFiniteNumber(cue.levelDb)) {
+        problems.push({ cue: i, reason: "levelDb must be a number of decibels (0 is unedited); got " + String(cue.levelDb) });
+        continue;
+      }
+      levelDb = cue.levelDb;
+    }
+
+    var inPoint = null;
+    var outPoint = null;
+    var trimBad = false;
+    if (cue.inPoint !== undefined && cue.inPoint !== null) {
+      if (!__isFiniteNumber(cue.inPoint)) {
+        problems.push({ cue: i, reason: "inPoint must be a comp time in seconds; got " + String(cue.inPoint) });
+        trimBad = true;
+      } else {
+        inPoint = cue.inPoint;
+      }
+    }
+    if (!trimBad && cue.outPoint !== undefined && cue.outPoint !== null) {
+      if (!__isFiniteNumber(cue.outPoint)) {
+        problems.push({ cue: i, reason: "outPoint must be a comp time in seconds; got " + String(cue.outPoint) });
+        trimBad = true;
+      } else {
+        outPoint = cue.outPoint;
+      }
+    }
+    if (trimBad) continue;
+    // in/out are absolute comp times, like everywhere else in these tools, so
+    // they are measured against `time` rather than against the file.
+    if (inPoint !== null && inPoint < time - __CUE_TIME_EPS) {
+      problems.push({ cue: i, reason: "inPoint " + inPoint + "s is before the cue's own time " + time + "s; both are comp times" });
+      continue;
+    }
+    var trimStart = time;
+    if (inPoint !== null) trimStart = inPoint;
+    if (outPoint !== null && outPoint <= trimStart + __CUE_TIME_EPS) {
+      problems.push({ cue: i, reason: "outPoint " + outPoint + "s is not after the cue starts at " + trimStart + "s" });
+      continue;
+    }
+
+    var label = null;
+    if (cue.label !== undefined && cue.label !== null) {
+      try {
+        label = __resolveLabel(cue.label);
+      } catch (eLabel) {
+        problems.push({ cue: i, reason: eLabel.message });
+        continue;
+      }
+    }
+
+    // The #85 options. Type-checked here, before the source is resolved, so a
+    // cue with a bad stretch AND a missing file reports the first of the two
+    // it hits — every cue still gets a line, which is what matters.
+    var loop = false;
+    if (cue.loop !== undefined && cue.loop !== null) {
+      if (cue.loop !== true && cue.loop !== false) {
+        problems.push({ cue: i, reason: "loop must be true or false; got " + String(cue.loop) });
+        continue;
+      }
+      loop = cue.loop;
+    }
+    var stretch = null;
+    if (cue.stretch !== undefined && cue.stretch !== null) {
+      if (!__isFiniteNumber(cue.stretch) || cue.stretch <= 0) {
+        problems.push({ cue: i, reason: "stretch must be a percentage greater than 0 (100 is unchanged, 200 is half speed); got " + String(cue.stretch) });
+        continue;
+      }
+      stretch = cue.stretch;
+    }
+    var fadeIn = 0;
+    var fadeOut = 0;
+    var fadeBad = false;
+    if (cue.fadeIn !== undefined && cue.fadeIn !== null) {
+      if (!__isFiniteNumber(cue.fadeIn) || cue.fadeIn < 0) {
+        problems.push({ cue: i, reason: "fadeIn must be a number of seconds, 0 or more; got " + String(cue.fadeIn) });
+        fadeBad = true;
+      } else {
+        fadeIn = cue.fadeIn;
+      }
+    }
+    if (!fadeBad && cue.fadeOut !== undefined && cue.fadeOut !== null) {
+      if (!__isFiniteNumber(cue.fadeOut) || cue.fadeOut < 0) {
+        problems.push({ cue: i, reason: "fadeOut must be a number of seconds, 0 or more; got " + String(cue.fadeOut) });
+        fadeBad = true;
+      } else {
+        fadeOut = cue.fadeOut;
+      }
+    }
+    if (fadeBad) continue;
+    if ((fadeIn > 0 || fadeOut > 0) && floorDb >= levelDb) {
+      problems.push({
+        cue: i,
+        reason: "fadeFloorDb " + floorDb + " is not below the cue's level " + levelDb + " dB, so its fade would go nowhere — lower the floor or raise the level"
+      });
+      continue;
+    }
+
+    // Resolve the source. A footageId names an item that must already be
+    // usable; a path is either something the project already holds or an
+    // import this call will do exactly once.
+    var source = null;
+    var defaultName = null;
+    if (hasId) {
+      var item = app.project.itemByID(cue.footageId);
+      if (!item) { problems.push({ cue: i, reason: "no project item with id " + cue.footageId }); continue; }
+      var why = __audioItemProblem(item);
+      if (why) { problems.push({ cue: i, reason: why }); continue; }
+      source = { kind: "item", item: item, fsName: null, path: null };
+      defaultName = item.name;
+    } else {
+      var file = new File(cue.path);
+      if (!file.exists) { problems.push({ cue: i, reason: "no file at " + cue.path }); continue; }
+      var fsName = String(file.fsName);
+      var existing = null;
+      if (byPath.hasOwnProperty(fsName)) existing = byPath[fsName];
+      if (existing) {
+        var whyExisting = __audioItemProblem(existing);
+        if (whyExisting) { problems.push({ cue: i, reason: whyExisting + " (already in the project from " + cue.path + ")" }); continue; }
+        source = { kind: "reused", item: existing, fsName: fsName, path: cue.path };
+      } else {
+        if (!toImportSeen.hasOwnProperty(fsName)) {
+          toImportSeen[fsName] = true;
+          toImport.push({ fsName: fsName, path: cue.path, file: file });
+        }
+        source = { kind: "import", item: null, fsName: fsName, path: cue.path };
+      }
+      // The caller named a path, so the path's basename is the honest default
+      // even when the project item it resolves to was renamed by hand.
+      defaultName = __basename(cue.path);
+    }
+
+    var name = prefix + __stripExtension(defaultName);
+    if (typeof cue.name === "string" && cue.name.length > 0) name = cue.name;
+
+    var stretchFactor = 1;
+    if (stretch !== null) stretchFactor = stretch / 100;
+    // A looped cue needs an end, because a loop has none of its own.
+    var loopEnd = null;
+    if (loop) {
+      loopEnd = comp.duration;
+      if (outPoint !== null) loopEnd = outPoint;
+    }
+
+    var p = {
+      index: i, name: name, time: time, levelDb: levelDb,
+      inPoint: inPoint, outPoint: outPoint, label: label, source: source,
+      loop: loop, loopEnd: loopEnd, stretch: stretch, stretchFactor: stretchFactor,
+      fadeIn: fadeIn, fadeOut: fadeOut,
+      // true when the fade could not be measured against the file yet
+      fadeUnchecked: false
+    };
+
+    // Does the cue fit? Known now for a loop (its end is chosen here), for a
+    // footageId or reused item (After Effects reports its duration) and for a
+    // capped outPoint; not yet for an unlooped cue on a file still to import.
+    var fit = __fadeFitProblem(p, __cueExtent(p, __itemDuration(source.item)));
+    if (fit === "unknown") {
+      p.fadeUnchecked = true;
+    } else if (fit !== null) {
+      problems.push({ cue: i, reason: fit });
+      continue;
+    }
+
+    planned.push(p);
+  }
+
+  return { prefix: prefix, planned: planned, problems: problems, toImport: toImport, floorDb: floorDb };
+}
+
+function __audioProblemLines(problems) {
+  var lines = [];
+  for (var i = 0; i < problems.length; i++) {
+    lines.push("cue " + problems[i].cue + ": " + problems[i].reason);
+  }
+  return lines.join("; ");
+}
+
+function __audioProblemMessage(problems, total) {
+  return (
+    "place_audio_cues placed nothing — " + problems.length + " of " + total + " cues cannot be placed. " +
+    __audioProblemLines(problems) + ". Every cue is checked before anything is created, so the comp and project are " +
+    "untouched. Fix these and call again; dryRun:true checks a list without placing it."
+  );
+}
+
+/**
+ * Counts and the two lists a caller cannot work out alone — what would be
+ * imported and what is already there — plus the failing cues. Never the
+ * resolved list: a 7-cue "all fine" used to cost ~1.5k tokens of echo (#88).
+ */
+function __audioDryRunReport(comp, plan, total) {
+  var wouldImport = [];
+  for (var j = 0; j < plan.toImport.length; j++) wouldImport.push(plan.toImport[j].path);
+
+  var wouldReuse = [];
+  var reuseSeen = {};
+  var looped = 0;
+  var faded = 0;
+  var stretched = 0;
+  var fadesUnchecked = 0;
+  for (var i = 0; i < plan.planned.length; i++) {
+    var p = plan.planned[i];
+    if (p.source.item && !reuseSeen.hasOwnProperty(String(p.source.item.id))) {
+      reuseSeen[String(p.source.item.id)] = true;
+      var r = { itemId: p.source.item.id, name: p.source.item.name };
+      if (p.source.path) r.path = p.source.path;
+      wouldReuse.push(r);
+    }
+    if (p.loop) looped++;
+    if (p.fadeIn > 0 || p.fadeOut > 0) faded++;
+    if (p.stretch !== null) stretched++;
+    if (p.fadeUnchecked) fadesUnchecked++;
+  }
+
+  var out = {
+    dryRun: true,
+    ok: plan.problems.length === 0,
+    compId: comp.id,
+    compName: comp.name,
+    cueCount: total,
+    wouldPlace: plan.planned.length,
+    wouldImport: wouldImport,
+    wouldReuse: wouldReuse,
+    problems: plan.problems,
+    note: "Nothing was imported, created or changed, and this call is not an undo step."
+  };
+  if (looped > 0) out.looped = looped;
+  if (faded > 0) out.faded = faded;
+  if (stretched > 0) out.stretched = stretched;
+  if (wouldImport.length > 0) {
+    var fadeNote = "";
+    if (fadesUnchecked > 0) {
+      fadeNote = " — and, for " + fadesUnchecked + " cue(s) with a fade, whether the fade fits the file's length —";
+    }
+    out.unverified =
+      wouldImport.length + " of these files are not in the project yet. They exist on disk, but whether each " +
+      "carries an audio track" + fadeNote + " is only knowable once After Effects has imported it; a real run checks " +
+      "that and refuses the whole call if one does not.";
+  }
+  return out;
+}
+
+/** Undo everything this call made, newest first. Layers before items: an item still in use cannot go. */
+function __rollbackAudioCues(layers, items) {
+  for (var i = layers.length - 1; i >= 0; i--) {
+    try { layers[i].remove(); } catch (e) {}
+  }
+  for (var j = items.length - 1; j >= 0; j--) {
+    try { items[j].remove(); } catch (e2) {}
+  }
+}
+
+/**
+ * The Time Remap expression that loops a cue. It is the pattern measured in
+ * issue #85 — comp time since the layer began, wrapped at the file's length —
+ * with two substitutions: `startTime` rather than `inPoint`, so trimming the
+ * in point hides the front of the file the way it does on every other layer
+ * instead of delaying it; and the source's duration read live off the layer,
+ * so a relinked file keeps looping. An expression cannot read a layer's
+ * stretch, so a stretched cue has its factor baked in, and that constant goes
+ * stale if the stretch is changed by hand afterwards.
+ */
+function __loopExpression(p) {
+  var elapsed = "(time - startTime)";
+  if (p.stretch !== null && p.stretch !== 100) elapsed = "((time - startTime) * 100 / " + p.stretch + ")";
+  return elapsed + " % thisLayer.source.duration";
+}
+
+/**
+ * `created` is the rollback list, and the layer joins it the instant it exists
+ * rather than once it is fully configured. A cue that dies between add() and
+ * the last setValue is exactly the case rollback is for, and a layer that had
+ * not been registered yet would be the one thing left behind.
+ *
+ * The order after that is not free to change. Each of the #85 options moves
+ * something After Effects then resets: `stretch` moves startTime, so startTime
+ * is set after it; enabling time remap resets the out point, so the extent is
+ * set after that; and the fade keys sit at the in/out the layer actually has,
+ * so they go last. Out point before in point throughout — extending first is
+ * what lets an in point past the file's natural end land on a looped layer.
+ */
+function __placeAudioCue(comp, p, item, created, floorDb) {
+  var layer = comp.layers.add(item);
+  created.push(layer);
+  layer.name = p.name;
+  if (p.stretch !== null) layer.stretch = p.stretch;
+  // startTime first: it slides the whole layer and would drag any trim with it.
+  layer.startTime = p.time;
+  var levels = __audioLevelsProperty(layer);
+  if (!levels) {
+    throw new Error(
+      "the layer created for \"" + item.name + "\" has no Audio Levels property, so its level could not be set"
+    );
+  }
+  if (p.label !== null) layer.label = p.label;
+
+  if (p.loop) {
+    // `=== false`, as with hasAudio: a layer that does not answer the question
+    // is not refused on the strength of a missing property.
+    if (layer.canSetTimeRemapEnabled === false) {
+      throw new Error(
+        "After Effects reports that time remapping cannot be enabled on the layer created for \"" + item.name + "\", so it cannot loop"
+      );
+    }
+    layer.timeRemapEnabled = true;
+    var remap = __timeRemapProperty(layer);
+    if (!remap) {
+      throw new Error(
+        "time remapping was enabled on the layer created for \"" + item.name + "\" but its Time Remap property could not be found, so the loop expression could not be set"
+      );
+    }
+    // The two keyframes AE created when remapping was enabled stay exactly
+    // where they are. Removing them hides the property, and the next write to
+    // it throws (issue #86); the expression overrides them anyway.
+    remap.expression = __loopExpression(p);
+    layer.outPoint = p.loopEnd;
+    if (p.inPoint !== null) layer.inPoint = p.inPoint;
+  } else {
+    if (p.outPoint !== null) layer.outPoint = p.outPoint;
+    if (p.inPoint !== null) layer.inPoint = p.inPoint;
+  }
+
+  // AE's Audio Levels is itself in decibels, one entry per channel.
+  var level = [p.levelDb, p.levelDb];
+  if (p.fadeIn > 0 || p.fadeOut > 0) {
+    var inP = layer.inPoint;
+    var outP = layer.outPoint;
+    var dur = outP - inP;
+    // The planner measured the fade against what it could know; this is the
+    // extent After Effects actually gave the layer, and the last line.
+    if (p.fadeIn + p.fadeOut > dur + __CUE_TIME_EPS) {
+      throw new Error(
+        "its fades (" + __fmtSeconds(p.fadeIn) + " in, " + __fmtSeconds(p.fadeOut) + " out) are longer than the " +
+        __fmtSeconds(dur) + " After Effects gave the layer (" + __fmtSeconds(inP) + " to " + __fmtSeconds(outP) + ")"
+      );
+    }
+    var floor = [floorDb, floorDb];
+    if (p.fadeIn > 0) {
+      levels.setValueAtTime(inP, floor);
+      levels.setValueAtTime(inP + p.fadeIn, level);
+    }
+    if (p.fadeOut > 0) {
+      levels.setValueAtTime(outP - p.fadeOut, level);
+      levels.setValueAtTime(outP, floor);
+    }
+  } else {
+    levels.setValue(level);
+  }
+  return layer;
+}
+
+/**
+ * What the caller gets back per cue: the id it has to carry forward, the name,
+ * the time, and — only where an option could have changed it — what After
+ * Effects actually did. Never an echo of the request.
+ */
+function __placedEntry(layer, p) {
+  var entry = { layerId: layer.id, name: layer.name, time: p.time };
+  // Read the trim back: AE clamps an in/out point to what the source can
+  // actually supply, and the caller should see what it got.
+  if (p.inPoint !== null) entry.inPoint = layer.inPoint;
+  if (p.outPoint !== null || p.loop || p.stretch !== null) entry.outPoint = layer.outPoint;
+  if (p.loop) entry.looped = true;
+  if (p.stretch !== null) entry.stretch = layer.stretch;
+  if (p.fadeIn > 0) entry.fadeIn = p.fadeIn;
+  if (p.fadeOut > 0) entry.fadeOut = p.fadeOut;
+  return entry;
+}
+
+OPS.place_audio_cues = noUndoWhen(
+  // dryRun is not an undo step either. A plan that quietly appeared in the
+  // user's undo history would make "this changed nothing" false in the one
+  // place they can see it.
+  function (args) { return !!(args && args.dryRun === true); },
+  function (args) {
+    var comp = getCompById(args.compId);
+    var total = 0;
+    if (args.cues instanceof Array) total = args.cues.length;
+    var plan = __planAudioCues(comp, args);
+
+    if (args.dryRun === true) return __audioDryRunReport(comp, plan, total);
+    if (plan.problems.length > 0) throw new Error(__audioProblemMessage(plan.problems, total));
+
+    var createdLayers = [];
+    var importedItems = [];
+    var importedReport = [];
+    var reusedReport = [];
+    var reusedSeen = {};
+    var placed = [];
+    var anyFade = false;
+
+    try {
+      // One import per distinct file, before any layer exists, so a bad file
+      // costs nothing but the import itself.
+      var imported = {};
+      for (var i = 0; i < plan.toImport.length; i++) {
+        var spec = plan.toImport[i];
+        var newItem = __importFile(spec.file, spec.path, false);
+        importedItems.push(newItem);
+        var why = __audioItemProblem(newItem);
+        if (why) throw new Error("imported " + spec.path + " and then found that " + why);
+        imported[spec.fsName] = newItem;
+        importedReport.push(__sourceReport(newItem, spec.path));
+      }
+
+      // The fades the planner could not measure — on files it had not seen —
+      // are measured now, with every duration known and no layer yet made, so
+      // a misfit still names every offending cue at once and costs only the
+      // imports, which the rollback takes back.
+      var lateProblems = [];
+      for (var f = 0; f < plan.planned.length; f++) {
+        var pf = plan.planned[f];
+        if (!pf.fadeUnchecked) continue;
+        var fit = __fadeFitProblem(pf, __cueExtent(pf, __itemDuration(imported[pf.source.fsName])));
+        if (fit === "unknown") {
+          fit = "After Effects did not report a duration for the imported " + pf.source.path + ", so its fade cannot be checked";
+        }
+        if (fit !== null) lateProblems.push({ cue: pf.index, reason: fit });
+      }
+      if (lateProblems.length > 0) {
+        throw new Error(
+          "the fades on " + lateProblems.length + " cue(s) do not fit the files once imported — " + __audioProblemLines(lateProblems)
+        );
+      }
+
+      for (var k = 0; k < plan.planned.length; k++) {
+        var p = plan.planned[k];
+        var item = p.source.item;
+        if (!item) item = imported[p.source.fsName];
+        if (p.source.kind !== "import" && !reusedSeen.hasOwnProperty(String(item.id))) {
+          reusedSeen[String(item.id)] = true;
+          reusedReport.push(__sourceReport(item, p.source.path));
+        }
+        var layer;
+        try {
+          layer = __placeAudioCue(comp, p, item, createdLayers, plan.floorDb);
+        } catch (eCue) {
+          throw new Error("cue " + p.index + " (\"" + p.name + "\" at " + p.time + "s): " + eCue.message);
+        }
+        if (p.fadeIn > 0 || p.fadeOut > 0) anyFade = true;
+        placed.push(__placedEntry(layer, p));
+      }
+    } catch (e) {
+      __rollbackAudioCues(createdLayers, importedItems);
+      throw new Error(
+        "place_audio_cues failed on " + ((e && e.message) ? e.message : String(e)) +
+        ". The " + createdLayers.length + " layer(s) and " + importedItems.length +
+        " import(s) it had already made were removed, so the comp and project are as they were."
+      );
+    }
 
-  var layer = comp.layers.add(item);
-  if (typeof args.name === "string" && args.name.length > 0) layer.name = args.name;
-  if (args.position !== undefined && args.position !== null) {
-    layer.property("Transform").property("Position").setValue(args.position);
+    var out = {
+      compId: comp.id,
+      placed: placed,
+      count: placed.length,
+      sources: { imported: importedReport, reused: reusedReport },
+      levelUnit: "dB"
+    };
+    if (anyFade) out.fadeFloorDb = plan.floorDb;
+    return out;
   }
-  if (args.startTime !== undefined && args.startTime !== null) layer.startTime = args.startTime;
-
-  return {
-    layerId: layer.id,
-    index: layer.index,
-    name: layer.name,
-    compId: comp.id,
-    itemId: item.id,
-    inPoint: layer.inPoint,
-    outPoint: layer.outPoint
-  };
-};
+);
 
 
 // ===== mogrt.jsx =====
@@ -1901,6 +4097,19 @@ OPS.create_footage_layer = function (args) {
 //     a project writes Untitled.mogrt over the last one.
 //   * The export invalidates every object reference held across it, including
 //     `app.project`. See the re-fetch below.
+//
+// And one thing suppression costs, which is the whole of issue #71.
+// exportAsMotionGraphicsTemplate reports a boolean and nothing else — AE never
+// says *why* it declined — so once dialogs are suppressed a refusal and a
+// success-that-wrote-nothing look identical from a script. That silence is
+// evidence of nothing in particular, and it must not be read as "a dialog
+// blocked us": under beginSuppressDialogs() a blocking dialog is the one cause
+// ruled out by construction, because suppressing them is exactly what that call
+// did. A comp with an empty Essential Graphics panel is not exportable, and it
+// used to come back blaming a dialog that did not exist and offering a remedy
+// (retry unsuppressed and click it) that led nowhere. So: check every
+// precondition that can be checked *before* the export and name it, and when
+// the export still fails, report the cause as unknown rather than as a dialog.
 
 /** Distinct fonts used by the text layers in a comp, following nested comps. */
 function __collectFonts(comp, depth, seenComps, fonts) {
@@ -1937,6 +4146,106 @@ function __mogrtFileName(name) {
   return String(name) + ".mogrt";
 }
 
+/** Trailing separators off, so two spellings of the same folder compare equal. */
+function __trimTrailingSeparator(p) {
+  var s = String(p);
+  while (s.length > 1) {
+    var last = s.charAt(s.length - 1);
+    if (last !== "/" && last !== "\\") break;
+    s = s.substring(0, s.length - 1);
+  }
+  return s;
+}
+
+function __isBlank(s) {
+  var t = String(s);
+  for (var i = 0; i < t.length; i++) {
+    var ch = t.charAt(i);
+    if (ch !== " " && ch !== "\t" && ch !== "\n" && ch !== "\r") return false;
+  }
+  return true;
+}
+
+/**
+ * How many controllers the comp's Essential Graphics panel holds, or null when
+ * the host will not say.
+ *
+ * null is not zero. A read that throws means this AE cannot be asked, and
+ * refusing an export on the strength of a question that was never answered
+ * would be its own confidently wrong diagnosis. Only an explicit 0 refuses.
+ */
+function __controllerCount(comp) {
+  var n = null;
+  try { n = comp.motionGraphicsTemplateControllerCount; } catch (e) { return null; }
+  if (typeof n !== "number") return null;
+  return n;
+}
+
+/**
+ * Whether After Effects can actually write into the destination folder.
+ *
+ * ExtendScript has no permission API, so the only reliable test is to write.
+ * A folder that exists and refuses writes is another cause the export reports
+ * as nothing at all, and it is worth naming before spending the export rather
+ * than after. The probe is removed on every path; it never outlives the call.
+ */
+function __folderIsWritable(folder) {
+  var probe = new File(__joinPath(folder.fsName, ".ae-mcp-write-probe"));
+  var opened = false;
+  try {
+    opened = probe.open("w");
+    if (opened) probe.write("");
+  } catch (eW) {
+    opened = false;
+  }
+  try { probe.close(); } catch (eC) {}
+  try { if (probe.exists) probe.remove(); } catch (eR) {}
+  return opened === true;
+}
+
+/**
+ * The failure message for an export that wrote nothing.
+ *
+ * Built rather than fixed, because the only honest message names what was
+ * actually established and stops there. `suppressed` is the hinge: with dialogs
+ * suppressed a modal cannot be the cause and must not be mentioned as one
+ * (issue #71); without suppression it is the first thing to look at. Everything
+ * after that is unknown, and says so — AE's own UI is the only place the real
+ * reason exists, which is why the diagnostic step is to run the export by hand.
+ */
+function __exportFailureMessage(info) {
+  var lines = [];
+  lines.push(
+    "After Effects did not write a template. It returned " + String(info.exported) +
+    " and there is no file at " + info.outPath + "."
+  );
+  lines.push(
+    "Ruled out before the export ran: the project is saved (" + info.projectPath + "); the destination " +
+    "folder exists and accepts writes; the template name resolves to that folder; and the comp has " +
+    info.controllerText + "."
+  );
+  if (!info.suppressed) {
+    lines.push(
+      "Dialogs were NOT suppressed for this call, so a modal dialog waiting in After Effects is the " +
+      "likeliest cause — switch to After Effects and look for one. Retry with the default " +
+      "suppressDialogs:true once it is cleared."
+    );
+  } else {
+    lines.push(
+      "Dialogs were suppressed, so a modal dialog cannot be what stopped this — do not go looking for " +
+      "one to click. After Effects reported no reason at all, and there is no reason for a script to " +
+      "read, so the cause is unknown."
+    );
+    lines.push(
+      "To find out what After Effects would have said, ask the user to export the same comp by hand: " +
+      "Window > Essential Graphics, select the comp, then Export Motion Graphics Template. After " +
+      "Effects shows its own error there. Running this tool again with suppressDialogs:false shows the " +
+      "same dialog, but it will freeze this connection until someone clicks it."
+    );
+  }
+  return lines.join(" ");
+}
+
 OPS.export_mogrt = noUndo(function (args) {
   var comp = getCompById(args.compId);
 
@@ -1952,6 +4261,29 @@ OPS.export_mogrt = noUndo(function (args) {
     );
   }
 
+  // Every precondition that can be established from a script runs here, before
+  // the project is touched at all: the template is not renamed, the project is
+  // not saved and no export is attempted until they all pass. A refusal below
+  // therefore costs the user nothing and names its own remedy — which is the
+  // whole point, since a failure *after* the export names nothing.
+
+  // The Essential Graphics panel has to have something in it. AE will not build
+  // a template with no controllers, and under suppression it declines without a
+  // word — which is what made this look like a dialog (issue #71). An explicit
+  // 0 is the whole diagnosis; a count the host refuses to give is not.
+  var preControllerCount = __controllerCount(comp);
+  if (preControllerCount === 0) {
+    throw new Error(
+      "This comp has 0 Essential Graphics controllers, and After Effects cannot export a template " +
+      "from a comp with an empty Essential Graphics panel. It refuses without writing a file and " +
+      "without reporting anything a script can read, so nothing was exported and nothing in the " +
+      "project was changed. To fix it, put at least one property into the panel: in After Effects " +
+      "open Window > Essential Graphics, pick this comp in the panel's dropdown, then drag a layer " +
+      "property into it — a text layer's Source Text, a colour, a slider, a position. Then call " +
+      "export_mogrt again."
+    );
+  }
+
   var templateName = (typeof args.name === "string" && args.name.length > 0) ? args.name : null;
   var previousTemplateName = null;
   try { previousTemplateName = comp.motionGraphicsTemplateName; } catch (e) {}
@@ -1959,7 +4291,16 @@ OPS.export_mogrt = noUndo(function (args) {
     // AE's own default is "Untitled" for a template built by script, which
     // silently collides with every other comp in the project. The comp name is
     // what the user would have typed. A name they *did* type is left alone.
-    templateName = (!previousTemplateName || previousTemplateName === "Untitled") ? comp.name : previousTemplateName;
+    if (!previousTemplateName || previousTemplateName === "Untitled") {
+      templateName = comp.name;
+    } else {
+      templateName = previousTemplateName;
+    }
+  }
+  if (__isBlank(templateName)) {
+    throw new Error(
+      "The template name is empty, and it becomes the .mogrt filename. Pass a `name`."
+    );
   }
 
   var destDir = (typeof args.destDir === "string" && args.destDir.length > 0)
@@ -1974,6 +4315,22 @@ OPS.export_mogrt = noUndo(function (args) {
 
   var outPath = __joinPath(folder.fsName, __mogrtFileName(templateName));
   var outFile = new File(outPath);
+
+  // The name becomes a filename, so a separator in it sends the write somewhere
+  // else — or nowhere, silently. Measured rather than pattern-matched: ask the
+  // File where it actually landed and compare. That works the same on both
+  // platforms, which a list of illegal characters would not.
+  var resolvedParent = null;
+  try { resolvedParent = outFile.parent.fsName; } catch (eP) {}
+  if (resolvedParent !== null &&
+      __trimTrailingSeparator(resolvedParent) !== __trimTrailingSeparator(folder.fsName)) {
+    throw new Error(
+      "The template name \"" + templateName + "\" is used as the .mogrt filename, and it resolves to " +
+      outPath + ", which is not inside " + folder.fsName + ". Pass a `name` with no slashes in it, and " +
+      "a `destDir` if you want it written somewhere else."
+    );
+  }
+
   var existed = outFile.exists;
   if (existed && args.overwrite !== true) {
     throw new Error(
@@ -1982,6 +4339,17 @@ OPS.export_mogrt = noUndo(function (args) {
     );
   }
 
+  // Last of the checkable preconditions, and the last thing that costs nothing
+  // to get wrong. A folder that will not accept a file is one more cause the
+  // export reports as silence.
+  if (!__folderIsWritable(folder)) {
+    throw new Error(
+      "After Effects cannot write into " + folder.fsName + " — a test file could not be created there. " +
+      "Nothing was exported. Pass a `destDir` the user can write to, or ask them to fix the folder's " +
+      "permissions."
+    );
+  }
+
   var fonts = [];
   try { __collectFonts(comp, 0, [], fonts); } catch (eF) {}
 
@@ -1995,6 +4363,7 @@ OPS.export_mogrt = noUndo(function (args) {
   // Everything the result needs, read *before* the export. See below.
   var compId = comp.id;
   var compName = comp.name;
+  var projectPath = app.project.file.fsName;
 
   var suppress = args.suppressDialogs !== false;
   var suppressed = false;
@@ -2023,10 +4392,21 @@ OPS.export_mogrt = noUndo(function (args) {
   // codebase refuses to pass on.
   var written = new File(outPath);
   if (!written.exists) {
-    throw new Error(
-      "After Effects reported " + String(exported) + " for the export but no file appeared at " + outPath +
-      ". If suppressDialogs was false, a modal dialog in After Effects may have cancelled it."
-    );
+    var controllerText;
+    if (preControllerCount === null) {
+      controllerText = "controllers this version of After Effects would not count";
+    } else if (preControllerCount === 1) {
+      controllerText = "1 Essential Graphics controller";
+    } else {
+      controllerText = String(preControllerCount) + " Essential Graphics controllers";
+    }
+    throw new Error(__exportFailureMessage({
+      exported: exported,
+      outPath: outPath,
+      projectPath: projectPath,
+      suppressed: suppress,
+      controllerText: controllerText
+    }));
   }
   var bytes = written.length;
   if (!(bytes > 0)) throw new Error("The exported template at " + outPath + " is empty (0 bytes).");
@@ -2042,7 +4422,9 @@ OPS.export_mogrt = noUndo(function (args) {
     createdDir: createdDir,
     projectSaved: app.project.file.fsName,
     dialogsSuppressed: suppress,
-    controllerCount: comp.motionGraphicsTemplateControllerCount,
+    // Re-read rather than echoed: the export is the only thing that can change
+    // it, and a host that will not answer says null instead of a made-up 0.
+    controllerCount: __controllerCount(comp),
     fonts: fonts
   };
   if (!suppress) {
@@ -2175,6 +4557,11 @@ OPS.set_house_style = noUndo(function (args) {
   }
 
   file.encoding = "UTF-8";
+  // ExtendScript's default lineFeed on macOS is "Macintosh", which turns every
+  // "\n" into a bare "\r" on disk (measured on 26.3: a guide written through
+  // this op read back fine, because File.read normalises, but opened as one
+  // long line in a text editor). The file is meant to be hand-edited.
+  file.lineFeed = "Unix";
   if (!file.open("w")) throw new Error("Could not open " + file.fsName + " for writing");
   try {
     if (!file.write(content)) throw new Error("Write failed for " + file.fsName);
@@ -2196,32 +4583,66 @@ OPS.set_house_style = noUndo(function (args) {
 
 // batch.jsx — execute many ops in one ExtendScript pass.
 // For huge batches, registers a job and processes in chunks via _continue_job.
+//
+// UNDO GROUPING, which is the whole design constraint here (issue #69):
+// After Effects **discards** an undo group opened in one `evalScript` call and
+// closed in another. Measured, not inferred — a 600-op batch that opened its
+// group in `run_batch` and closed it from a later `_continue_job` produced ~600
+// undo steps, and AE's Edit menu read `Undo New Solid` rather than the group's
+// name. So a group only survives if it opens and closes inside one call, and
+// that gives the two paths below genuinely different answers:
+//
+//   inline (<= 500 ops, or any size with singleUndo) — the whole batch runs in
+//     one call, so one group round it is real. One undo step.
+//   chunked (> 500 ops) — the batch spans N calls, so the most AE will keep is
+//     one group per chunk. N undo steps, counted and reported, never claimed
+//     to be one.
+
+// The inline cutoff. 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.
+var __BATCH_INLINE_MAX = 500;
+// Chunk size for the async path. The panel reads this back off the envelope
+// rather than holding its own copy, so the two cannot drift.
+var __BATCH_CHUNK = 25;
+// The ceiling on singleUndo. Past this, one blocking ExtendScript call freezes
+// After Effects for long enough that the user will think it has hung, with no
+// progress events to say otherwise — so it is refused rather than attempted.
+var __BATCH_SINGLE_UNDO_MAX = 2000;
 
 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 };
+  var singleUndo = args.singleUndo === true;
+
+  // Refused before anything else happens, including the diff fingerprint: a
+  // call that is not going to run should cost nothing.
+  if (singleUndo && ops.length > __BATCH_SINGLE_UNDO_MAX) {
+    throw new Error(
+      "singleUndo refuses " + ops.length + " ops (the limit is " + __BATCH_SINGLE_UNDO_MAX + "). " +
+      "One undo step means the whole batch runs inside a single ExtendScript call, which " +
+      "freezes After Effects' interface for the whole of it and reports no progress; at this " +
+      "size the user would reasonably think it had hung. Either split the work into batches of " +
+      __BATCH_SINGLE_UNDO_MAX + " or fewer, or drop singleUndo and accept one undo step per " +
+      "chunk of " + __BATCH_CHUNK + " (the result says exactly how many)."
+    );
   }
+
+  // diff:true fingerprints the comps this batch names, before and after, inside
+  // this one call — see snapshot.jsx. Null unless asked for.
+  var diffState = __diffStart(args, ops);
+
+  if (ops.length <= __BATCH_INLINE_MAX || singleUndo) {
+    return __batchInline(ops, transactional, name, diffState);
+  }
+
   // Long batches: register job, return jobId; panel polls _continue_job.
+  // No undo group is opened here on purpose. One opened now would be closed
+  // from a different call and AE would throw it away, which is exactly how this
+  // op spent three releases reporting one undo step and delivering hundreds.
   var jobId = __newJobId();
+  var estimate = Math.ceil(ops.length / __BATCH_CHUNK);
   JOBS[jobId] = {
     cursor: 0,
     total: ops.length,
@@ -2231,48 +4652,212 @@ OPS.run_batch = function (args) {
     cancelled: false,
     transactional: transactional,
     name: name,
+    chunkSize: __BATCH_CHUNK,
+    // Counted as groups are actually opened, never predicted. See __UNDO_GROUPS.
+    undoSteps: 0,
+    // Carried across the chunked continuations: the before-fingerprint has to
+    // outlive the call that took it, or a long batch could never be diffed.
+    diffState: diffState,
+  };
+  return {
+    jobId: jobId,
+    async: true,
+    total: ops.length,
+    chunkSize: __BATCH_CHUNK,
+    // Labelled an estimate because it is one: a transactional failure ends the
+    // batch early, and the exact count comes back with the final result.
+    undoStepsEstimate: estimate,
+    undoGroupName: name,
+    note: "This batch runs in " + estimate + " chunks of " + __BATCH_CHUNK + " and will land as " +
+      "about " + estimate + " undo steps, NOT one — After Effects discards an undo group that " +
+      "spans two script calls, so a chunked batch can only group per chunk. The final result " +
+      "reports the exact number. If the user needs a single Cmd-Z, re-send with singleUndo:true " +
+      "(up to " + __BATCH_SINGLE_UNDO_MAX + " ops), which runs the whole batch in one blocking " +
+      "call with no progress events.",
   };
-  // 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).
+// run_batch is allowed to manage its own undo: the inline path opens exactly one
+// group of its own, and the chunked path opens one per continuation.
 OPS.run_batch.__meta = { noUndo: true };
 
+// The inline path: every op inside one undo group inside one evalScript, which
+// is the only shape After Effects keeps.
+//
+// withUndo() rather than a bare beginUndoGroup/endUndoGroup pair, for two
+// reasons: its `finally` closes the group when a transactional op throws, and it
+// is the only thing that keeps __UNDO_OPEN honest, so a batched op that calls
+// withoutUndoGroup() still works instead of silently doing nothing.
+function __batchInline(ops, transactional, name, diffState) {
+  var results = [];
+  var errors = [];
+  var before = __undoGroupsOpened();
+  // A run_batch listed as an op inside another run_batch would otherwise open a
+  // second group inside the first, and AE's groups do not nest: the inner
+  // endUndoGroup closes the outer one and the rest of the outer batch writes
+  // ungrouped. Run inside the group that is already open instead, and say so —
+  // an inner batch reporting "one undo step" of its own would be a second lie
+  // in the same shape as the one this fixes.
+  var nested = __UNDO_OPEN;
+  // An empty batch opens nothing. AE records no undo step for a group that
+  // changed nothing, so opening one would make `undoSteps: 1` an over-report on
+  // the one call where the truth is unambiguous.
+  var empty = ops.length === 0;
+  var run = function () {
+    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) {
+          // Nothing rolls back, so the half-applied state is what the caller
+          // has to reason about. The diff says where it stopped.
+          var failure = new Error("Batch failed at op[" + i + "] " + step.op + ": " + e.message);
+          __diffAnnotateError(failure, diffState);
+          throw failure;
+        }
+      }
+    }
+  };
+  try {
+    if (nested || empty) run();
+    else withUndo(name, run);
+  } catch (e) {
+    // The group is already closed by withUndo's finally. Say what it cost, so a
+    // failed batch is as clear about its undo history as a successful one.
+    try {
+      e.message = String(e.message) + " || " +
+        __batchUndoNote(__undoGroupsOpened() - before, name, nested, false);
+    } catch (e2) {}
+    throw e;
+  }
+  var out = {
+    results: results,
+    errors: errors,
+    total: ops.length,
+    undoSteps: __undoGroupsOpened() - before,
+    undoGroupName: name,
+  };
+  if (nested) out.nested = true;
+  out.note = __batchUndoNote(out.undoSteps, name, nested, false);
+  if (diffState) out.diff = __diffFinish(diffState);
+  return out;
+}
+
+// The one sentence every batch result carries about its own undo history.
+// Written for an agent that is about to tell a person how to undo the work.
+// `steps` is always the measured count, so this describes what happened rather
+// than what the path intended.
+function __batchUndoNote(steps, name, nested, chunked) {
+  if (nested) {
+    return "This batch ran inside an undo group that was already open (a run_batch nested in " +
+      "another one), so it adds no undo step of its own — its work is part of the outer step.";
+  }
+  if (steps <= 0) {
+    return "This batch opened no undo group, so it added no undo steps.";
+  }
+  if (steps === 1) {
+    // A chunked batch reaches one step only by stopping after its first chunk —
+    // cancelled, or failed in it — and that group is named "(1)", not the bare
+    // name. Quoting the wrong one would send the user looking for a menu entry
+    // that is not there.
+    return 'This batch is one undo step ("' + name + (chunked ? " (1)" : "") +
+      '"): a single Cmd-Z (Ctrl-Z on Windows) undoes all of it.';
+  }
+  if (chunked) {
+    return "This batch landed as " + steps + " undo steps, NOT one — named \"" + name + " (1)\" " +
+      'through "' + name + " (" + steps + ')". After Effects discards an undo group that spans ' +
+      "two script calls, so a chunked batch can only group per chunk. Undoing all of it takes up " +
+      "to " + steps + " presses of Cmd-Z (Ctrl-Z on Windows) — tell the user that number rather " +
+      "than saying one. (A chunk whose ops changed nothing records no step, so that is the " +
+      "ceiling.) singleUndo:true buys a single step back, at the cost of freezing AE's interface " +
+      "for the whole batch and emitting no progress.";
+  }
+  return "This batch landed as " + steps + " undo steps rather than one: an op inside it closed " +
+    "the batch's undo group and opened a new one (withoutUndoGroup — After Effects refuses " +
+    "copyToComp on a parented or expression-linked layer while a group is open). Undoing all of " +
+    "it takes up to " + steps + " presses of Cmd-Z (Ctrl-Z on Windows).";
+}
+
 // Continuation step. Returns one chunk's worth of progress.
+//
+// Cancellation, which used to need bookkeeping across calls and no longer does:
+// _cancel_job is its own evalScript and the panel serializes those, so a cancel
+// can only ever be observed *between* chunks. A chunk's group opens and closes
+// inside this one call, so there is never an open group for a cancel — or a
+// throw, or a dropped WebSocket — to leave behind. That is what the old
+// `j.undoOpen` flag was for, and it was tracking a group AE had already dropped.
 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 stopped = {
+      done: true, cancelled: true, jobId: jobId,
+      results: j.results, errors: j.errors,
+      undoSteps: j.undoSteps, undoGroupName: j.name,
+      note: __batchUndoNote(j.undoSteps, j.name, false, true),
+    };
+    if (j.diffState) stopped.diff = __diffFinish(j.diffState);
+    return stopped;
   }
-  var chunkSize = args.chunkSize || 25;
+  var chunkSize = args.chunkSize || j.chunkSize || __BATCH_CHUNK;
   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 };
+  var before = __undoGroupsOpened();
+  var failure = null;
+  // One group per chunk, opened and closed inside this call. The chunk number
+  // is in the name so the Edit menu says which part of the batch a step is.
+  withUndo(j.name + " (" + (j.undoSteps + 1) + ")", function () {
+    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) {
+          failure = { error: e.message, atIndex: j.cursor };
+          return;
+        }
       }
     }
+  });
+  j.undoSteps += __undoGroupsOpened() - before;
+
+  if (failure) {
+    // No rollback is attempted. The old code fired one `Undo` menu command
+    // here, which undoes at most the last step even when it works at all —
+    // menu commands depend on host focus and the active selection, neither of
+    // which this bridge has. Reporting a rollback that did not happen is the
+    // same class of lie as swallowing an error, so it says plainly what is on
+    // disk and how many steps it took.
+    var failed = {
+      done: true, failed: true, jobId: jobId,
+      error: failure.error, atIndex: failure.atIndex,
+      results: j.results, errors: j.errors,
+      rolledBack: false,
+      undoSteps: j.undoSteps, undoGroupName: j.name,
+      note: __batchUndoNote(j.undoSteps, j.name, false, true) +
+        " Nothing was rolled back: the ops before op[" + failure.atIndex + "] are applied and " +
+        "stay applied. Read the state back rather than re-running the batch.",
+    };
+    if (j.diffState) failed.diff = __diffFinish(j.diffState);
+    return failed;
   }
   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 };
+    var done = {
+      done: true, jobId: jobId,
+      results: j.results, errors: j.errors, total: j.total,
+      undoSteps: j.undoSteps, undoGroupName: j.name,
+      note: __batchUndoNote(j.undoSteps, j.name, false, true),
+    };
+    if (j.diffState) done.diff = __diffFinish(j.diffState);
+    return done;
   }
-  return { done: false, jobId: jobId, progress: j.cursor, total: j.total };
+  return { done: false, jobId: jobId, progress: j.cursor, total: j.total, undoSteps: j.undoSteps };
 });
 
 OPS._cancel_job = noUndo(function (args) {
@@ -2285,7 +4870,10 @@ OPS._cancel_job = noUndo(function (args) {
 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 };
+  return {
+    cursor: j.cursor, total: j.total, cancelled: j.cancelled,
+    errorCount: j.errors.length, undoSteps: j.undoSteps,
+  };
 });
 
 
@@ -2787,7 +5375,16 @@ OPS.get_project_summary = noUndo(function (args) {
   };
 });
 
+// A search, so the default is the opposite of list_layers: absent `include`
+// means the core alone — id/index/name/sourceType plus the comp — because the
+// reason to call this is to learn which layers exist and what to address them
+// by, not to read them (issue #87: nine matches cost ~2k tokens, re-sent on
+// every later request). `include: []` and omitting it are therefore the same
+// here, and the section names are list_layers' own, read through the same
+// __layerSummary. What was included is echoed, so a bounded answer is never
+// read as a full one.
 OPS.find_layers = noUndo(function (args) {
+  var sections = (args && args.include) ? args.include : [];
   var out = [];
   var comps = [];
   if (args.compId) comps.push(getCompById(args.compId));
@@ -2814,16 +5411,125 @@ OPS.find_layers = noUndo(function (args) {
         }
         if (!hit) continue;
       }
-      var s = __layerSummary(l);
+      var s = __layerSummary(l, sections);
       s.compId = c.id;
       s.compName = c.name;
       out.push(s);
     }
   }
-  return out;
+  return { matches: out, count: out.length, compsSearched: comps.length, included: sections };
 });
 
 
+// ===== helpers.jsx =====
+
+// helpers.jsx — the scope a run_jsx script runs in.
+//
+// Everything in this file is a global function, which is what makes it visible
+// to `eval`d script bodies and to anything loaded through run_jsx's
+// `libraries`. It exists because the run_jsx description promised "helpers in
+// scope" and never said which, so every session re-derived the same four or
+// five functions — find-a-layer-by-id, ease-with-the-right-array-size, a shape
+// builder that zeros the position (issue #53). Each of these was written from
+// scratch in the transcript, at token cost, with a fresh chance of getting the
+// AE quirk wrong.
+//
+// The rule for adding one: it has to be something an agent would otherwise
+// write badly, not merely something it would write often. All four below wrap
+// a documented AE trap.
+//
+// These are listed by signature in the run_jsx tool description. If you change
+// one, change that too — it is the only place a caller ever sees them.
+
+// getCompById by a shorter name, because that is the name agents guess.
+function compById(id) {
+  return getCompById(id);
+}
+
+// getLayerById, but the comp may be given as an id. An agent holding
+// (compId, layerId) — the pair every tool returns — can use it directly.
+function layerById(comp, layerId) {
+  var c = comp;
+  if (typeof c === "number") c = getCompById(c);
+  return getLayerById(c, layerId);
+}
+
+// {influence, speed}, or a bare number read as influence. AE's own default
+// ease is 33% influence at zero speed, so that is what an omitted field gets.
+function __hEaseSpec(spec) {
+  if (spec === null || spec === undefined) return { influence: 33, speed: 0 };
+  if (typeof spec === "number") return { influence: spec, speed: 0 };
+  var inf = 33;
+  var spd = 0;
+  if (typeof spec.influence === "number") inf = spec.influence;
+  if (typeof spec.speed === "number") spd = spec.speed;
+  return { influence: inf, speed: spd };
+}
+
+// ease(prop, keyIndex, easeIn, easeOut) — sizes its own ease array.
+//
+// setTemporalEaseAtKey wants one KeyframeEase per dimension and the count is
+// NOT derivable from the value: a spatial property takes exactly one whatever
+// its dimension (the ease runs along the motion path), a 2D layer's Scale takes
+// three, a shape's Ellipse Size takes two, Opacity and sliders take one. The
+// wrong count throws "parameter 2" and says nothing else (issue #50).
+//
+// The sizing lives in `__applyTemporalEase` in keyframes.jsx, which is what
+// `set_temporal_ease` and `add_keyframe` use. This helper is the same function
+// with a friendlier signature — deliberately not a second implementation, so a
+// script written through run_jsx and the same work done through the tools can
+// never disagree about what a property wanted.
+//
+// easeOut omitted means the same ease on both sides. Returns the number of
+// entries that worked, so a caller can see what the property actually wanted.
+function ease(prop, keyIndex, easeIn, easeOut) {
+  var inSpec = __hEaseSpec(easeIn);
+  var outSpec = __hEaseSpec(easeOut === undefined ? easeIn : easeOut);
+  return __applyTemporalEase(prop, keyIndex, inSpec, outSpec);
+}
+
+// addKeys(prop, [[time, value], ...]) — or [{time, value}, ...].
+// Returns the key index of each, in the order given, so the next call can ease
+// them without searching for them again.
+function addKeys(prop, pairs) {
+  if (!pairs || !pairs.length) return [];
+  var out = [];
+  for (var i = 0; i < pairs.length; i++) {
+    var p = pairs[i];
+    var t;
+    var v;
+    if (p instanceof Array) {
+      t = p[0];
+      v = p[1];
+    } else {
+      t = p.time;
+      v = p.value;
+    }
+    prop.setValueAtTime(t, v);
+    out.push(prop.nearestKeyIndex(t));
+  }
+  return out;
+}
+
+// shape(comp, {name, position}) — a shape layer that lands at [0,0].
+//
+// AE spawns a scripted shape layer at the comp centre with its anchor at
+// (0,0), so paths authored in comp pixels come out offset by half a frame —
+// easy to miss on a downsampled screenshot (issue #51). Position [0,0] makes
+// the layer's coordinate space the comp's, which is what path vertices assume.
+function shape(comp, opts) {
+  var c = comp;
+  if (typeof c === "number") c = getCompById(c);
+  var o = opts || {};
+  var l = c.layers.addShape();
+  if (o.name) l.name = o.name;
+  var pos = o.position ? o.position : [0, 0];
+  var value = (pos.length === 3) ? pos : [pos[0], pos[1]];
+  l.property("Transform").property("Position").setValue(value);
+  return l;
+}
+
+
 // ===== raw.jsx =====
 
 // raw.jsx — escape hatch. Eval arbitrary ExtendScript and return the value.
@@ -2949,17 +5655,369 @@ function __rjResult(result, undoGroupName) {
   };
 }
 
+// ---------- Mapping a failure back onto the caller's own script ----------
+// A failed run_jsx reported After Effects' line number with nothing to measure
+// it against, and that number does not count from where the caller thinks it
+// does: the same "line 22" pointed at two different statements in consecutive
+// calls (issue #46). Nothing rolls back, so an agent that cannot locate the
+// throw has to read the whole project back to find out where the script stopped.
+//
+// Two halves, and the second is the one that actually helps. The caller's line
+// 1 sits a *counted* distance down the evaluated source: with no libraries the
+// prefix carries no newline and the distance is zero, and with libraries it is
+// however many lines of library text were inlined ahead of the script.
+// __rjBuildSource measures the preamble it actually built rather than asserting
+// a constant, so the number can never drift from the string it describes —
+// a hand-written constant beside a string is exactly how the two came apart the
+// first time. Then the mapped line is reported with its TEXT, which an agent
+// can act on without trusting any numbering at all.
+//
+// The mapping refuses to guess: a line that falls outside the submitted source
+// is reported as unmappable, never clamped — unless it lands in a library that
+// was inlined ahead of it, which is a real file with real lines and is named.
+// A confident wrong line number is worse than none — it sends the reader to a
+// statement that did not fail.
+var __RJ_WRAP_PREFIX = "(function(){ ";
+// The closer sits on its own line. Appended to the caller's last line, a script
+// ending in a `//` comment commented out its own `})()` and failed to parse for
+// a reason nothing in the error mentioned.
+var __RJ_WRAP_SUFFIX = "\n})()";
+
+// No regex literal: tests/unit/jsx-ternary.mjs strips string and comment
+// literals from these sources and does not understand regex literals, so one
+// here could desynchronise its scan of this file. (audio.jsx and footage.jsx do
+// carry a few; they survive only because their contents happen to pair up.)
+function __rjLines(s) {
+  return String(s).split("\r\n").join("\n").split("\r").join("\n").split("\n");
+}
+
+// The preamble of a call with no libraries: the bare wrapper opener, which
+// carries no newline, so zero. __rjBuildSource recomputes this per call once
+// libraries are in it; this is the default __rjSourceInfo falls back on when a
+// caller hands it no layout.
+var __RJ_PREAMBLE_LINES = __rjLines(__RJ_WRAP_PREFIX).length - 1;
+
+function __rjTrim(s) {
+  var t = String(s);
+  var a = 0;
+  var b = t.length;
+  while (a < b && (t.charAt(a) === " " || t.charAt(a) === "\t")) a++;
+  while (b > a && (t.charAt(b - 1) === " " || t.charAt(b - 1) === "\t")) b--;
+  return t.substring(a, b);
+}
+
+function __rjClip(s, max) {
+  var t = String(s);
+  if (t.length <= max) return t;
+  return t.substring(0, max) + " ...";
+}
+
+// What After Effects reported, mapped onto the source the caller submitted.
+// Nothing here is fabricated: when the number does not land inside the script,
+// sourceLine stays null and the server says the number could not be mapped.
+//
+// `layout` is what __rjBuildSource returned for this call — how many lines of
+// preamble sit ahead of the caller's line 1, and where each inlined library
+// landed in the evaluated source. Omitted, it means the bare wrapper: no
+// libraries and a zero-line preamble, which is every call without `libraries`.
+function __rjSourceInfo(e, code, scriptPath, layout) {
+  var lay = layout ? layout : { preambleLines: __RJ_PREAMBLE_LINES, segments: [] };
+  var preamble = lay.preambleLines;
+  var segs = lay.segments ? lay.segments : [];
+  var lines = __rjLines(code);
+  var info = {
+    lineCount: lines.length,
+    rawLine: null,
+    sourceLine: null,
+    sourceText: null
+  };
+  if (scriptPath) info.sourceName = String(scriptPath);
+
+  var raw = null;
+  try {
+    if (e && typeof e.line === "number" && isFinite(e.line)) raw = e.line;
+  } catch (e1) {}
+  info.rawLine = raw;
+
+  // Which line of the *evaluated source* — the wrapper, the inlined libraries
+  // and the caller's script together — the failure sits on. After Effects' own
+  // `line` already counts from there, which is what makes it usable at all.
+  var wrapperLine = null;
+
+  // ExtendScript's Error also carries `source` (the text the error was raised
+  // in) with `start`/`end` character offsets into it, and the documentation
+  // presents those as the better answer, because they need no assumption about
+  // what `line` counts from. On After Effects 2026 they are not offsets at all.
+  //
+  // Probed inside AE, catching from a four-line script that throws on line 4:
+  //
+  //   eval("(function(){ var a=1;\nvar b=2;\nvar c=3;\nnope.boom();\n})()")
+  //   caught -> { "line": 4, "start": 0, "end": 0, "srcLen": 57 }
+  //
+  // `line` is already correct. `start` and `end` came back 0 on every error
+  // measured, however far into the source it was raised. Read as an offset, a
+  // zero start puts *every* failure on line 1 and prints line 1's text — which
+  // is exactly what issue #46 still did after it was reported fixed, with the
+  // true number demoted to the parenthetical afterwards.
+  //
+  // So the branch survives only for offsets that could actually be real: 0/0 is
+  // After Effects declining to say, not After Effects pointing at the first
+  // character. Do not restore this from the documentation.
+  try {
+    var src = null;
+    if (e && typeof e.source === "string") src = e.source;
+    var start = null;
+    if (e && typeof e.start === "number" && isFinite(e.start)) start = e.start;
+    var end = null;
+    if (e && typeof e.end === "number" && isFinite(e.end)) end = e.end;
+    var offsetsUsable = false;
+    if (start !== null && start > 0) offsetsUsable = true;
+    if (start === 0 && end !== null && end > 0) offsetsUsable = true;
+    if (offsetsUsable && src !== null &&
+        src.substring(0, __RJ_WRAP_PREFIX.length) === __RJ_WRAP_PREFIX) {
+      wrapperLine = __rjLines(src.substring(0, start)).length;
+    }
+  } catch (e2) {}
+  if (wrapperLine === null) wrapperLine = raw;
+  if (wrapperLine === null) return info;
+
+  var mapped = wrapperLine - preamble;
+  if (mapped >= 1 && mapped <= lines.length) {
+    info.sourceLine = mapped;
+    info.sourceText = __rjClip(__rjTrim(lines[mapped - 1]), 200);
+    return info;
+  }
+
+  // Not the caller's script. A library inlined ahead of it is a real file with
+  // real lines, so name it and point into it rather than reporting the number
+  // as unmappable: that file is where the reader has to look, and naming the
+  // script instead would send them to a line that did not fail.
+  for (var s = 0; s < segs.length; s++) {
+    var seg = segs[s];
+    var count = seg.lines.length - 1;
+    var within = wrapperLine - seg.firstLine + 1;
+    if (within >= 1 && within <= count) {
+      info.sourceName = seg.path;
+      info.lineCount = count;
+      info.sourceLine = within;
+      info.sourceText = __rjClip(__rjTrim(seg.lines[within - 1]), 200);
+      return info;
+    }
+  }
+  return info;
+}
+
+// Rethrow with the mapping attached. dispatch()'s catch copies whatever sits on
+// `aeDetail` onto the error result; the panel forwards the fields it names and
+// the server prints the line's text. A plain object rather than an Error
+// because ExtendScript will not reliably let us write `line` on one, and
+// __mkError only ever reads message/stack/line.
+function __rjThrowWithSource(e, code, scriptPath, layout) {
+  var info = __rjSourceInfo(e, code, scriptPath, layout);
+  var msg = "";
+  try { if (e && e.message) msg = String(e.message); } catch (e1) {}
+  if (!msg) {
+    try { msg = String(e); } catch (e2) { msg = "ExtendScript error"; }
+  }
+  var stack = "";
+  try { if (e && e.stack) stack = String(e.stack); } catch (e3) {}
+  throw { message: msg, stack: stack, line: info.rawLine, aeDetail: info };
+}
+
+// ---------- Helper libraries ----------
+// A library's source is inlined into the SAME eval as the caller's script,
+// ahead of it. That is not the obvious design, and it is the only one that
+// works.
+//
+// The first version used $.evalFile, on the documented premise that it
+// evaluates at global scope — load once, call for the rest of the After Effects
+// session (issue #53). Probed inside AE 2026, calling $.evalFile from the body
+// of an eval'd script, on a library declaring `function rig2()` and
+// `var RIGVAR = 3`:
+//
+//   {"exists":true, "typeofRig2_local":"function", "typeofRIGVAR_local":"number",
+//    "globalRig2":"undefined", "viaGlobal":null}
+//   // and on the next run_jsx call, in the same AE session:
+//   {"typeofRig2":"undefined", "viaGlobal":"undefined"}
+//
+// $.evalFile evaluates into the *calling function's* scope, exactly as eval
+// does. Everything a library defined therefore lived inside the loader and was
+// gone before the wrapper ran, so `libraries` answered "Function rig is
+// undefined" every time, for every library, in every session. The per-session
+// cache keyed on a content hash has gone with it: nothing was ever left loaded
+// to reuse, so the only work it ever skipped was work whose result had already
+// been discarded.
+//
+// One eval means one scope: a library's `function helper(){}` is a declaration
+// in the same function body as the script, so the script can call it. Two
+// consequences, both handled here rather than left to surprise someone:
+//
+//  * A library is re-evaluated on every call. That is the price of the scoping
+//    After Effects actually has. Keep libraries to declarations, not to work.
+//  * The library text shifts the caller's line 1 down, which is precisely the
+//    failure issue #46 was about. __rjBuildSource *counts* the preamble it
+//    built rather than asserting a constant, and __rjSourceInfo subtracts that
+//    count — so a caller's line 1 is line 1 of their own script whether they
+//    passed libraries or not.
+
+// No regex literal, for the same reason __rjLines has none.
+function __rjIsBlank(s) {
+  var t = String(s);
+  for (var i = 0; i < t.length; i++) {
+    var c = t.charAt(i);
+    if (c !== " " && c !== "\t" && c !== "\n" && c !== "\r") return false;
+  }
+  return true;
+}
+
+// Every library ends in a newline before the next one — or the caller's script
+// — follows it. Appended directly, a library whose last line is a `//` comment
+// would comment out whatever came after it: the same trap __RJ_WRAP_SUFFIX
+// exists for at the other end of the wrapper.
+function __rjEndWithNewline(s) {
+  var t = String(s);
+  if (t.length === 0) return "\n";
+  var last = t.charAt(t.length - 1);
+  if (last === "\n" || last === "\r") return t;
+  return t + "\n";
+}
+
+// The server reads library files and sends {path, text}, exactly as it does for
+// scriptPath — one place reads files, and its errors can name the path it was
+// given. Arriving with a path and no text means the call did not come through
+// the run_jsx tool: a run_batch step, whose args are never validated, or a
+// hand-rolled POST /op.
+function __rjLibrarySource(lib) {
+  var p = null;
+  var text = null;
+  if (typeof lib === "string") {
+    p = lib;
+  } else if (lib) {
+    p = lib.path;
+    if (typeof lib.text === "string") text = lib.text;
+  }
+  if (!p) throw new Error("run_jsx: a libraries entry has no path.");
+  if (text === null) {
+    throw new Error(
+      "run_jsx library \"" + p + "\" arrived with no source text. The server reads library files " +
+      "and substitutes their contents, so this call did not go through the run_jsx tool — " +
+      "run_batch steps and direct /op posts must pass {path, text} themselves."
+    );
+  }
+  if (__rjIsBlank(text)) throw new Error("run_jsx library is empty: " + p);
+  return { path: String(p), text: __rjEndWithNewline(text) };
+}
+
+// Parse each library on its own before any of it reaches the shared eval.
+// Inlining means a library that does not parse takes the whole wrapper with it,
+// and the line After Effects reports for a syntax error is wherever its parser
+// gave up — frequently inside the caller's script, which would blame the wrong
+// file for someone else's missing brace. An uncalled function expression forces
+// a full parse of exactly this library and nothing else, so the failure names
+// it and counts from its own line 1.
+function __rjCheckLibraryParses(lib) {
+  try {
+    eval("(function(){ " + lib.text + "})");
+  } catch (e) {
+    var m = "";
+    try { m = (e && e.message) ? String(e.message) : String(e); } catch (e1) { m = "unknown error"; }
+    var ln = null;
+    try { if (e && typeof e.line === "number" && isFinite(e.line)) ln = e.line; } catch (e2) {}
+    var libLines = __rjLines(lib.text);
+    var count = libLines.length - 1;
+    var detail = {
+      lineCount: count,
+      rawLine: ln,
+      sourceLine: null,
+      sourceText: null,
+      sourceName: lib.path
+    };
+    if (ln !== null && ln >= 1 && ln <= count) {
+      detail.sourceLine = ln;
+      detail.sourceText = __rjClip(__rjTrim(libLines[ln - 1]), 200);
+    }
+    throw {
+      message: "run_jsx library failed to parse: " + lib.path + " — " + m,
+      stack: "",
+      line: ln,
+      aeDetail: detail
+    };
+  }
+}
+
+// The evaluated source for one call, plus the map that turns any line of it
+// back into a line of a file the caller knows about.
+//
+// `preambleLines` is COUNTED from the text that precedes the script rather than
+// assumed. That is the invariant issue #46 turned on, and it now has to hold
+// for a preamble whose length changes from call to call: it can never drift
+// from the string it describes, however many libraries there are.
+function __rjBuildSource(code, libraries) {
+  var prefix = __RJ_WRAP_PREFIX;
+  var segments = [];
+  if (libraries && libraries.length) {
+    for (var i = 0; i < libraries.length; i++) {
+      var lib = __rjLibrarySource(libraries[i]);
+      __rjCheckLibraryParses(lib);
+      segments.push({
+        path: lib.path,
+        // The wrapper opener carries no newline, so the first library's line 1
+        // shares line 1 of the evaluated source with it.
+        firstLine: __rjLines(prefix).length,
+        lines: __rjLines(lib.text)
+      });
+      prefix = prefix + lib.text;
+    }
+  }
+  return {
+    wrapper: prefix + code + __RJ_WRAP_SUFFIX,
+    preambleLines: __rjLines(prefix).length - 1,
+    segments: segments
+  };
+}
+
 // undoGroup:false is a per-call opt-out, read by dispatch() through the
 // predicate form of __meta.noUndo. It exists because AE refuses copyToComp for
 // a layer with a parent or a linked expression while an undo group is open,
 // which is exactly the layer worth copying (issue #30).
 OPS.run_jsx = noUndoWhen(function (args) { return args.undoGroup === false; }, function (args) {
   var code = args.code || "";
-  // We wrap in a function so `return` works.
-  var wrapper = "(function(){ " + code + " })()";
+  // scriptPath is resolved to code by the *server* before the payload is built.
+  // Arriving here with a path and no code means it came in some other way — a
+  // run_batch step, whose args are never validated, or a hand-rolled POST /op.
+  // Running an empty script would return the "completed with no return value"
+  // envelope, which is a success result for a file nobody read.
+  if (!code && args.scriptPath) {
+    throw new Error(
+      "run_jsx received scriptPath \"" + args.scriptPath + "\" with no code. The server reads that " +
+      "file and substitutes it, so this path did not go through the run_jsx tool — run_batch steps " +
+      "and direct /op posts must pass `code` themselves."
+    );
+  }
+  if (!code) throw new Error("run_jsx needs `code` — an empty script would report success for nothing.");
+  // We wrap in a function so `return` works, with any libraries inlined ahead
+  // of the script so they share its scope. Assembled and parse-checked before
+  // anything runs, and outside the try below: a library that fails to parse is
+  // not a line in the caller's script and must not be reported as one.
+  var built = __rjBuildSource(code, args.libraries);
   // Which undo step to look for in AE if the script has to be backed out. The
   // name mirrors dispatch()'s default ("AE MCP: " + op); false means the caller
   // asked for no group and the changes landed as whatever steps AE recorded.
   var undoGroupName = (args.undoGroup === false) ? false : "AE MCP: run_jsx";
-  return __rjResult(eval(wrapper), undoGroupName);
+  // diff:true fingerprints the comp before and after, inside this one call —
+  // see snapshot.jsx. Null unless asked for, so the ordinary path is untouched.
+  var __d = __diffStart(args, null);
+  var __value;
+  try {
+    __value = eval(built.wrapper);
+  } catch (e) {
+    // Annotate before mapping the line: __rjThrowWithSource reads e.message,
+    // so the diff note has to be on it by then, and the source mapping is what
+    // makes the reported line the caller's own (#46).
+    __diffAnnotateError(e, __d);
+    __rjThrowWithSource(e, code, args.scriptPath, built);
+  }
+  var __out = __rjResult(__value, undoGroupName);
+  if (__d) return __rjWithDiff(__out, __diffFinish(__d), undoGroupName);
+  return __out;
 });