brainferno-mcp-bridge 0.2.2 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## v0.3.0 — 2026-09-05
+
+- After Effects `ae_import_as_comp`: import a layered Photoshop (.psd) or Illustrator (.ai)
+  file as a composition — each source layer becomes its own AE layer, keeping blend modes,
+  positions, and (for PSD) editable layer styles. `cropped` chooses Composition - Cropped
+  Layers. Verified live: a PSD came in as three layers with its drop shadow editable in AE.
+  (Illustrator maps top-level layers to AE layers, so put objects on separate layers to keep
+  them separate; the file must be RGB and saved PDF-compatible.)
+- After Effects Essential Graphics: `ae_add_to_essential_graphics` exposes a layer property
+  (transform channel, a text layer's source text, or any property via propertyPath) as a
+  control, and `ae_export_mogrt` exports the composition as a Motion Graphics template
+  (.mogrt). Verified live against AE 26.3.
+- Photoshop gradient overlay: `ps_set_layer_style` now takes `style: "gradientOverlay"` with
+  `colors` (two or more hex stops), `gradientStyle` (linear/radial/angle/reflected/diamond),
+  `angle`, `scale`, `reverse`, `alignWithLayer`, and `dither`.
+- After Effects `ae_set_expression` now rolls the property back to its previous expression
+  when the new one fails to compile (it used to leave the broken source assigned).
+- Layer styles for Photoshop and After Effects. Photoshop: `ps_set_layer_style` (add or edit
+  a drop shadow, inner shadow, glow, bevel & emboss, satin, color overlay, or stroke — other
+  styles on the layer are kept), `ps_get_layer_styles`, `ps_remove_layer_style`. After
+  Effects: `ae_add_layer_style`, `ae_set_layer_style_param`, `ae_get_layer_styles`,
+  `ae_remove_layer_style` — friendly names map to AE's match names (satin → `chromeFX`,
+  colorOverlay → `solidFill`, stroke → `frameFX`).
+- New Premiere Pro tool `pp_insert_mogrt`: drop a Motion Graphics template (.mogrt) on the
+  timeline at a time, like dragging it from the Essential Graphics panel. Without
+  `videoTrackIndex` it lands on the first track above every video clip playing at that time,
+  so the graphic sits over the picture.
+
 ## v0.2.2 — 2026-08-30
 
 - The server reported itself as **0.1.0** to every MCP client and every panel, whatever

package/README.md

@@ -25,8 +25,9 @@ the way. Every action is one undo step in the app, so you can always step back.
 - **Runs on your machine.** Nothing leaves your computer unless you turn on *shared* mode
   for other computers on your network (token-protected).
 
-> Status: v0.2 — every tool verified live on Windows and macOS, the two platforms Adobe
-> ships Creative Cloud for (Adobe 2026 apps). See [Status](#status).
+> Status: every tool verified live on Windows and macOS, the two platforms Adobe ships
+> Creative Cloud for (Adobe 2026 apps). The npm badge above is the current version.
+> See [Status](#status).
 
 The companion panel inside each app — here in Adobe After Effects and Adobe Photoshop —
 shows the connection, a live log, and a kill switch:
@@ -77,22 +78,28 @@ Ideas people build with it:
 Counts are the tools registered per app. Each family has a live-run write-up in
 `docs/spikes/` with the quirks found on real installs.
 
-### Photoshop — 18 tools
+### Photoshop — 21 tools
 Documents (list, create, open, save, export PNG/JPEG, preview image), layers (create,
-text layers with font/size/color, properties, move, duplicate, delete), place an image as a
-smart object, fill, filters (Gaussian/motion/unsharp…), resize, crop.
-
-### After Effects — 24 tools
-Project info and file, compositions and footage (list, create, import), layers of every
-kind (footage, solid, text, null, adjustment), keyframes with easing, expressions, effects
-and their parameters, text content/font/color/justification, markers, single-frame preview,
-render queue, and headless rendering through `aerender` (the UI stays free).
-
-### Premiere Pro — 28 tools
+text layers with font/size/color, properties, move, duplicate, delete), layer styles
+(drop shadow, glows, bevel, satin, color and gradient overlay, stroke… — add, adjust, read,
+remove), place an image as a smart object, fill, filters (Gaussian/motion/unsharp…),
+resize, crop.
+
+### After Effects — 31 tools
+Project info and file, compositions and footage (list, create, import), import a layered
+PSD or AI file as a composition (one layer each, with PSD layer styles editable), layers of
+every kind (footage, solid, text, null, adjustment), keyframes with easing, expressions,
+effects and their parameters, layer styles (drop shadow, glows, bevel, stroke… — add, adjust,
+read, remove), text content/font/color/justification, markers, Essential Graphics (expose a
+control, export a Motion Graphics template), single-frame preview, render queue, and
+headless rendering through `aerender` (the UI stays free).
+
+### Premiere Pro — 29 tools
 Project, sequences and items, a full sequence read (every track and clip with times),
-import, create a sequence from media, insert/overwrite, ripple remove, move, trim, rename,
-transitions, effects and keyframes (Motion, Opacity, any applied effect), markers, frame
-preview, export preset search, and export (in Premiere or handed to Media Encoder).
+import, create a sequence from media, insert/overwrite, Motion Graphics templates (.mogrt)
+dropped over the picture, ripple remove, move, trim, rename, transitions, effects and
+keyframes (Motion, Opacity, any applied effect), markers, frame preview, export preset
+search, and export (in Premiere or handed to Media Encoder).
 
 ### Illustrator — 7 tools + Adobe's own 46
 Create documents, draw shapes (rect, ellipse, line, polygon, star) and text, save `.ai`,
@@ -412,8 +419,9 @@ docs/                build plan, protocol, live-run notes (spikes/), Audition AP
 
 - **Working, verified live on Windows and macOS (Adobe 2026 apps)**: all six application
   lanes and their v1 tool sets, the ffmpeg lane, the job registry, the four pipelines, remote
-  mode, and the installer. Write-ups with the quirks found: `docs/spikes/05`–`13` (`13` is the
-  macOS run: aerender path, Media Encoder's config file and renderer).
+  mode, and the installer. Write-ups with the quirks found: `docs/spikes/05`–`14` (`13` is the
+  macOS run: aerender path, Media Encoder's config file and renderer; `14` is the release
+  process and what npm actually does after a publish).
 - **Not yet**: double-click panel installs (`.ccx`/`.zxp`) so the UXP Developer
   Tool is not needed; a single signed installer; TLS for shared mode; Audition multitrack
   writes; Media Encoder queue control.

package/dist/tools/after-effects.d.ts

@@ -9,6 +9,14 @@ export declare function getLayerScript(compId: number, layerIndex: number): stri
 export declare function openProjectScript(path: string): string;
 export declare function saveProjectScript(path: string | undefined): string;
 export declare function importFootageScript(path: string): string;
+/**
+ * Import a layered PSD or AI as a composition (one AE layer per source layer).
+ * ImportAsType.COMP keeps each layer at document size; COMP_CROPPED_LAYERS crops
+ * to content. The importer preserves blend modes and positions, and — for PSD —
+ * layer styles as After Effects imports them. There is no ImportOptions flag for
+ * the dialog's "editable vs merged layer styles"; AE uses its own default.
+ */
+export declare function importAsCompScript(path: string, cropped: boolean): string;
 export interface CreateCompParams {
     name: string;
     width: number;
@@ -62,6 +70,43 @@ export declare function removeKeyframesScript(compId: number, layerIndex: number
 export declare function setExpressionScript(compId: number, layerIndex: number, property: string, propertyPath: string[] | undefined, expression: string | null): string;
 export declare function applyEffectScript(compId: number, layerIndex: number, matchName: string): string;
 export declare function setEffectParamScript(compId: number, layerIndex: number, effect: number | string, param: string, value: number | number[] | string): string;
+/**
+ * Layer styles are Photoshop's effects (drop shadow, stroke, …) living under
+ * "ADBE Layer Styles". Each maps to an internal key; the group is addressed by
+ * its match name "<key>/enabled" and its parameters by "<key>/<param>".
+ */
+export declare const LAYER_STYLE_KEYS: {
+    readonly dropShadow: "dropShadow";
+    readonly innerShadow: "innerShadow";
+    readonly outerGlow: "outerGlow";
+    readonly innerGlow: "innerGlow";
+    readonly bevelEmboss: "bevelEmboss";
+    readonly satin: "chromeFX";
+    readonly colorOverlay: "solidFill";
+    readonly gradientOverlay: "gradientFill";
+    readonly stroke: "frameFX";
+};
+export type LayerStyleName = keyof typeof LAYER_STYLE_KEYS;
+export declare function addLayerStyleScript(compId: number, layerIndex: number, style: LayerStyleName): string;
+export declare function getLayerStylesScript(compId: number, layerIndex: number): string;
+export declare function setLayerStyleParamScript(compId: number, layerIndex: number, style: LayerStyleName, param: string, value: number | number[] | string): string;
+export declare function removeLayerStyleScript(compId: number, layerIndex: number, style: LayerStyleName): string;
+/**
+ * Expose a layer property in the comp's Essential Graphics panel so the comp can
+ * be exported as a Motion Graphics template. Verified live on AE 26.3:
+ * canAddToMotionGraphicsTemplate / addToMotionGraphicsTemplate take the comp the
+ * property lives in; the control is named after the property (AE 26.3 has no
+ * script to rename it). Source Text lives at ADBE Text Properties > Text Document.
+ */
+export declare function addToEssentialGraphicsScript(compId: number, layerIndex: number, property: string, propertyPath: string[] | undefined): string;
+/**
+ * Export the comp as a .mogrt. The host's exportAsMotionGraphicsTemplate takes a
+ * *folder* and names the file from motionGraphicsTemplateName, so we split the
+ * requested path, set the name, and write <folder>/<name>.mogrt. Verified live on
+ * AE 26.3 (the pre-24.3 "always returns false" bug is gone; we still check the
+ * file exists). The project must be saved — a dirty project makes AE prompt.
+ */
+export declare function exportMogrtScript(compId: number, folder: string, name: string, overwrite: boolean): string;
 export interface SetTextParams {
     compId: number;
     layerIndex: number;

package/dist/tools/after-effects.js

@@ -78,6 +78,30 @@ const HELPERS = `
   function __compInfo(c) {
     return { id: c.id, name: c.name, width: c.width, height: c.height, duration: c.duration, frameRate: c.frameRate, numLayers: c.numLayers, pixelAspect: c.pixelAspect };
   }
+  function __styles(l) {
+    var g = l.property("ADBE Layer Styles");
+    if (!g) { throw new Error("Layer " + l.index + " has no layer styles group (cameras and lights cannot take styles)."); }
+    return g;
+  }
+  // A style's group is fetched by its match name "<key>/enabled" (the short key
+  // resolves for dropShadow only). canSetEnabled is false until the style is
+  // actually added, so it doubles as "is this style present".
+  function __styleGroup(g, key) {
+    var f = null;
+    try { f = g.property(key + "/enabled"); } catch (e) {}
+    if (f && !f.canSetEnabled) { f = null; }
+    return f;
+  }
+  function __styleParams(s) {
+    var out = [];
+    for (var i = 1; i <= s.numProperties; i++) {
+      var q = s.property(i);
+      var v = null;
+      try { v = q.value; } catch (e) {}
+      out.push({ index: i, name: q.name, matchName: q.matchName, value: v });
+    }
+    return out;
+  }
 `;
 const wrap = (body) => `(function () {${HELPERS}${body}
 })()`;
@@ -152,6 +176,32 @@ export function importFootageScript(path) {
     return { id: item.id, name: item.name, width: item.width, height: item.height, duration: item.duration, hasVideo: item.hasVideo, hasAudio: item.hasAudio };
   });`);
 }
+/**
+ * Import a layered PSD or AI as a composition (one AE layer per source layer).
+ * ImportAsType.COMP keeps each layer at document size; COMP_CROPPED_LAYERS crops
+ * to content. The importer preserves blend modes and positions, and — for PSD —
+ * layer styles as After Effects imports them. There is no ImportOptions flag for
+ * the dialog's "editable vs merged layer styles"; AE uses its own default.
+ */
+export function importAsCompScript(path, cropped) {
+    const want = cropped ? "ImportAsType.COMP_CROPPED_LAYERS" : "ImportAsType.COMP";
+    return wrap(`
+  var f = new File(${lit(path)});
+  if (!f.exists) { throw new Error("No file at " + f.fsName); }
+  return __undo("Import as composition", function () {
+    var io = new ImportOptions(f);
+    if (io.canImportAs(${want})) { io.importAs = ${want}; }
+    else if (io.canImportAs(ImportAsType.COMP)) { io.importAs = ImportAsType.COMP; }
+    else { throw new Error("After Effects can't import this as a composition. Layered .psd works; an .ai must be RGB (not CMYK) and saved with PDF compatibility."); }
+    var item = app.project.importFile(io);
+    if (!(item instanceof CompItem)) { throw new Error("Imported '" + item.name + "', but not as a composition — the file may have only one layer."); }
+    var info = __compInfo(item);
+    var layers = [];
+    for (var i = 1; i <= item.numLayers; i++) { layers.push(__layerInfo(item.layer(i))); }
+    info.layers = layers;
+    return info;
+  });`);
+}
 export function createCompScript(p) {
     return wrap(`
   return __undo("Create comp", function () {
@@ -271,8 +321,15 @@ export function setExpressionScript(compId, layerIndex, property, propertyPath,
   return __undo("Set expression", function () {
     var e = ${opt(expression)};
     if (e === null) { prop.expression = ""; return { property: prop.name, expression: null }; }
+    // Keep the old expression so a failed compile leaves the property untouched
+    // (AE otherwise keeps the broken source assigned, just disabled).
+    var prev = prop.expression;
     prop.expression = e;
-    if (prop.expressionError) { throw new Error("Expression error: " + prop.expressionError); }
+    if (prop.expressionError) {
+      var err = prop.expressionError;
+      prop.expression = prev;
+      throw new Error("Expression error: " + err);
+    }
     return { property: prop.name, expression: prop.expression, enabled: prop.expressionEnabled };
   });`);
 }
@@ -299,6 +356,180 @@ export function setEffectParamScript(compId, layerIndex, effect, param, value) {
   if (!pp) { throw new Error("Parameter not found: " + ${lit(param)}); }
   return __undo("Set effect parameter", function () { pp.setValue(${v}); return { effect: e.name, param: pp.name, value: pp.value }; });`);
 }
+/**
+ * Layer styles are Photoshop's effects (drop shadow, stroke, …) living under
+ * "ADBE Layer Styles". Each maps to an internal key; the group is addressed by
+ * its match name "<key>/enabled" and its parameters by "<key>/<param>".
+ */
+export const LAYER_STYLE_KEYS = {
+    dropShadow: "dropShadow",
+    innerShadow: "innerShadow",
+    outerGlow: "outerGlow",
+    innerGlow: "innerGlow",
+    bevelEmboss: "bevelEmboss",
+    satin: "chromeFX",
+    colorOverlay: "solidFill",
+    gradientOverlay: "gradientFill",
+    stroke: "frameFX",
+};
+/**
+ * Layer styles cannot be added with addProperty (After Effects refuses it). The
+ * working way is the Layer > Layer Styles menu command, which needs the comp
+ * open in the viewer and the target layer selected. The menu ids are the stable
+ * 9000–9008 block (verified live); findMenuCommandId returned a bogus id once
+ * after a reconnect, so the fixed id runs first and the label is only a retry.
+ */
+const LAYER_STYLE_MENU = {
+    dropShadow: { label: "Drop Shadow", id: 9000 },
+    innerShadow: { label: "Inner Shadow", id: 9001 },
+    outerGlow: { label: "Outer Glow", id: 9002 },
+    innerGlow: { label: "Inner Glow", id: 9003 },
+    bevelEmboss: { label: "Bevel and Emboss", id: 9004 },
+    satin: { label: "Satin", id: 9005 },
+    colorOverlay: { label: "Color Overlay", id: 9006 },
+    gradientOverlay: { label: "Gradient Overlay", id: 9007 },
+    stroke: { label: "Stroke", id: 9008 },
+};
+export function addLayerStyleScript(compId, layerIndex, style) {
+    const key = LAYER_STYLE_KEYS[style];
+    const menu = LAYER_STYLE_MENU[style];
+    return wrap(`
+  var c = __comp(${num(compId)}); var l = __layer(c, ${num(layerIndex)});
+  var g = __styles(l);
+  var s = __styleGroup(g, ${lit(key)});
+  if (s) {
+    return __undo("Enable layer style", function () {
+      try { s.enabled = true; } catch (e) {}
+      return { style: ${lit(style)}, matchName: s.matchName, params: __styleParams(s), alreadyPresent: true };
+    });
+  }
+  // addProperty does not work for layer styles — the Layer Styles menu command
+  // is the only way, and it needs the comp foremost and only this layer selected.
+  return __undo("Add layer style", function () {
+    c.openInViewer();
+    for (var j = 1; j <= c.numLayers; j++) { c.layer(j).selected = false; }
+    l.selected = true;
+    app.executeCommand(${num(menu.id)});
+    var added = __styleGroup(g, ${lit(key)});
+    if (!added) {
+      // Very rare: the fixed id was renumbered. Retry via the localized label.
+      var mid = 0;
+      try { mid = app.findMenuCommandId(${lit(menu.label)}); } catch (e) {}
+      if (mid) { app.executeCommand(mid); added = __styleGroup(g, ${lit(key)}); }
+    }
+    if (!added) { throw new Error("Could not add the ${style} layer style (menu command did not take; is the layer a camera or light?)."); }
+    try { added.enabled = true; } catch (e) {}
+    return { style: ${lit(style)}, matchName: added.matchName, params: __styleParams(added) };
+  });`);
+}
+export function getLayerStylesScript(compId, layerIndex) {
+    return wrap(`
+  var c = __comp(${num(compId)}); var l = __layer(c, ${num(layerIndex)});
+  var g = __styles(l);
+  var out = { enabled: g.enabled, styles: [] };
+  for (var i = 1; i <= g.numProperties; i++) {
+    var s = g.property(i);
+    if (s.matchName === "ADBE Blend Options Group") { continue; }
+    if (!s.canSetEnabled) { continue; } // hidden template group, not actually on the layer
+    out.styles.push({ name: s.name, matchName: s.matchName, enabled: s.enabled, params: __styleParams(s) });
+  }
+  return out;`);
+}
+export function setLayerStyleParamScript(compId, layerIndex, style, param, value) {
+    const key = LAYER_STYLE_KEYS[style];
+    // Hex colors become AE's [r, g, b, a] 0–1 arrays; other strings pass through.
+    const hexMatch = typeof value === "string" && /^#[0-9a-fA-F]{6}$/.test(value);
+    const v = hexMatch ? `${rgb(value).slice(0, -1)}, 1]` : typeof value === "string" ? lit(value) : Array.isArray(value) ? `[${value.map(num).join(", ")}]` : num(value);
+    return wrap(`
+  var c = __comp(${num(compId)}); var l = __layer(c, ${num(layerIndex)});
+  var g = __styles(l);
+  var s = __styleGroup(g, ${lit(key)});
+  if (!s) { throw new Error("The ${style} style is not on this layer. Call ae_add_layer_style first."); }
+  var q = null;
+  var want = ${lit(param)};
+  var wl = want.toLowerCase();
+  for (var i = 1; i <= s.numProperties; i++) {
+    var cand = s.property(i);
+    if (cand.matchName === want || String(cand.name).toLowerCase() === wl) { q = cand; break; }
+  }
+  if (!q) {
+    var names = [];
+    for (var j = 1; j <= s.numProperties; j++) { names.push(s.property(j).name); }
+    throw new Error("No parameter " + want + " on " + s.name + ". Parameters: " + names.join(", "));
+  }
+  return __undo("Set layer style parameter", function () { q.setValue(${v}); return { style: ${lit(style)}, param: q.name, matchName: q.matchName, value: q.value }; });`);
+}
+export function removeLayerStyleScript(compId, layerIndex, style) {
+    const key = LAYER_STYLE_KEYS[style];
+    // After Effects keeps a permanent slot per style and rejects .remove() on it,
+    // so "remove" turns the style off (enabled = false) — the visible effect goes
+    // away, matching what the eyeball toggle does in the UI.
+    return wrap(`
+  var c = __comp(${num(compId)}); var l = __layer(c, ${num(layerIndex)});
+  var g = __styles(l);
+  var s = __styleGroup(g, ${lit(key)});
+  if (!s) { throw new Error("The ${style} style is not on this layer."); }
+  return __undo("Turn off layer style", function () { s.enabled = false; return { style: ${lit(style)}, enabled: false }; });`);
+}
+// ---- Essential Graphics / Motion Graphics templates -------------------------
+/**
+ * Expose a layer property in the comp's Essential Graphics panel so the comp can
+ * be exported as a Motion Graphics template. Verified live on AE 26.3:
+ * canAddToMotionGraphicsTemplate / addToMotionGraphicsTemplate take the comp the
+ * property lives in; the control is named after the property (AE 26.3 has no
+ * script to rename it). Source Text lives at ADBE Text Properties > Text Document.
+ */
+export function addToEssentialGraphicsScript(compId, layerIndex, property, propertyPath) {
+    const path = propertyPath ? `[${propertyPath.map(lit).join(", ")}]` : "null";
+    return wrap(`
+  var c = __comp(${num(compId)}); var l = __layer(c, ${num(layerIndex)});
+  var prop = __prop(l, ${lit(property)}, ${path});
+  if (!prop.canAddToMotionGraphicsTemplate(c)) {
+    throw new Error("'" + prop.name + "' cannot be added to Essential Graphics — either its type is not supported or a control with that name is already there.");
+  }
+  return __undo("Add to Essential Graphics", function () {
+    var ok = prop.addToMotionGraphicsTemplate(c);
+    if (!ok) { throw new Error("After Effects refused to add '" + prop.name + "' to the Essential Graphics panel."); }
+    var count = c.motionGraphicsTemplateControllerCount;
+    var names = [];
+    for (var i = 1; i <= count; i++) { names.push(c.getMotionGraphicsTemplateControllerName(i)); }
+    return { added: prop.name, controllerCount: count, controllers: names };
+  });`);
+}
+/**
+ * Export the comp as a .mogrt. The host's exportAsMotionGraphicsTemplate takes a
+ * *folder* and names the file from motionGraphicsTemplateName, so we split the
+ * requested path, set the name, and write <folder>/<name>.mogrt. Verified live on
+ * AE 26.3 (the pre-24.3 "always returns false" bug is gone; we still check the
+ * file exists). The project must be saved — a dirty project makes AE prompt.
+ */
+export function exportMogrtScript(compId, folder, name, overwrite) {
+    return wrap(`
+  var c = __comp(${num(compId)});
+  if (!app.project.file) { throw new Error("Save the After Effects project first (ae_save_project) — exporting a Motion Graphics template needs a saved project."); }
+  var fo = new Folder(${lit(folder)});
+  if (!fo.exists) { fo.create(); }
+  c.motionGraphicsTemplateName = ${lit(name)};
+  // Read everything off the comp now: exportAsMotionGraphicsTemplate invalidates
+  // the comp reference, so touching c afterwards throws "Object is invalid".
+  var compName = c.name;
+  var controllers = c.motionGraphicsTemplateControllerCount;
+  // A missing font (or any project warning) pops a modal, and any modal blocks ALL
+  // scripting until a human dismisses it. Suppress dialogs around the save+export
+  // so it stays headless.
+  var ok = false;
+  app.beginSuppressDialogs();
+  try {
+    app.project.save();
+    ok = c.exportAsMotionGraphicsTemplate(${overwrite ? "true" : "false"}, ${lit(folder)});
+  } finally {
+    app.endSuppressDialogs(false);
+  }
+  var outPath = ${lit(folder)} + "/" + ${lit(name)} + ".mogrt";
+  var f = new File(outPath);
+  if (!f.exists) { throw new Error("After Effects did not write the .mogrt (export returned " + ok + "). Does the file already exist without overwrite, or is the folder writable? " + outPath); }
+  return { compName: compName, name: ${lit(name)}, outputPath: outPath, controllerCount: controllers };`);
+}
 export function setTextScript(p) {
     return wrap(`
   var c = __comp(${num(p.compId)}); var l = __layer(c, ${num(p.layerIndex)});
@@ -516,6 +747,17 @@ export function registerAfterEffectsTools(server, bridge, options = {}) {
         description: "Import an image, video, audio, or PSD file into the project. Returns the footage item id for ae_add_layer.",
         inputSchema: { path: z.string().min(1).describe("Absolute path to the media file.") },
     }, async ({ path }) => run(importFootageScript(path)));
+    server.registerTool("ae_import_as_comp", {
+        title: "After Effects: import a PSD or AI file as a composition",
+        description: "Import a layered Photoshop (.psd) or Illustrator (.ai) file as a composition — every source layer becomes " +
+            "its own After Effects layer, keeping blend modes, positions, and (for PSD) layer styles as After Effects " +
+            "imports them. Illustrator files must be RGB (not CMYK) and saved with PDF compatibility. Returns the new " +
+            "composition with its layers.",
+        inputSchema: {
+            path: z.string().min(1).describe("Absolute path to a .psd or .ai file."),
+            cropped: z.boolean().optional().describe("Crop each layer to its content (Composition - Cropped Layers). Defaults to false = keep document-size layers."),
+        },
+    }, async ({ path, cropped }) => run(importAsCompScript(path, cropped ?? false)));
     // ---- comps & layers -----------------------------------------------------
     server.registerTool("ae_create_comp", {
         title: "After Effects: create a composition",
@@ -604,9 +846,52 @@ export function registerAfterEffectsTools(server, bridge, options = {}) {
     }, async ({ compId: id, layerIndex: li, property, propertyPath: pp }) => run(removeKeyframesScript(id, li, property, pp)));
     server.registerTool("ae_set_expression", {
         title: "After Effects: set an expression",
-        description: "Set (or clear with null) the expression on a layer property. Fails with the error text if the expression does not compile.",
+        description: "Set (or clear with null) the expression on a layer property. Use `property` for a transform channel, or " +
+            "`propertyPath` (match/display names) to reach an effect parameter, mask, or text source. If the expression " +
+            "does not compile it fails with the error text and the property keeps its previous expression.",
         inputSchema: { compId, layerIndex, property: propertyName, propertyPath, expression: z.string().nullable().describe("Expression source, or null to remove.") },
     }, async ({ compId: id, layerIndex: li, property, propertyPath: pp, expression }) => run(setExpressionScript(id, li, property, pp, expression)));
+    // ---- essential graphics / motion graphics templates ---------------------
+    server.registerTool("ae_add_to_essential_graphics", {
+        title: "After Effects: add a control to Essential Graphics",
+        description: "Expose a layer property in the comp's Essential Graphics panel so the comp can be exported as a Motion " +
+            "Graphics template (.mogrt). Give `property` for a transform channel or `sourceText` for a text layer's " +
+            "content, or `propertyPath` (match/display names) for anything else, e.g. an effect's Slider or Color. " +
+            "The control takes the property's name (rename it in the panel; After Effects has no script for that).",
+        inputSchema: {
+            compId,
+            layerIndex,
+            property: z
+                .enum(["position", "scale", "rotation", "opacity", "anchorPoint", "sourceText"])
+                .optional()
+                .describe("Transform channel, or sourceText for a text layer's content. For anything else, use propertyPath."),
+            propertyPath,
+        },
+    }, async ({ compId: id, layerIndex: li, property, propertyPath: pp }) => {
+        const path = property === "sourceText" && !pp ? ["ADBE Text Properties", "ADBE Text Document"] : pp;
+        const prop = property && property !== "sourceText" ? property : "position";
+        return run(addToEssentialGraphicsScript(id, li, prop, path));
+    });
+    server.registerTool("ae_export_mogrt", {
+        title: "After Effects: export a Motion Graphics template",
+        description: "Export a composition as a Motion Graphics template (.mogrt) — the controls added with " +
+            "ae_add_to_essential_graphics become its editable fields. Saves the project first (it must have been saved " +
+            "once). Returns the written path.",
+        inputSchema: {
+            compId,
+            outputPath: z.string().min(1).describe("Absolute path ending in .mogrt. The file name (minus .mogrt) becomes the template name."),
+            overwrite: z.boolean().optional().describe("Overwrite an existing file at that path. Defaults to true."),
+        },
+        annotations: { destructiveHint: true },
+    }, async ({ compId: id, outputPath, overwrite }) => {
+        const norm = outputPath.replace(/\\/g, "/");
+        const slash = norm.lastIndexOf("/");
+        const folder = slash >= 0 ? norm.slice(0, slash) : ".";
+        const name = (slash >= 0 ? norm.slice(slash + 1) : norm).replace(/\.mogrt$/i, "");
+        if (!name)
+            return run(exportMogrtScript(id, folder, "Untitled", overwrite ?? true)); // unreachable-ish; keeps a name
+        return run(exportMogrtScript(id, folder, name, overwrite ?? true));
+    });
     // ---- effects, text, markers ---------------------------------------------
     server.registerTool("ae_apply_effect", {
         title: "After Effects: apply an effect",
@@ -625,6 +910,41 @@ export function registerAfterEffectsTools(server, bridge, options = {}) {
             value: z.union([z.number(), z.array(z.number()), z.string()]),
         },
     }, async ({ compId: id, layerIndex: li, effect, param, value }) => run(setEffectParamScript(id, li, effect, param, value)));
+    // ---- layer styles -------------------------------------------------------
+    const styleName = z
+        .enum(["dropShadow", "innerShadow", "outerGlow", "innerGlow", "bevelEmboss", "satin", "colorOverlay", "gradientOverlay", "stroke"])
+        .describe("Layer style name.");
+    server.registerTool("ae_add_layer_style", {
+        title: "After Effects: add a layer style",
+        description: "Add a Photoshop-style layer style (drop shadow, inner shadow, glows, bevel & emboss, satin, color/gradient " +
+            "overlay, stroke) to a layer. Returns the style's parameters (names and current values) for ae_set_layer_style_param.",
+        inputSchema: { compId, layerIndex, style: styleName },
+    }, async ({ compId: id, layerIndex: li, style }) => run(addLayerStyleScript(id, li, style)));
+    server.registerTool("ae_get_layer_styles", {
+        title: "After Effects: read a layer's styles",
+        description: "List the layer styles on a layer with each style's parameters and current values.",
+        inputSchema: { compId, layerIndex },
+        annotations: { readOnlyHint: true },
+    }, async ({ compId: id, layerIndex: li }) => run(getLayerStylesScript(id, li), { timeoutClass: "fast" }));
+    server.registerTool("ae_set_layer_style_param", {
+        title: "After Effects: set a layer style parameter",
+        description: "Set a parameter on a layer style already added with ae_add_layer_style — by display name (e.g. 'Distance', " +
+            "'Opacity', 'Color') or match name (e.g. 'dropShadow/blur'). Colors take a hex string or [r,g,b] 0–1 array.",
+        inputSchema: {
+            compId,
+            layerIndex,
+            style: styleName,
+            param: z.string().min(1).describe("Parameter display name or match name."),
+            value: z.union([z.number(), z.array(z.number()), z.string()]).describe("Number, [r,g,b] 0–1 array, or hex color like #ff8800."),
+        },
+    }, async ({ compId: id, layerIndex: li, style, param, value }) => run(setLayerStyleParamScript(id, li, style, param, value)));
+    server.registerTool("ae_remove_layer_style", {
+        title: "After Effects: turn off a layer style",
+        description: "Turn a layer style off (its visible effect goes away). After Effects keeps a permanent slot per style, " +
+            "so this disables the style rather than deleting the slot; ae_add_layer_style turns it back on.",
+        inputSchema: { compId, layerIndex, style: styleName },
+        annotations: { destructiveHint: true },
+    }, async ({ compId: id, layerIndex: li, style }) => run(removeLayerStyleScript(id, li, style)));
     server.registerTool("ae_set_text", {
         title: "After Effects: set text layer content and style",
         description: "Change a text layer's text, font size, font (PostScript name), color, or justification.",