fablecut 1.14.0 → 1.15.0

package/mcp-server.js

@@ -7,11 +7,11 @@
    or, from a clone:
      claude mcp add -s user fablecut -- node "<path-to>/fablecut/mcp-server.js"
 
-   Tools: fablecut_status, fablecut_docs, fablecut_get_project,
-          fablecut_set_project, fablecut_patch_project, fablecut_import_media,
-          fablecut_analyze_reference, fablecut_encode_profiles,
-          fablecut_normalize_audio, fablecut_auto_duck, fablecut_export,
-          fablecut_scopes
+    Tools: fablecut_status, fablecut_docs, fablecut_get_project,
+           fablecut_set_project, fablecut_patch_project, fablecut_import_media,
+           fablecut_analyze_reference, fablecut_frame, fablecut_encode_profiles,
+           fablecut_normalize_audio, fablecut_auto_duck, fablecut_export,
+           fablecut_scopes
    ═══════════════════════════════════════════════════════════════════════════ */
 "use strict";
 const fs = require("fs");
@@ -21,18 +21,23 @@ const { spawn, spawnSync } = require("child_process");
 const { loadEncodeProfiles, listProfilesPublic, resolveProfile, profileSummary } = require("./encode-profiles");
 
 const {
-  APP_DIR, DATA_DIR, MEDIA_DIR, EXPORTS_DIR, ANALYSIS_DIR, LIBRARY_DIR, PROJECT_FILE, ensureDirs, readSaved, writeSaved,
+  APP_DIR, DATA_DIR, MEDIA_DIR, EXPORTS_DIR, ANALYSIS_DIR, LIBRARY_DIR, PROJECT_FILE, PROXIES_DIR, ensureDirs, readSaved, writeSaved,
 } = require("./paths");
 const { downloadImportUrl, kindFromName, maybeFaststart } = require("./import-url");
 const FX = require("./audio-fx");
 const EditOps = require("./edit-ops");
+const ProjectOps = require("./project-ops");
 const Denoise = require("./denoise");
 const Color = require("./color");
+const FrameStats = require("./frame-stats");
 const Mask = require("./mask");
 const Tracker = require("./tracker");
 const Motion = require("./motion");
 const CompLib = require("./comp");
 const Templates = require("./templates");
+const Delivery = require("./delivery");
+const { probeFile, infoForEntry } = require("./media-probe");
+const { findProxies } = require("./proxy");
 /** The user's saved presets / templates (library/presets, library/templates), validated; bad files skipped. */
 const savedItems = (kind) => readSaved(kind).map((x) => (kind === "presets" ? Templates.normalizePreset(x.data) : Templates.normalizeTemplate(x.data))).filter(Boolean);
 
@@ -77,10 +82,11 @@ function httpOk(url) {
     req.setTimeout(1200, () => { req.destroy(); resolve(false); });
   });
 }
-/** JSON request to the editor server → {status, body}. */
-function apiJSON(method, urlPath, payload) {
+/** JSON request to the editor server → {status, body}. Extra headers are for
+ *  endpoints that gate on them — /api/frame?path= needs X-FableCut-Client. */
+function apiJSON(method, urlPath, payload, headers) {
   return new Promise((resolve, reject) => {
-    const req = http.request(API + urlPath, { method, headers: { "Content-Type": "application/json" } }, (r) => {
+    const req = http.request(API + urlPath, { method, headers: { "Content-Type": "application/json", ...headers } }, (r) => {
       let data = "";
       r.setEncoding("utf8");
       r.on("data", (d) => { data += d; });
@@ -97,6 +103,11 @@ function apiJSON(method, urlPath, payload) {
 }
 async function ensureUIServer() {
   if (await httpOk(API + "/api/project")) return true;
+  /* Tests (and nothing else) may set FABLECUT_NO_AUTOSTART=1: the auto-start
+     below spawns a detached server.js the test harness cannot stop — it
+     inherits the test's port and data dir and keeps running after the test.
+     With the flag set, report the missing server instead of starting one. */
+  if (process.env.FABLECUT_NO_AUTOSTART === "1") return false;
   spawn(process.execPath, [path.join(ROOT, "server.js")],
     { cwd: ROOT, detached: true, stdio: "ignore" }).unref();
   for (let i = 0; i < 12; i++) {
@@ -146,7 +157,7 @@ const TOOLS = [
   },
   {
     name: "fablecut_patch_project",
-    description: "Apply targeted edits to the FableCut project WITHOUT round-tripping the whole document — PREFER THIS over get+set for every edit (it is ~10-100x cheaper in tokens and merge-safe by design: it re-reads the latest document from disk, applies your ops in order, bumps revision once, saves atomically). Ops: {op:'addClip', clip:{…}} (id auto-generated if omitted) · {op:'updateClip', id, set:{…}} · {op:'removeClip', id} · {op:'addMedia', media:{…}} · {op:'removeMedia', id} · {op:'setProject', set:{name|width|height|fps|background|markers|disabledTracks|lockedTracks|untargetedTracks|encodeProfile|master}} (markers = the full list [{t, label?, color?}], color: gold|red|orange|green|cyan|blue|purple|pink; master = {gain}, the master fader in dB) · {op:'setTrack', id:'A1', set:{gain?, pan?, out?}} (audio-track fader in dB −60…+12, pan −1…1, out = a submix bus id or 'master'; null or 0 resets) · {op:'setBus', id:'B1', set:{name?, gain?, pan?, mute?}} (submix bus, created if missing; route tracks into it with setTrack out) · {op:'removeBus', id} · {op:'setFx', target:'clip'|'track'|'bus'|'master', id?, preset?:'podcast'|… OR fx:[{type,…params}], append?:true} (audio effects — validated; presets: clean-voice, podcast, radio, deep-voice, telephone, cinematic, wide, muffled; fx:null clears; on a clip it applies to its linked stems too) · {op:'setFxKeys', target, id?, index?|type?, param, keys:[{t, v, ease?}]|null} (automate one effect parameter: t is clip-local for a clip's effects, timeline seconds otherwise; see the 'Audio mix' docs section) · {op:'setGrade', id | ids:[…], grade:{exposure?, temp?, tint?, lift?, gamma?, gain?, offset?, contrast?, pivot?, blacks?, shadows?, midtones?, highlights?, whites?, lowSoft?, highSoft?, saturation?, curves?:{y?, r?, g?, b?}, hueHue?, hueSat?, hueLuma?, satLuma?, layers?:[…], on?}, replace?:true} (color grade on video / image / svg / adjust clips — wheels are [r, g, b, master]; curves are [[x, y], …] point lists on 0…1 and merge per channel; hue curves are [[hue°, value], …] — one point = a ±40° band; layers replaces the whole layer list; merges key by key, null resets a key, replace:true starts from neutral, grade:null clears; see the 'Color' docs section; measure the result with fablecut_scopes) · {op:'setGradeLayer', id | ids, layer: index | 'name', set:{name?, on?, qualifier?:{hue?:[centre°, width°, soft°], sat?:[lo, hi, soft], luma?:[lo, hi, soft], invert?}, mask?:{shape:'ellipse'|'rect'|'poly', x, y, w, h, rotation?, feather?, invert?, points?, keys?:[{t, x?, y?, …}]}, …any grade key}, replace?:true, remove?:true} (a secondary: a grade applied only where the qualifier × mask select; a new name or index = length adds a layer; qualifier and mask merge key by key; check what it selects with fablecut_scopes matte:{clip, layer}) · {op:'setMask', id | ids, mask?: index | 'name', set:{shape?:'rect'|'ellipse'|'bezier'|'freehand', mode?:'add'|'subtract'|'intersect'|'difference', invert?, opacity?, feather? (px), expand? (px, − shrinks), x?, y? (centre, 0…1 of the clip's picture), w?, h?, scale?, rotation?, points?:[[dx, dy, inX?, inY?, outX?, outY?], …] (bezier, around x, y), stroke?:[[u, v], …] (freehand: fitted into a bezier), keys?:[{t, ease?, x?, y?, w?, h?, scale?, rotation?, feather?, expand?, opacity?, points?}], name?, on?}, replace?:true, remove?:true} (clip masks on video / image / svg / text / adjust clips: the clip shows only where its masks combine to, bottom-up; mask left out, an unknown name or index = length adds one — a new mask needs shape; set merges key by key; masks follow the clip's transform; check with fablecut_scopes mask:{clip}) · {op:'removeMask', id, mask} · {op:'setMaskKeys', id, mask, keys:[…]|null} (animate a mask; t = seconds from the clip's start) · {op:'setMatte', id | ids, matte:'alpha'|'alpha-inverted'|'luma'|'luma-inverted'|null, track?:'V3'|null} (track matte: the picture on the video track directly above — or track — cuts the clip by its alpha or its brightness, inverted or not; that track stops drawing while it is a matte; null clears). · {op:'removeTrack', id, track: name | index} (delete a motion track stored by fablecut_track; what follows it keeps its keys). MOTION GRAPHICS: a shape layer is addClip {kind:'shape', track, start, duration, props:{shapes:[…]}} (no mediaId); a null is addClip {kind:'null', …} — invisible, a parent for other clips. {op:'setShape', id | ids, shape?: index | 'name' | '2.0' (path into a group), set:{type?:'rect'|'ellipse'|'polygon'|'star'|'line'|'path'|'group', name?, on?, x?, y? (px from the layer's origin), rotation?, scale?, opacity?, w?, h?, radius? (rect corners), sides?, inner? (star 0.05…1), points?:[[x, y, inX?, inY?, outX?, outY?], …] (line: 2, path: 2…128, px around x, y), closed? (path), fill?, stroke? ('#rrggbb' | '#rrggbbaa' | 'none'), strokeWidth?, lineCap?, lineJoin?, dash?:[on, off…], trimStart?, trimEnd? (0…100 — a draw-on), trimOffset?, items?:[…] (group), keys?:[{t, ease?, …any of x y rotation scale opacity w h radius inner strokeWidth trimStart trimEnd trimOffset fill stroke points}]}, replace?:true, remove?:true} (shape left out, an unknown name or index = length adds one — a new shape needs type; set merges key by key) · {op:'removeShape', id, shape} · {op:'setParent', id | ids, parent: clip id | null, keep?: true, at?} (the clip moves, turns and scales with its parent; keep:true — the default — keeps it where it is at time at, default its start; opacity and effects are not inherited). COMPOSITIONS (nested sequences): project.comps = [{id, name, width, height, duration, background?, tracks?, clips:[…]}]; a clip {kind:'comp', compId, start, in, duration} places one (draws like a picture of the comp's size — transform, masks, grade, blend, blur all apply — and its media plays and exports). {op:'addComp', comp:{id?, name, duration, width?, height?, background?, clips?:[…]}} · {op:'updateComp', id, set:{name?, width?, height?, duration?, background?, tracks?}} · {op:'removeComp', id} (refused while used) · {op:'precompose', ids:[…], name?, id?} (the clips move into a new comp; a comp clip takes their place) · {op:'inComp', comp, ops:[…]} (run clip and timeline ops on the comp's own clips — addClip, updateClip, setShape, split, …; nests). PRESETS AND TEMPLATES: {op:'applyPreset', id | ids, preset, length?, at?} keys a named animation onto visual clips, relative to where they sit (in: fade-in, pop-in, slide-up-in, slide-down-in, slide-left-in, slide-right-in, drop-in, zoom-in, spin-in, whip-in, rise-blur, draw-on · out: fade-out, pop-out, slide-up-out, slide-down-out, slide-left-out, slide-right-out, zoom-out, spin-out, whip-out, sink-blur, draw-off · at (an emphasis at timeline time at): pulse, shake, wobble, bounce, flash · loop (the whole clip): float, breathe, sway, spin, wiggle — or a saved one, or an inline {anchor:'in'|'out'|'at'|'whole', length, keys:{channel:[{t, v, ease?}]}} where scale / opacity multiply and the rest add). {op:'addTemplate', template, start?, track?, duration?, fields?:{key: value}, id?, compId?, name?} places a template as its own comp + a comp clip (lower-third-bar, lower-third-underline, lower-third-boxes [name, title, accent…] · logo-ring, logo-slam, logo-lines [logo = a media id, brand / tagline, accent] · social-story 1080x1920, social-quote 1080x1080, social-end-card [text fields, accent, background]); {op:'setTemplate', id: its clip or comp, fields?, duration?} changes the fields or the length (the exit keeps its timing). {op:'savePreset', id, name, anchor?} / {op:'saveTemplate', comp, name?, fields?} save to library/presets and library/templates for every project.MOTION PATHS: x and y keyed at the same time are a position key; curve handles pin / pout (px) on those x and y keys bend the path between keys ({op:'setMotionPath', id | ids, path:'smooth'|'straight', autoOrient?:bool} sets them for you; props.autoOrient turns the clip along its path). props.motionBlur = shutter angle 0…720 (180 = film look), props.motionBlurSamples 2…32. TEXT ON A PATH: {op:'setTextPath', id | ids, path:'line'|'arc'|'circle'|'wave'|{type:'path'|'line'|'ellipse'|'rect'|'polygon'|'star', …shape item geometry, keys?}|null, offset? (% along, keyable as pathOffset), align?:'start'|'center'|'end'} — the title runs along the path (more lines on parallel curves below it), every textAnim plays along it. Every visual clip also has props.anchorX / anchorY (px from its picture's centre: the point x / y place and rotation / scale turn around) and shape clips props.trimStart / trimEnd / trimOffset (trim every path in the layer) — all keyframable. props.blend: normal · multiply · screen · overlay · darken · lighten · color-dodge · color-burn · hard-light · soft-light · difference · exclusion · hue · saturation · color · luminosity · lighter. TIMELINE EDITS — the editor's own split / ripple / trim code, so linked stems, track targeting (untargetedTracks) and locks behave exactly as in the UI; times in seconds: {op:'split', at, ids?} (no ids: every targeted track) · {op:'rippleDelete', ids} (later clips close the hole) · {op:'closeGap', at} · {op:'lift'|'extract', from?, to?} (remove a range; extract closes it; default = project inPoint/outPoint, which then clear) · {op:'insert'|'overwrite', mediaId, at, in?, duration?} (three-point edit: insert pushes later clips right, overwrite replaces what is there; a video brings one audio stem per channel) · {op:'rippleTrim'|'roll', id, side:'in'|'out', delta} · {op:'slip'|'slide', id, delta} (clamped to the media; the note says what was applied) · {op:'crossfade', ids? | at, duration?} (constant-power audio crossfade, borrowing handles from both sides). Any of these takes tracks:[…] to target lanes for that op only. setProject also takes inPoint / outPoint. updateClip merge rules: top-level keys are replaced (keyframes/transitionIn/transitionOut wholesale), `props` merges key-by-key, and setting any key to null deletes it. LOCKS: the user can lock clips (`locked:true`) and tracks (`lockedTracks`); updateClip / removeClip on a locked clip — or on a clip linked to one — and addClip onto a locked track are refused. Leave locked material alone; only if the user asked you to change it, pass force:true on that op (or unlock first: updateClip set:{locked:null}, which is always allowed). All-or-nothing: an invalid op aborts the whole patch unsaved. Optional baseRevision: the revision your ops were planned against (from fablecut_get_project, fablecut_status or the previous patch result) — if the project has moved past it (e.g. the user edited in the UI meanwhile), the patch is refused with CONFLICT and the current revision, nothing saved; re-check the clips you touch, then retry with the new revision. Omit it to apply on top of whatever is latest.",
+    description: "Apply targeted edits to the FableCut project WITHOUT round-tripping the whole document — PREFER THIS over get+set for every edit (it is ~10-100x cheaper in tokens and merge-safe by design: it re-reads the latest document from disk, applies your ops in order, bumps revision once, saves atomically). Ops: {op:'addClip', clip:{…}} (id auto-generated if omitted) · {op:'updateClip', id, set:{…}} · {op:'removeClip', id} · {op:'addMedia', media:{…}} · {op:'removeMedia', id} · MEDIA BIN: {op:'updateMedia', id | ids, set:{name?, favorite?:true|false, tags?:[…], folderId?}, addTags?:[…], removeTags?:[…]} (organize media; fps, codec, audio channels and size are probed from the file and read-only) · {op:'setCollection', id?, name?, media?:[…ids] (replaces), add?:[…], remove?:[…]} (a collection groups media across folders; a new id or name creates it) · {op:'removeCollection', id} · {op:'relinkMedia', id, src:'/media/…'} (the same footage found elsewhere — an OFFLINE file in the compact view; clips keep their In points) · {op:'replaceMedia', id, src, name?} (a different file behind the media — every clip using it switches, keeping its timing, trimmed to fit a shorter file; import the new file first with fablecut_import_media) · {op:'setProject', set:{name|width|height|fps|background|markers|disabledTracks|lockedTracks|untargetedTracks|encodeProfile|delivery|outputs|master}} (markers = the full list [{t, label?, color?}], color: gold|red|orange|green|cyan|blue|purple|pink; master = {gain}, the master fader in dB; delivery = a delivery preset id or spec — see fablecut_export — that exports use by default; outputs = the batch list, [preset id | spec, …] up to 16, exported together by fablecut_export {outputs:true}) · {op:'setTrack', id:'A1', set:{gain?, pan?, out?}} (audio-track fader in dB −60…+12, pan −1…1, out = a submix bus id or 'master'; null or 0 resets) · {op:'setBus', id:'B1', set:{name?, gain?, pan?, mute?}} (submix bus, created if missing; route tracks into it with setTrack out) · {op:'removeBus', id} · {op:'setFx', target:'clip'|'track'|'bus'|'master', id?, preset?:'podcast'|… OR fx:[{type,…params}], append?:true} (audio effects — validated; presets: clean-voice, podcast, radio, deep-voice, telephone, cinematic, wide, muffled; fx:null clears; on a clip it applies to its linked stems too) · {op:'setFxKeys', target, id?, index?|type?, param, keys:[{t, v, ease?}]|null} (automate one effect parameter: t is clip-local for a clip's effects, timeline seconds otherwise; see the 'Audio mix' docs section) · {op:'setGrade', id | ids:[…], grade:{exposure?, temp?, tint?, lift?, gamma?, gain?, offset?, contrast?, pivot?, blacks?, shadows?, midtones?, highlights?, whites?, lowSoft?, highSoft?, saturation?, curves?:{y?, r?, g?, b?}, hueHue?, hueSat?, hueLuma?, satLuma?, layers?:[…], on?}, replace?:true} (color grade on video / image / svg / adjust clips — wheels are [r, g, b, master]; curves are [[x, y], …] point lists on 0…1 and merge per channel; hue curves are [[hue°, value], …] — one point = a ±40° band; layers replaces the whole layer list; merges key by key, null resets a key, replace:true starts from neutral, grade:null clears; see the 'Color' docs section; measure the result with fablecut_scopes) · {op:'setGradeLayer', id | ids, layer: index | 'name', set:{name?, on?, qualifier?:{hue?:[centre°, width°, soft°], sat?:[lo, hi, soft], luma?:[lo, hi, soft], invert?}, mask?:{shape:'ellipse'|'rect'|'poly', x, y, w, h, rotation?, feather?, invert?, points?, keys?:[{t, x?, y?, …}]}, …any grade key}, replace?:true, remove?:true} (a secondary: a grade applied only where the qualifier × mask select; a new name or index = length adds a layer; qualifier and mask merge key by key; check what it selects with fablecut_scopes matte:{clip, layer}) · {op:'setMask', id | ids, mask?: index | 'name', set:{shape?:'rect'|'ellipse'|'bezier'|'freehand', mode?:'add'|'subtract'|'intersect'|'difference', invert?, opacity?, feather? (px), expand? (px, − shrinks), x?, y? (centre, 0…1 of the clip's picture), w?, h?, scale?, rotation?, points?:[[dx, dy, inX?, inY?, outX?, outY?], …] (bezier, around x, y), stroke?:[[u, v], …] (freehand: fitted into a bezier), keys?:[{t, ease?, x?, y?, w?, h?, scale?, rotation?, feather?, expand?, opacity?, points?}], name?, on?}, replace?:true, remove?:true} (clip masks on video / image / svg / text / adjust clips: the clip shows only where its masks combine to, bottom-up; mask left out, an unknown name or index = length adds one — a new mask needs shape; set merges key by key; masks follow the clip's transform; check with fablecut_scopes mask:{clip}) · {op:'removeMask', id, mask} · {op:'setMaskKeys', id, mask, keys:[…]|null} (animate a mask; t = seconds from the clip's start) · {op:'setMatte', id | ids, matte:'alpha'|'alpha-inverted'|'luma'|'luma-inverted'|null, track?:'V3'|null} (track matte: the picture on the video track directly above — or track — cuts the clip by its alpha or its brightness, inverted or not; that track stops drawing while it is a matte; null clears). · {op:'removeTrack', id, track: name | index} (delete a motion track stored by fablecut_track; what follows it keeps its keys). MOTION GRAPHICS: a shape layer is addClip {kind:'shape', track, start, duration, props:{shapes:[…]}} (no mediaId); a null is addClip {kind:'null', …} — invisible, a parent for other clips. {op:'setShape', id | ids, shape?: index | 'name' | '2.0' (path into a group), set:{type?:'rect'|'ellipse'|'polygon'|'star'|'line'|'path'|'group', name?, on?, x?, y? (px from the layer's origin), rotation?, scale?, opacity?, w?, h?, radius? (rect corners), sides?, inner? (star 0.05…1), points?:[[x, y, inX?, inY?, outX?, outY?], …] (line: 2, path: 2…128, px around x, y), closed? (path), fill?, stroke? ('#rrggbb' | '#rrggbbaa' | 'none'), strokeWidth?, lineCap?, lineJoin?, dash?:[on, off…], trimStart?, trimEnd? (0…100 — a draw-on), trimOffset?, items?:[…] (group), keys?:[{t, ease?, …any of x y rotation scale opacity w h radius inner strokeWidth trimStart trimEnd trimOffset fill stroke points}]}, replace?:true, remove?:true} (shape left out, an unknown name or index = length adds one — a new shape needs type; set merges key by key) · {op:'removeShape', id, shape} · {op:'setParent', id | ids, parent: clip id | null, keep?: true, at?} (the clip moves, turns and scales with its parent; keep:true — the default — keeps it where it is at time at, default its start; opacity and effects are not inherited). COMPOSITIONS (nested sequences): project.comps = [{id, name, width, height, duration, background?, tracks?, clips:[…]}]; a clip {kind:'comp', compId, start, in, duration} places one (draws like a picture of the comp's size — transform, masks, grade, blend, blur all apply — and its media plays and exports). {op:'addComp', comp:{id?, name, duration, width?, height?, background?, clips?:[…]}} · {op:'updateComp', id, set:{name?, width?, height?, duration?, background?, tracks?}} · {op:'removeComp', id} (refused while used) · {op:'precompose', ids:[…], name?, id?} (the clips move into a new comp; a comp clip takes their place) · {op:'inComp', comp, ops:[…]} (run clip and timeline ops on the comp's own clips — addClip, updateClip, setShape, split, …; nests). PRESETS AND TEMPLATES: {op:'applyPreset', id | ids, preset, length?, at?} keys a named animation onto visual clips, relative to where they sit (in: fade-in, pop-in, slide-up-in, slide-down-in, slide-left-in, slide-right-in, drop-in, zoom-in, spin-in, whip-in, rise-blur, draw-on · out: fade-out, pop-out, slide-up-out, slide-down-out, slide-left-out, slide-right-out, zoom-out, spin-out, whip-out, sink-blur, draw-off · at (an emphasis at timeline time at): pulse, shake, wobble, bounce, flash · loop (the whole clip): float, breathe, sway, spin, wiggle — or a saved one, or an inline {anchor:'in'|'out'|'at'|'whole', length, keys:{channel:[{t, v, ease?}]}} where scale / opacity multiply and the rest add). {op:'addTemplate', template, start?, track?, duration?, fields?:{key: value}, id?, compId?, name?} places a template as its own comp + a comp clip (lower-third-bar, lower-third-underline, lower-third-boxes [name, title, accent…] · logo-ring, logo-slam, logo-lines [logo = a media id, brand / tagline, accent] · social-story 1080x1920, social-quote 1080x1080, social-end-card [text fields, accent, background]); {op:'setTemplate', id: its clip or comp, fields?, duration?} changes the fields or the length (the exit keeps its timing). {op:'savePreset', id, name, anchor?} / {op:'saveTemplate', comp, name?, fields?} save to library/presets and library/templates for every project.MOTION PATHS: x and y keyed at the same time are a position key; curve handles pin / pout (px) on those x and y keys bend the path between keys ({op:'setMotionPath', id | ids, path:'smooth'|'straight', autoOrient?:bool} sets them for you; props.autoOrient turns the clip along its path). props.motionBlur = shutter angle 0…720 (180 = film look), props.motionBlurSamples 2…32. TEXT ON A PATH: {op:'setTextPath', id | ids, path:'line'|'arc'|'circle'|'wave'|{type:'path'|'line'|'ellipse'|'rect'|'polygon'|'star', …shape item geometry, keys?}|null, offset? (% along, keyable as pathOffset), align?:'start'|'center'|'end'} — the title runs along the path (more lines on parallel curves below it), every textAnim plays along it. Every visual clip also has props.anchorX / anchorY (px from its picture's centre: the point x / y place and rotation / scale turn around) and shape clips props.trimStart / trimEnd / trimOffset (trim every path in the layer) — all keyframable. props.blend: normal · multiply · screen · overlay · darken · lighten · color-dodge · color-burn · hard-light · soft-light · difference · exclusion · hue · saturation · color · luminosity · lighter. TIMELINE EDITS — the editor's own split / ripple / trim code, so linked stems, track targeting (untargetedTracks) and locks behave exactly as in the UI; times in seconds: {op:'split', at, ids?} (no ids: every targeted track) · {op:'rippleDelete', ids} (later clips close the hole) · {op:'closeGap', at} · {op:'lift'|'extract', from?, to?} (remove a range; extract closes it; default = project inPoint/outPoint, which then clear) · {op:'insert'|'overwrite', mediaId, at, in?, duration?} (three-point edit: insert pushes later clips right, overwrite replaces what is there; a video brings one audio stem per channel) · {op:'rippleTrim'|'roll', id, side:'in'|'out', delta} · {op:'slip'|'slide', id, delta} (clamped to the media; the note says what was applied) · {op:'crossfade', ids? | at, duration?} (constant-power audio crossfade, borrowing handles from both sides). Any of these takes tracks:[…] to target lanes for that op only. setProject also takes inPoint / outPoint. updateClip merge rules: top-level keys are replaced (keyframes/transitionIn/transitionOut wholesale), `props` merges key-by-key, and setting any key to null deletes it. LOCKS: the user can lock clips (`locked:true`) and tracks (`lockedTracks`); updateClip / removeClip on a locked clip — or on a clip linked to one — and addClip onto a locked track are refused. Leave locked material alone; only if the user asked you to change it, pass force:true on that op (or unlock first: updateClip set:{locked:null}, which is always allowed). All-or-nothing: an invalid op aborts the whole patch unsaved. Optional baseRevision: the revision your ops were planned against (from fablecut_get_project, fablecut_status or the previous patch result) — if the project has moved past it (e.g. the user edited in the UI meanwhile), the patch is refused with CONFLICT and the current revision, nothing saved; re-check the clips you touch, then retry with the new revision. Omit it to apply on top of whatever is latest.",
     inputSchema: {
       type: "object",
       properties: {
@@ -175,6 +186,26 @@ const TOOLS = [
       required: ["project"],
     },
   },
+  {
+    name: "fablecut_frame",
+    description: "LOOK at the footage — returns an actual image, not just numbers. REQUIRES A VISION-CAPABLE MODEL: if you cannot read images, pass `text:true` instead (or skip this tool and use fablecut_analyze_reference). Three modes. (1) One frame of a source clip: pass `path` (an absolute file path, or a '/media/…' src — read where it lies, never copied) and `t` in seconds. (2) A contact sheet: pass `frames` (2–60) for one grid image with that many moments spread across the clip (`from`/`to` to survey part of it) — the cheap way to see what a whole clip holds. (3) With no `path`, `time` renders the COMPOSED TIMELINE at that moment through the editor's own compositor, graded and multi-track, exactly as export would. Use it before choosing a clip's `in` point, or to pick footage matching a blueprint's shots[] energy — seeing beats guessing. Needs ffmpeg on PATH (timeline mode runs in the open editor tab, else a headless browser).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Source clip to look at: an absolute file path or a '/media/…' src. Read in place — nothing is copied into media/. Omit to render the timeline instead." },
+        t: { type: "number", description: "Seconds into the source clip (default 0). Ignored when `frames` is passed." },
+        time: { type: "number", description: "TIMELINE seconds to render, when `path` is omitted (default: the editor's playhead)" },
+        frames: { type: "number", description: "Contact-sheet mode: number of moments to sample across the clip, 2–60 (default 12)" },
+        cols: { type: "number", description: "Contact-sheet columns (omit for the squarest layout — 6 frames give 3×2, 12 give 4×3)" },
+        from: { type: "number", description: "Contact sheet: start of the range to survey (default 0)" },
+        to: { type: "number", description: "Contact sheet: end of the range (default: the clip's duration)" },
+        width: { type: "number", description: "Pixel width of the returned image (default 768 for one frame, 320 per cell for a sheet)" },
+        text: { type: "boolean", description: "Return TEXT measurements instead of the image, for a client or model that cannot see one: brightness and luma levels, dominant named colours with their share, texture (detail within the frame, 0–100), and for a contact sheet a per-cell line with change-since-the-previous-cell. Measurements, NOT a caption — they say what the picture is made of, never what is in it. Use when you have no vision." },
+        where: { type: "string", enum: ["auto", "tab", "headless"], description: "Timeline mode only: auto (default): an open editor tab, else headless · tab · headless" },
+        timeout: { type: "number", description: "Timeline mode: seconds to wait for the render (default 60)" },
+      },
+    },
+  },
   {
     name: "fablecut_analyze_reference",
     description: "Analyze a reference video into an EDIT BLUEPRINT so a similar edit can be rebuilt with different footage over the same music. Returns: shot boundaries (cuts) with per-shot audio energy, music beats + BPM, a loudness curve, the detected drop, and extracts the reference's music track into media/ (registered in the project, ready to place on A1). Remake recipe: copy the reference's width/height/fps to the project, write `beats` into project `markers`, lay the extracted music on A1, then place one clip per blueprint `shot` at the same start/duration — pick calm footage for low-energy shots and action for high-energy ones, and make the biggest moment land on `drop`. See the 'Remake a reference video' section of fablecut_docs.",
@@ -199,12 +230,13 @@ const TOOLS = [
   },
   {
     name: "fablecut_encode_profiles",
-    description: "List ffmpeg encoding profiles for Fast export (from encoding-profiles.json). Each profile is a raw ffmpeg argument list plus jpegQuality, extension, and optional color (output matrix/range — default BT.709 tv). Use to pick a profile id for project.encodeProfile. Edit encoding-profiles.json on disk to add custom profiles — anything the local ffmpeg supports works, and the server hot-reloads the file. Profiles are dry-run against ffmpeg when an export starts, so a bad argument is rejected before rendering.",
+    description: "List what fablecut_export can make. DELIVERY PRESETS (structured settings, the Export dialog's Preset list): youtube, youtube-shorts, instagram-reels, tiktok, x, linkedin, master (project size), broadcast (ProRes 422 HQ), web (720p), archive (lossless FFV1), custom — plus presets the user saved — each a spec of resolution, fps, codec (h264, hevc, av1, vp9, prores, dnxhr, mpeg2 XDCAM, ffv1), rate control (crf / vbr / cbr), keyframe interval, pixel format, color, container, audio, a file-name template and metadata. {preset:'youtube'} returns one preset's full spec; the encoders this ffmpeg can use are listed (hardware ones only when they work on this machine). ENCODING PROFILES (encoding-profiles.json): raw ffmpeg argument lists plus jpegQuality, extension and color, for anything the presets do not cover; edit the file on disk (hot-reloaded); {profile:'hq'} returns one, detail:true includes every args array. Both are dry-run against ffmpeg when an export starts, so bad settings are refused before rendering.",
     inputSchema: {
       type: "object",
       properties: {
-        detail: { type: "boolean", description: "Include the full ffmpeg args array per profile (default: a truncated summary)" },
-        profile: { type: "string", description: "Return one profile by id instead of the full list" },
+        detail: { type: "boolean", description: "Include the full ffmpeg args array per encoding profile (default: a truncated summary)" },
+        profile: { type: "string", description: "Return one encoding profile by id instead of the full list" },
+        preset: { type: "string", description: "Return one delivery preset's full spec (youtube, broadcast, a saved preset id …)" },
       },
     },
   },
@@ -252,6 +284,21 @@ const TOOLS = [
       required: ["clipIds"],
     },
   },
+  {
+    name: "fablecut_proxy",
+    description: "Proxies: light H.264 copies (540p by default, 720p or 1080p; never larger than the source) of heavy footage — 4K, HEVC, ProRes, long phone clips — that the editor plays while the user edits, so playback and scrubbing stay smooth. Export, fablecut_frame, fablecut_scopes and every measurement always read the original, so a proxy never changes the result. Without create or delete it reports each video's proxy (ready, being made with its progress, failed, none). create:true makes them (one at a time, in the background on the server) and waits until they are done unless wait:false; delete:true removes them. mediaIds defaults to every video in the project. The user turns proxy playback on or off with the monitor's Proxy button. Needs ffmpeg on PATH.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mediaIds: { type: "array", items: { type: "string" }, description: "Video media ids (default: all video media)" },
+        create: { type: "boolean", description: "Make proxies for these files" },
+        delete: { type: "boolean", description: "Delete their proxies" },
+        height: { type: "number", enum: [540, 720, 1080], description: "Proxy height in pixels (default 540)" },
+        wait: { type: "boolean", description: "With create: wait until every proxy is done (default true)" },
+        timeout: { type: "number", description: "Seconds to wait with create (default 900)" },
+      },
+    },
+  },
   {
     name: "fablecut_export",
     description: "Render the timeline to a video file in exports/ — the editor's own Fast export (same compositor, audio mix and encoding profile as the Export button), so the file matches what the user sees. It runs in a browser: an open editor tab takes the job (the user sees the progress bar), or with no tab open the server starts headless Chrome / Edge (set FABLECUT_CHROME to pick one) and closes it afterwards. Waits for the file by default and returns its path. Range: the project's inPoint→outPoint when set, else the whole timeline (or pass range). Needs ffmpeg on PATH. One export at a time. Long edits: pass wait:false, then poll with {job}; {cancel:job} stops one.",
@@ -259,7 +306,10 @@ const TOOLS = [
       type: "object",
       properties: {
         range: { type: "string", enum: ["entire", "in-out"], description: "Whole timeline, or the project's inPoint→outPoint (default: in-out when either is set)" },
-        profile: { type: "string", description: "Encoding profile id (fablecut_encode_profiles); default: project.encodeProfile, else the server default" },
+        preset: { type: "string", description: "Delivery preset: youtube, youtube-shorts, instagram-reels, tiktok, x, linkedin, master, broadcast, web, archive, custom, or a saved preset's id (fablecut_encode_profiles lists them). The output is reframed to the preset's size — cropped from the middle (or from the project's exportFrame), or padded with reframe:'fit'" },
+        delivery: { type: "object", description: "Delivery settings over the preset (or over custom): {width, height (null = the picture's size), fps (null = the project's), reframe:'fill'|'fit'|'stretch', container:'mp4'|'mov'|'mkv'|'webm'|'mxf', video:{codec:'h264'|'hevc'|'av1'|'vp9'|'prores'|'dnxhr'|'mpeg2'|'ffv1', encoder?, rate:'crf'|'vbr'|'cbr', crf, bitrate (kb/s), maxrate (kb/s), keyint (s), pixFmt, speed:'fast'|'balanced'|'best', profile (prores: proxy|lt|standard|hq|4444|4444xq · dnxhr: lb|sq|hq|hqx|444)}, audio:{codec:'aac'|'opus'|'mp3'|'pcm16'|'pcm24'|'flac'|'none', bitrate (kb/s), sampleRate, channels, loudness (LUFS target: -14 streaming/social, -16 podcast, -23 EBU R128, -24 ATSC; null = as mixed), truePeak (dBTP ceiling, default -1)}, color:'bt709'|'bt709-full'|'bt601-625'|'bt601-525', filename:'{project}_{preset}_{res}' (tokens {project} {preset} {res} {w} {h} {fps} {codec} {date} {time} {range} {n}), metadata:{title, artist, description, copyright, date, keywords}}. Anything left out comes from the preset; impossible combinations are corrected and the reply says how. Every finished file is checked against what was asked (size, fps, frames, codecs, length, loudness, true peak, file size) and the reply lists the checks" },
+        outputs: { description: "Several files, rendered once per frame rate (up to 8 outputs per render): true = the project's checked batch outputs (project.outputs, set with setProject {outputs:[…]}), or a list like [{preset:'master'}, {preset:'youtube'}, {preset:'instagram-reels'}, {preset:'custom', width:1080, height:1080, filename:'{project}_square_{res}'}, {preset:'web', filename:'{project}_preview_{res}'}]. Outputs with the same fps share one render; the reply lists every file", anyOf: [{ type: "boolean" }, { type: "array", items: { anyOf: [{ type: "string" }, { type: "object" }] } }] },
+        profile: { type: "string", description: "Encoding profile id (raw ffmpeg args, fablecut_encode_profiles) instead of a preset. With neither: project.delivery, else project.encodeProfile, else the server's default profile" },
         where: { type: "string", enum: ["auto", "tab", "headless"], description: "auto (default): an open editor tab, else headless · tab: only an open tab · headless: always a background browser, leaving the user's tab alone" },
         wait: { type: "boolean", description: "Block until the file is written (default true)" },
         timeout: { type: "number", description: "Seconds to wait before returning the job's status instead (default 900); the export keeps running" },
@@ -434,114 +484,6 @@ function normalizeGroups(proj, ids) {
   return [...groups.values()];
 }
 
-/* ── Timeline edits (patch ops split … crossfade) ──
-   The editor's own edit code (edit-ops.js) run against the document, so an
-   agent gets the same targeting (untargetedTracks, or the op's `tracks`), the
-   same sync lock (linked partners ride along) and the same lock rules as the
-   keyboard shortcuts. Returns a short note; throws to abort the patch. */
-const relinkedDocs = new WeakSet();
-function timelineEdit(proj, op, refuseLocked, lockReason) {
-  const name = op.op;
-  const E = EditOps.forDoc(proj, { tracks: op.tracks, force: op.force === true, uid: () => uid() });
-  // Links are rebuilt from timing on every editor load; do the same once per
-  // patch so clips an agent added (without linkGroup) ride along with their stems.
-  if (!relinkedDocs.has(proj)) { E.relinkClips(); relinkedDocs.add(proj); }
-  const r3 = (n) => Math.round(n * 1000) / 1000;
-  const signed = (n) => (n > 0 ? "+" : "") + r3(n);
-  const num = (v, what) => {
-    if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`${name}: ${what} must be a number (seconds)`);
-    return v;
-  };
-  const clipOf = (id) => {
-    const c = proj.clips.find((x) => x.id === id);
-    if (!c) throw new Error(`${name}: no clip ${id}`);
-    return c;
-  };
-  const named = () => {
-    if (!Array.isArray(op.ids) || !op.ids.length) throw new Error(`${name}: ids must list at least one clip`);
-    const clips = op.ids.map(String).map(clipOf);
-    for (const c of clips) refuseLocked(name, lockReason(c), op);
-    return clips;
-  };
-  const refused = (why) => new Error(`${name}: ${why}` +
-    (/locked/i.test(why) ? " — the user locked it; pass force:true only if they asked" : ""));
-  const trimmed = (c, r, extra = "") => {
-    if (typeof r === "string") throw refused(r);
-    const asked = num(op.delta, "delta");
-    return `${name} ${c.id}${extra} ${signed(r)}s` + (Math.abs(r - asked) > 1e-6 ? ` (asked ${signed(asked)}, clamped)` : "");
-  };
-  switch (name) {
-    case "split": {
-      const at = num(op.at, "at");
-      const r = E.splitAt(at, op.ids ? named() : null);
-      if (!r.split) throw refused(r.blocked ? "only locked clips under that time — left whole" : `no clip runs across ${at}s on the ${op.ids ? "given clips" : "targeted tracks"}`);
-      return `split@${at} +${r.rights.map((x) => x.id).join("+")}` + (r.blocked ? " (locked clips left whole)" : "");
-    }
-    case "rippleDelete": {
-      const r = E.rippleDelete(named());
-      return `-${r.removed.map((x) => x.id).join("-")} (rippled)`;
-    }
-    case "closeGap": {
-      const G = E.closeGapAt(num(op.at, "at"));
-      if (typeof G === "string") throw refused(G.replace("at playhead", `at ${op.at}s`).replace("move the playhead", "pick another time"));
-      return `closed ${r3(G)}s gap @${op.at}`;
-    }
-    case "lift": case "extract": {
-      const usePoints = op.from == null && op.to == null;
-      const t0 = op.from == null ? proj.inPoint : num(op.from, "from");
-      const t1 = op.to == null ? proj.outPoint : num(op.to, "to");
-      if (t0 == null || t1 == null) throw refused("give from and to (seconds), or set the project's inPoint and outPoint");
-      const why = E.liftRange(t0, t1, name === "extract");
-      if (why) throw refused(why.replace("Set IN and OUT first (I / O) to", "from→to must span more than a frame to"));
-      if (usePoints) { delete proj.inPoint; delete proj.outPoint; } // as in the editor
-      return `${name} ${r3(t0)}→${r3(t1)}s`;
-    }
-    case "rippleTrim": case "roll": {
-      const c = clipOf(String(op.id));
-      if (op.side !== "in" && op.side !== "out") throw new Error(`${name}: side must be "in" (head) or "out" (tail)`);
-      const fn = name === "roll" ? E.rollEdit : E.rippleTrim;
-      return trimmed(c, fn(c, op.side, num(op.delta, "delta")), "." + op.side);
-    }
-    case "slip": case "slide": {
-      const c = clipOf(String(op.id));
-      const fn = name === "slip" ? E.slipClip : E.slideClip;
-      return trimmed(c, fn(c, num(op.delta, "delta")));
-    }
-    case "insert": case "overwrite": {
-      const m = proj.media.find((x) => x.id === op.mediaId);
-      if (!m) throw new Error(`${name}: unknown mediaId ${op.mediaId}`);
-      const timed = m.kind === "video" || m.kind === "audio";
-      const inn = op.in == null ? 0 : num(op.in, "in");
-      if (inn < 0) throw new Error(`${name}: in must be ≥ 0`);
-      const dur = op.duration != null ? num(op.duration, "duration")
-        : timed && m.duration > 0 ? m.duration - inn : null;
-      if (dur == null) throw new Error(`${name}: duration is required for ${timed ? "media with no known duration yet" : m.kind}`);
-      if (!(dur >= EditOps.MIN_DUR)) throw new Error(`${name}: duration must be at least ${EditOps.MIN_DUR}s`);
-      if (timed && m.duration > 0 && inn + dur > m.duration + 1e-3)
-        throw new Error(`${name}: in + duration (${r3(inn + dur)}s) runs past the end of ${m.id} (${m.duration}s)`);
-      let stems = 2;
-      if (m.kind === "video") {
-        try { const f = mediaFile(m.src); if (f) stems = probeChannels(f) || 0; } catch { /* no ffprobe: assume stereo */ }
-      }
-      const r = (name === "insert" ? E.insertAt : E.overwriteAt)(m, timed ? inn : 0, dur, num(op.at, "at"), stems);
-      if (typeof r === "string") throw refused(r.replace(" — click a track name to target it (and unlock it)", " — every lane for it is untargeted or locked (pass tracks:[…])"));
-      const placed = r.clip ? (r.clip.linkGroup ? proj.clips.filter((x) => x.linkGroup === r.clip.linkGroup) : [r.clip]) : [];
-      return `${name}@${r3(r.at)} ` + placed.map((x) => `+${x.id}(${x.track})`).join("") + (name === "insert" ? ` · later clips moved +${r3(dur)}s` : "");
-    }
-    case "crossfade": {
-      const dur = op.duration == null ? EditOps.CROSSFADE_DUR : num(op.duration, "duration");
-      if (dur < EditOps.MIN_TRANS_DUR) throw new Error(`${name}: duration must be at least ${EditOps.MIN_TRANS_DUR}s`);
-      const pairs = op.ids ? E.crossfadeCuts(E.withLinked(named())) : E.crossfadeCutsNear(num(op.at, "at"));
-      if (!pairs.length) throw refused(op.ids ? "no audio cut next to those clips — they must touch or overlap on one track"
-        : `no audio cut within 0.5s of ${op.at}s on the targeted audio tracks`);
-      const { done, why } = E.crossfadePairs(pairs, dur);
-      if (!done) throw refused(why.join(", "));
-      return `crossfaded ${done} cut${done === 1 ? "" : "s"}` + (why.length ? ` (skipped: ${why.join(", ")})` : "");
-    }
-  }
-  throw new Error("Unknown edit op " + name);
-}
-
 /* ── Noise reduction (fablecut_denoise) — denoise.js, as the editor's Noise control ── */
 async function denoiseTool(args) {
   const ids = Array.isArray(args.clipIds) ? args.clipIds.map(String) : [];
@@ -602,20 +544,71 @@ async function denoiseTool(args) {
 }
 
 /* ── Export (fablecut_export) ── */
+/** Saved delivery presets (library/delivery/), as the server lists them. */
+function savedDeliveryPresets() { return Delivery.savedPresets(readSaved("delivery")); }
 function describeExportJob(j) {
   const pct = Math.round((j.progress || 0) * 100);
   if (j.status === "done") {
     const file = path.join(EXPORTS_DIR, path.basename(decodeURIComponent(j.src || "")));
     let size = "";
     try { size = ` (${(fs.statSync(file).size / 1048576).toFixed(1)} MB)`; } catch {}
-    return `Export ${j.id} done → ${file}${size}\nServed at ${BASE}${j.src}`;
+    const outs = j.result && Array.isArray(j.result.outputs) ? j.result.outputs : null;
+    if (outs && outs.length > 1) {
+      return `Export ${j.id} done — ${outs.filter((o) => o.ok).length} of ${outs.length} files:\n` + outs.map((o) => o.ok
+        ? `✓ ${path.join(EXPORTS_DIR, o.file)}${o.summary ? ` — ${o.summary}` : ""}${o.report ? `\n    ${o.report.ok ? "checks passed" : "CHECK"}: ${o.report.line}` : ""}`
+        : `✗ ${o.file}: ${o.error}`).join("\n");
+    }
+    const rep = outs && outs[0] && outs[0].report;
+    return `Export ${j.id} done → ${file}${size}${j.result && j.result.summary ? `\n${j.result.summary}` : ""}` +
+      `${rep ? `\n${rep.ok ? "Checks passed" : "CHECK"}: ${rep.line}` : ""}\nServed at ${BASE}${j.src}`;
   }
   if (j.status === "failed" || j.status === "cancelled") return `Export ${j.id} ${j.status}: ${j.error || "no reason given"}`;
   return `Export ${j.id} ${j.status}${j.status === "running" ? ` — ${pct}%` : ""} (in ${j.via === "headless" ? "a headless browser" : "the open editor tab"}). ` +
     `Check again with fablecut_export {job:"${j.id}"}, or stop it with {cancel:"${j.id}"}.`;
 }
+/* fablecut_proxy: the server makes proxies (proxy.js); this asks it, and waits. */
+async function proxyTool(args) {
+  if (!(await ensureUIServer())) throw new Error(`the editor server is not running and could not be started on port ${PORT}`);
+  const proj = readProject();
+  const ids = Array.isArray(args.mediaIds) && args.mediaIds.length ? args.mediaIds : proj.media.filter((m) => m.kind === "video").map((m) => m.id);
+  const list = ids.map((id) => {
+    const m = proj.media.find((x) => x.id === id);
+    if (!m) throw new Error(`no media ${id}`);
+    if (m.kind !== "video") throw new Error(`${id} is ${m.kind === "audio" || m.kind === "image" ? "an" : "a"} ${m.kind} — only video gets a proxy`);
+    return m;
+  });
+  if (!list.length) return "No video in the project.";
+  const srcs = list.map((m) => m.src);
+  if (args.delete) {
+    const r = await apiJSON("POST", "/api/proxy/delete", { srcs });
+    if (r.status !== 200) throw new Error(r.body?.error || "delete failed");
+    return list.map((m) => `${m.id} "${m.name}": ${r.body.deleted[m.src] ? "proxy deleted" : "had no proxy"}`).join("\n");
+  }
+  let r = await apiJSON("POST", args.create ? "/api/proxy" : "/api/proxy/status", { srcs, height: args.height });
+  if (r.status !== 200) throw new Error(r.body?.error || `proxy request failed (${r.status})`);
+  let status = r.body.status;
+  const busy = () => Object.values(status).some((s) => s && (s.state === "queued" || s.state === "running"));
+  if (args.create && args.wait !== false) {
+    const deadline = Date.now() + 1000 * (Number.isFinite(args.timeout) && args.timeout > 0 ? args.timeout : 900);
+    while (busy() && Date.now() < deadline) {
+      await sleep(1000);
+      r = await apiJSON("POST", "/api/proxy/status", { srcs });
+      if (r.status === 200) status = r.body.status;
+    }
+  }
+  const line = (m) => {
+    const s = status[m.src];
+    if (!s) return `${m.id} "${m.name}": OFFLINE — the file is missing`;
+    if (s.state === "ready") return `${m.id} "${m.name}": proxy ready — ${s.width ? s.width + "×" + s.height : s.height + "p"}, ${(s.size / 1048576).toFixed(1)} MB (${s.src})`;
+    if (s.state === "running" || s.state === "queued") return `${m.id} "${m.name}": proxy ${s.state}${s.state === "running" ? ` ${Math.round(s.progress * 100)}%` : ""} (${s.height}p)`;
+    if (s.state === "failed") return `${m.id} "${m.name}": proxy FAILED — ${s.error}`;
+    return `${m.id} "${m.name}": no proxy${m.height ? ` (source ${m.width}×${m.height})` : ""}`;
+  };
+  return list.map(line).join("\n") + (busy() ? "\nStill working — call fablecut_proxy again (without create) to check." : "");
+}
 async function exportTool(args) {
   if (!(await ensureUIServer())) throw new Error(`the editor server is not running and could not be started on port ${PORT}`);
+  let startNote = "";
   if (args.cancel) {
     const r = await apiJSON("POST", "/api/export/job/cancel?id=" + encodeURIComponent(args.cancel));
     if (r.status !== 200) throw new Error(r.body?.error || "cancel failed");
@@ -627,10 +620,11 @@ async function exportTool(args) {
     if (r.status !== 200) throw new Error(r.body?.error || "no such export job");
     job = r.body;
   } else {
-    const r = await apiJSON("POST", "/api/export/request", { range: args.range, profile: args.profile, where: args.where || "auto" });
+    const r = await apiJSON("POST", "/api/export/request", { range: args.range, profile: args.profile, preset: args.preset, delivery: args.delivery, outputs: args.outputs, where: args.where || "auto" });
     if (r.status !== 200) throw new Error(r.body?.error || `export request failed (${r.status})`);
     job = r.body;
-    if (args.wait === false) return describeExportJob(job);
+    if (job.notes && job.notes.length) startNote = `Settings adjusted: ${job.notes.join("; ")}\n`;
+    if (args.wait === false) return (job.delivery ? `Output: ${job.delivery}\n` : "") + startNote + describeExportJob(job);
   }
   const deadline = Date.now() + 1000 * (Number.isFinite(args.timeout) && args.timeout > 0 ? args.timeout : 900);
   while (job.status === "pending" || job.status === "running") {
@@ -641,32 +635,148 @@ async function exportTool(args) {
     if (r.status !== 200) throw new Error(r.body?.error || "lost track of the export job");
     job = r.body;
   }
-  return describeExportJob(job);
+  return startNote + describeExportJob(job);
 }
 
-/* ── Scopes (fablecut_scopes): one graded still, measured in the editor ── */
-function describeScopes(j) {
-  if (j.status !== "done") return `Scope reading ${j.id} ${j.status}${j.error ? ": " + j.error : ""}`;
-  const r = j.result || {}, st = r.stats;
-  if (!st) return `Frame at ${r.time}s is empty (nothing drawn).`;
-  const L = st.luma, cast = st.cast;
-  const lines = [
-    `Frame at ${r.time}s (${r.frame?.w}x${r.frame?.h}):`,
-    `  luma min ${L.min} · p1 ${L.p1} · median ${L.median} · mean ${L.mean} · p99 ${L.p99} · max ${L.max}`,
-    `  clipped: black ${st.clipped.blackPct}% · white ${st.clipped.whitePct}%`,
-    `  rgb mean [${st.rgbMean.join(", ")}] · saturation ${st.saturation}`,
-    `  cast: ${cast.tone === "neutral" ? "neutral" : `${cast.tone} (hue ${cast.hue}°)`} · strength ${cast.strength}`,
-    `On screen (bottom → top): ${(r.clips || []).map((c) => `${c.id} ${c.track} ${c.kind}${c.grade !== "neutral" ? " grade:" + c.grade : ""}${c.masks ? ` masks:[${c.masks}]` : ""}${c.matte ? ` matte:${c.matte}` : ""}${c.isMatte ? " (a matte — not drawn)" : ""}${c.blend ? " blend:" + c.blend : ""}`).join(" | ") || "nothing"}`,
-  ];
-  const m = r.matte;
-  if (m) {
-    lines.push(m.error ? `Matte ${m.clip} layer ${m.layer}: ${m.error}` : `Matte of ${m.clip} layer ${m.layer}: covers ${m.coverage}% of the clip's picture` +
-      (m.selected ? ` · selected pixels: luma median ${m.selected.luma.median} (p1 ${m.selected.luma.p1}, p99 ${m.selected.luma.p99}) · rgb mean [${m.selected.rgbMean.join(", ")}] · saturation ${m.selected.saturation} · cast ${m.selected.cast.tone === "neutral" ? "neutral" : `${m.selected.cast.tone} (hue ${m.selected.cast.hue}°)`}` : " · nothing selected"));
+/* ── Frames (fablecut_frame) ──
+   The tool is the only one that answers with an image, so it returns content
+   blocks rather than a string. Text comes FIRST: it carries the coordinates of
+   what is in the picture (src, timestamp, dimensions), which is the part an
+   agent would otherwise have to guess at, and it keeps the existing
+   content[0].text reading in the test harness valid. */
+
+/** {mimeType, data:Buffer} → an MCP image content block. */
+function imageBlock(mimeType, buf) {
+  return { type: "image", data: buf.toString("base64"), mimeType };
+}
+/** A data: URL from the compositor → an image content block, or null. */
+function imageBlockFromDataUrl(url) {
+  const m = /^data:(image\/\w+);base64,(.+)$/.exec(String(url || ""));
+  return m ? { type: "image", data: m[2], mimeType: m[1] } : null;
+}
+
+/** Raw GET to the editor server → {status, headers, buffer}.
+ *  Sends the MCP client header: /api/frame?path= only answers requests that
+ *  carry it, so a web page in the user's browser can neither render frames of
+ *  arbitrary files nor probe which ones exist. */
+function apiBytes(urlPath) {
+  return new Promise((resolve, reject) => {
+    const req = http.request(API + urlPath, { method: "GET", headers: { "X-FableCut-Client": "mcp" } }, (r) => {
+      const chunks = [];
+      r.on("data", (c) => chunks.push(c));
+      r.on("end", () => resolve({ status: r.statusCode, headers: r.headers, body: Buffer.concat(chunks) }));
+    });
+    req.on("error", reject);
+    req.setTimeout(60_000, () => req.destroy(new Error("the editor server did not answer")));
+    req.end();
+  });
+}
+
+async function frameTool(args) {
+  /* Timeline mode: no path. The compositor lives in the browser, so this rides
+     the same job queue the scopes reading uses, with image:true. Text mode
+     needs no image at all here — the scopes reading already measures the frame,
+     and those numbers describe the composed picture. */
+  if (!args.path) {
+    if (!(await ensureUIServer())) throw new Error(`the editor server is not running and could not be started on port ${PORT}`);
+    const body = { where: args.where || "auto", image: true };
+    if (args.time != null) body.time = args.time;
+    const r = await apiJSON("POST", "/api/scopes/request", body);
+    if (r.status !== 200) throw new Error(r.body?.error || `frame request failed (${r.status})`);
+    let job = r.body;
+    const deadline = Date.now() + 1000 * (Number.isFinite(args.timeout) && args.timeout > 0 ? args.timeout : 60);
+    while (job.status === "pending" || job.status === "running") {
+      if (Date.now() > deadline) {
+        await apiJSON("POST", "/api/export/job/cancel?id=" + encodeURIComponent(job.id));
+        throw new Error("timed out waiting for the editor to render the frame");
+      }
+      await sleep(300);
+      const q = await apiJSON("GET", "/api/export/job?id=" + encodeURIComponent(job.id));
+      if (q.status !== 200) throw new Error(q.body?.error || "lost track of the frame render");
+      job = q.body;
+    }
+    if (job.status !== "done") throw new Error(`frame render ${job.status}: ${job.error || "no reason given"}`);
+    const res = job.result || {};
+    const onScreen = (res.clips || []).map((c) => `${c.id} ${c.track} ${c.kind}`).join(", ") || "nothing";
+    const head = `Timeline at ${res.time}s (${res.frame?.w}x${res.frame?.h}) — on screen: ${onScreen}`;
+
+    /* Text mode: the scopes reading measured this exact frame already, and its
+       numbers are the same family as the source-frame measurements — so a
+       text-only agent gets the composed picture described, not nothing. */
+    if (args.text) {
+      const st = res.stats, st_ = st ? describeScopeLines(st) : null;
+      return [{ type: "text", text: head + "\n" + (st_ || "The editor returned no measurements for this frame.") + "\n\n" + TEXT_ONLY_NOTE }];
+    }
+    const img = imageBlockFromDataUrl(res.image);
+    if (!img) throw new Error("the editor rendered the frame but could not encode it as an image (a cross-origin source taints the canvas)");
+    return [{ type: "text", text: head }, img];
+  }
+
+  /* Source mode: ffmpeg on the server. Looking must not have side effects, so
+     the file is read where it is — an absolute path is passed through as
+     `path`, and a /media/… or /library/… src is passed through as `src`. The
+     server never copies anything into media/ on our behalf. */
+  if (!(await ensureUIServer())) throw new Error(`the editor server is not running and could not be started on port ${PORT}`);
+  const raw = String(args.path);
+  const served = /^\/(media|library)\//i.test(raw);
+  // A served src is resolved by the server against its own data dir, which may
+  // be somewhere this process cannot see (FABLECUT_DATA_DIR) — so let it decide
+  // and report the 404. A filesystem path we can check ourselves is checked.
+  if (!served && (!fs.existsSync(raw) || !fs.statSync(raw).isFile()))
+    throw new Error("File not found: " + raw);
+
+  const q = new URLSearchParams(served ? { src: raw } : { path: path.resolve(raw) });
+  if (args.frames != null) {
+    q.set("frames", String(Math.round(Number(args.frames))));
+    // No cols → the server picks the squarest layout (6 frames give 3×2).
+    if (args.cols != null) q.set("cols", String(Math.round(Number(args.cols))));
+    if (args.from != null) q.set("from", String(args.from));
+    if (args.to != null) q.set("to", String(args.to));
+    q.set("w", String(args.width || 320));
+  } else {
+    q.set("t", String(Number.isFinite(args.t) ? args.t : 0));
+    q.set("w", String(args.width || 768));
+  }
+  if (args.quality != null) q.set("q", String(args.quality));
+
+  /* text mode asks the server for measurements instead of the picture, in the
+     one request — not the picture and then a second call for the numbers. */
+  if (args.text) {
+    q.set("text", "1");
+    const j = await apiJSON("GET", "/api/frame?" + q.toString(), undefined, { "X-FableCut-Client": "mcp" });
+    if (j.status !== 200) throw new Error(j.body?.error || `frame description failed (${j.status})`);
+    const st = j.body.stats, b = j.body;
+    const where = b.frames > 1
+      ? `${b.frames} moments across ${b.source || raw}, left→right then top→bottom, at ${(b.times || []).join("s, ")}s.`
+      : `Frame at ${(b.times || [])[0] ?? 0}s of ${b.source || raw}.`;
+    const body = !st
+      ? "The server returned no measurements for this frame (does it have a video track?)."
+      : b.frames > 1 ? FrameStats.gridLines(st).join("\n") : FrameStats.frameLines("Frame", st).join("\n");
+    return [{ type: "text", text: where + "\n" + body + "\n\n" + TEXT_ONLY_NOTE }];
   }
-  const k = r.mask;
-  if (k) lines.push(k.error ? `Masks of ${k.clip}: ${k.error}` : `Masks of ${k.clip} (${k.masks}): keep ${k.coverage}% of the clip's picture · the masked clip covers ${k.frameCoverage}% of the frame`);
-  return lines.join("\n") + "\n" + JSON.stringify({ time: r.time, stats: st, ...(m ? { matte: m } : {}), ...(k ? { mask: k } : {}) });
+
+  const res = await apiBytes("/api/frame?" + q.toString());
+  if (res.status !== 200) {
+    let msg = `frame request failed (${res.status})`;
+    try { msg = JSON.parse(res.body.toString("utf8")).error || msg; } catch { /* not JSON */ }
+    throw new Error(msg);
+  }
+  const times = (res.headers["x-fablecut-frame-times"] || "").split(",").filter(Boolean);
+  const type = res.headers["content-type"] || "image/jpeg";
+  const source = decodeURI(res.headers["x-fablecut-frame-source"] || "") || raw;
+  const head = args.frames != null
+    ? `Contact sheet — ${times.length} moments across ${source}, left→right then top→bottom, at ${times.join("s, ")}s.`
+    : `Frame at ${times[0] ?? 0}s of ${source}.`;
+
+  if (res.body.length < 4 || res.body[0] !== 0xff || res.body[1] !== 0xd8)
+    throw new Error("the server did not return a JPEG");
+  return [{ type: "text", text: head }, imageBlock(type, res.body)];
 }
+
+/* Appended to every text: true answer, because a measurement is not a caption:
+   it says what the picture is made of, never what is in it. */
+const { TEXT_ONLY_NOTE, describeScopeLines, describeScopes } = ProjectOps;
+
 async function scopesTool(args) {
   if (!(await ensureUIServer())) throw new Error(`the editor server is not running and could not be started on port ${PORT}`);
   const body = { where: args.where || "auto" };
@@ -717,15 +827,7 @@ async function trackTool(args) {
     job = q.body;
   }
   if (job.status !== "done") throw new Error(`tracking ${job.status}: ${job.error || "no reason given"}`);
-  const t = job.result || {};
-  return [
-    t.tracked ? `Tracked ${t.clip} "${t.track}" (${t.kind}) ${t.from}–${t.to} s: ${t.samples} samples, match quality min ${t.quality.min} · mean ${t.quality.mean}`
-      : `Used the stored track "${t.track}" on ${t.clip} (${t.from}–${t.to} s, ${t.samples} samples)`,
-    t.lostAt && t.lostAt.length ? `Lost the region at ${t.lostAt.join(", ")} s — the track stops there (pick a spot with more detail, or a larger region, and track on from there)` : "",
-    t.cancelled ? "Cancelled — kept what was tracked so far." : "",
-    t.applied ? `Applied → ${t.applied}` : "Stored only (apply it with apply:{mask} or apply:{clip}).",
-    `Project revision ${t.revision}.`,
-  ].filter(Boolean).join("\n");
+  return ProjectOps.describeTrack(job.result || {});
 }
 
 /* ── Tool implementations ── */
@@ -737,8 +839,12 @@ async function callTool(name, args, attempt = 0) {
       return exportTool(args);
     case "fablecut_scopes":
       return scopesTool(args);
+    case "fablecut_frame":
+      return frameTool(args);
     case "fablecut_denoise":
       return denoiseTool(args);
+    case "fablecut_proxy":
+      return proxyTool(args);
     case "fablecut_status": {
       const up = await ensureUIServer();
       const proj = readProject();
@@ -769,11 +875,26 @@ async function callTool(name, args, attempt = 0) {
           encLine = `Export profile: ${describe(pinned || cfg.default) || `server default "${cfg.default}"`}`;
         }
       } catch { encLine = "Export profile: (encoding-profiles.json unavailable)"; }
+      if (proj.delivery) {
+        try {
+          const { spec } = Delivery.normalize(proj.delivery, { presets: savedDeliveryPresets() });
+          encLine = `Export: project.delivery — ${spec.preset} · ${Delivery.describe(spec)} (fablecut_export uses it unless you pass profile or preset)`;
+        } catch { }
+      }
+      if (Array.isArray(proj.outputs) && proj.outputs.length) {
+        const on = proj.outputs.filter((o) => o.on !== false);
+        encLine += `\nBatch outputs (fablecut_export {outputs:true}): ${on.length} of ${proj.outputs.length} checked — ` +
+          on.map((o) => Delivery.projectFilename(o, proj)).join(", ");
+      }
       return [
         `Editor server: ${up ? "RUNNING — open " + BASE + " in a browser to watch edits live" : "FAILED TO START (check node / port " + PORT + ")"}`,
         `Project: "${proj.name}" — ${proj.width}x${proj.height} @ ${proj.fps}fps, ${proj.clips.length} clip(s), ${dur.toFixed(2)}s, revision ${proj.revision}`,
         encLine,
         `Registered media: ${cap(proj.media.map((m) => `${m.id} (${m.kind}, ${m.name}${m.duration ? ", " + m.duration + "s" : ""})`), 25).join("; ") || "none"}`,
+        ...(() => {
+          const off = proj.media.filter((m) => /^\/(media|library)\//.test(m.src || "") && !mediaFile(m.src));
+          return off.length ? [`OFFLINE media (file missing — find it and relinkMedia): ${cap(off.map((m) => `${m.id} ${m.src}`), 25).join("; ")}`] : [];
+        })(),
         `Files in media/: ${cap(files, 25).join(", ") || "none"}`,
         `Library assets (./library): ${libSummary}`,
         `Project file: ${PROJECT_FILE}`,
@@ -794,106 +915,10 @@ async function callTool(name, args, attempt = 0) {
       const doc = readProject();
       lastReadRevision = doc.revision || 0;
       if (!args.compact) return JSON.stringify(doc);
-      // the UI persists default-valued props on every clip; hide them so the
-      // compact view only shows what actually deviates
-      const DEFAULTS = {
-        x: 0, y: 0, scale: 1, rotation: 0, opacity: 1, volume: 1, pan: 0, speed: 1,
-        gain: 0, channelMode: "stereo", duck: 0,
-        blend: "normal", fit: "contain", cropL: 0, cropR: 0, cropT: 0, cropB: 0,
-        cornerRadius: 0, flipH: false, flipV: false, filterPreset: "none",
-        brightness: 100, contrast: 100, saturation: 100, hue: 0, temperature: 0,
-        tint: 0, blur: 0, grayscale: 0, sepia: 0, invert: 0, vignette: 0,
-        shake: 0, shakeSpeed: 8, rgbSplit: 0, grain: 0,
-        chromaKey: "", chromaTolerance: 26, chromaSoftness: 12, bgRemove: false,
-        text: "Title", fontSize: 72, color: "#ffffff", color2: "", font: "Segoe UI",
-        bold: true, weight: 0, italic: false, uppercase: false, align: "center",
-        letterSpacing: 0, lineHeight: 1.2, textShadow: 12, glow: 0, glowColor: "",
-        strokeWidth: 0, strokeColor: "#000", bgColor: "#000", bgOpacity: 0,
-        textAnim: "none", wordRate: 0.15, direction: "auto", boxW: 0, boxH: 0, boxFit: false, vAlign: "middle",
-        anchorX: 0, anchorY: 0, trimStart: 0, trimEnd: 100, trimOffset: 0,
-        autoOrient: false, motionBlur: 0, motionBlurSamples: 8, pathOffset: 0, pathAlign: "start",
-      };
-      const hex = (v) => typeof v === "string" && /^#[0-9a-f]{3}$/i.test(v)
-        ? "#" + [...v.slice(1)].map((c) => c + c).join("").toLowerCase()
-        : (typeof v === "string" && /^#[0-9a-f]{6}$/i.test(v) ? v.toLowerCase() : v);
-      const fmtProps = (o, kind) => {
-        if (!o) return "";
-        const kept = {};
-        for (const [k, v] of Object.entries(o)) {
-          if (kind !== "text" && k === "text" && v === "Title") continue;
-          // Always keep pan on linked stems — pan:0 (center) is meaningful and
-          // must not be stripped, or agents rebuilding from compact can lose it.
-          if (k === "pan" && Number.isInteger(o.audioChannel) && o.audioChannel >= 0) {
-            kept[k] = v;
-            continue;
-          }
-          if (k === "masks" || k === "tracks" || k === "shapes" || k === "textPath") continue;   // summarized below — point lists and samples are long
-          if (hex(DEFAULTS[k]) !== hex(v)) kept[k] = v;
-        }
-        const masks = Mask.describe(Mask.normalizeMasks(o.masks)), tracks = Tracker.describe(Tracker.normalizeTracks(o.tracks));
-        const shapes = Motion.describe(Motion.normalizeShapes(o.shapes));
-        const tp = o.textPath && Motion.normalizeTextPath(o.textPath);
-        if (tp) kept.textPath = tp.type + (tp.points ? `(${tp.points.length})` : tp.w ? ` ${tp.w}×${tp.h}` : "");
-        return (Object.keys(kept).length ? " " + JSON.stringify(kept) : "") + (shapes ? ` [${shapes}]` : "") + (masks ? ` [${masks}]` : "") + (tracks ? ` [tracks: ${tracks}]` : "");
-      };
-      // Mixer: only off-default faders / pans, so a fresh project adds no line.
-      const signed = (v) => (v > 0 ? "+" : "") + v;
-      const fxTag = (fx) => Array.isArray(fx) && fx.length ? ` fx:${FX.summarizeFx(fx)}` : "";
-      const mixLine = (d) => {
-        const parts = (Array.isArray(d.tracks) ? d.tracks : [])
-          .filter((t) => t && (+t.gain || +t.pan || t.fx?.length || t.out))
-          .map((t) => t.id + (t.out ? `→${t.out}` : "") + (+t.gain ? ` ${signed(+t.gain)}dB` : "") + (+t.pan ? ` pan:${+t.pan}` : "") + fxTag(t.fx));
-        for (const b of Array.isArray(d.buses) ? d.buses : [])
-          parts.push(`bus ${b.id}${b.name ? ` "${b.name}"` : ""}` + (+b.gain ? ` ${signed(+b.gain)}dB` : "") + (+b.pan ? ` pan:${+b.pan}` : "") +
-            (b.mute ? " muted" : "") + fxTag(b.fx));
-        if (d.master && (+d.master.gain || d.master.fx?.length))
-          parts.push("master" + (+d.master.gain ? ` ${signed(+d.master.gain)}dB` : "") + fxTag(d.master.fx));
-        return parts.length ? [`MIX: ${parts.join(" · ")}`] : [];
-      };
-      const lines = [
-        `"${doc.name}" ${doc.width}x${doc.height}@${doc.fps} rev:${doc.revision}` +
-        (doc.panSchema >= 1 ? " panSchema:1" : "") +
-        (doc.background ? ` bg:${doc.background}` : "") +
-        (doc.inPoint != null || doc.outPoint != null ? ` in/out:${doc.inPoint ?? "-"}→${doc.outPoint ?? "-"}` : "") +
-        (doc.markers?.length ? ` markers:${doc.markers.length} [${doc.markers.slice(0, 12).map((m) => m.t).join(",")}${doc.markers.length > 12 ? ",…" : ""}]` : "") +
-        (doc.lockedTracks?.length ? ` lockedTracks:[${doc.lockedTracks.join(",")}]` : "") +
-        (doc.untargetedTracks?.length ? ` untargetedTracks:[${doc.untargetedTracks.join(",")}]` : "") +
-        (doc.disabledTracks?.length ? ` disabledTracks:[${doc.disabledTracks.join(",")}]` : ""),
-        ...mixLine(doc),
-        `MEDIA (${doc.media.length}):`,
-        ...doc.media.map((m) => `  ${m.id} ${m.kind} "${m.name}"${m.duration ? " " + m.duration + "s" : ""}` +
-          (m.derivedFrom ? ` (${m.denoise ? "denoised " + m.denoise : "derived"} from ${m.derivedFrom})` : "")),
-        `CLIPS (${doc.clips.length}), by track/time:`,
-        ...doc.clips
-          .slice()
-          .sort((a, b) => (a.track === b.track ? a.start - b.start : String(a.track).localeCompare(b.track)))
-          .map((c) => {
-            const kf = c.keyframes ? " kf:" + Object.entries(c.keyframes).map(([k, v]) => `${k}(${v.length})`).join(",") +
-              (Motion.hasPathHandles(c) ? " path:curved" : "") : "";
-            const tr = (c.transitionIn ? ` in:${c.transitionIn.type}/${c.transitionIn.duration}` : "") +
-                       (c.transitionOut ? ` out:${c.transitionOut.type}/${c.transitionOut.duration}` : "");
-            const r3 = (n) => Math.round(n * 1000) / 1000;
-            return `  ${c.id} ${c.track} ${r3(c.start)}s+${r3(c.duration)}s ${c.kind}` +
-              (c.mediaId ? `(${c.mediaId}${c.in ? ` in:${r3(c.in)}` : ""})` : "") +
-              (c.kind === "comp" ? `(${c.compId}${c.in ? ` in:${r3(c.in)}` : ""})` : "") +
-              (c.name ? ` "${c.name}"` : "") + (c.parent ? ` parent:${c.parent}` : "") + fmtProps(c.props, c.kind) + kf + tr +
-              (c.locked === true ? " [locked]" : "") + (c.disabled === true ? " [disabled]" : "") +
-              (c.unlinked === true ? " [unlinked]" : "") + fxTag(c.fx);
-          }),
-        ...(Array.isArray(doc.comps) && doc.comps.length ? [`COMPS (${doc.comps.length}) — edit their clips with {op:"inComp", comp, ops:[…]}:`,
-          ...doc.comps.flatMap((comp) => [`  ${CompLib.describe(comp)}`,
-            ...(comp.template ? [`    template ${comp.template.id} — fields (setTemplate): ` + (comp.template.fields || []).map((f) => {
-              const v = Templates.fieldValue(comp, f);
-              return `${f.key}=${typeof v === "string" ? JSON.stringify(v.length > 40 ? v.slice(0, 40) + "…" : v) : v}`;
-            }).join(" ")] : []),
-            ...(comp.clips || []).slice().sort((a, b) => a.start - b.start).map((c) => {
-            const r3 = (n) => Math.round(n * 1000) / 1000;
-            return `    ${c.id} ${c.track} ${r3(c.start)}s+${r3(c.duration)}s ${c.kind}` + (c.mediaId ? `(${c.mediaId})` : "") + (c.kind === "comp" ? `(${c.compId})` : "") +
-              (c.name ? ` "${c.name}"` : "") + (c.parent ? ` parent:${c.parent}` : "") + fmtProps(c.props, c.kind);
-          })])] : []),
-        `(compact view — full JSON: fablecut_get_project without compact; edit via fablecut_patch_project)`,
-      ];
-      return lines.join("\n");
+      return ProjectOps.compactView(doc, {
+        offline: (m) => /^\/(media|library)\//.test(m.src || "") && !mediaFile(m.src),
+        proxy: (m) => { const f = mediaFile(m.src); const p = f && findProxies(PROXIES_DIR, f)[0]; return p ? p.height : null; },
+      });
     }
     case "fablecut_patch_project": {
       if (!Array.isArray(args.ops) || !args.ops.length) throw new Error("`ops` must be a non-empty array");
@@ -910,788 +935,13 @@ async function callTool(name, args, attempt = 0) {
         `Re-read the clips you touch (fablecut_get_project {compact:true}), then retry with baseRevision:${rev} — ` +
         `or omit baseRevision to apply on top of the latest anyway.`);
       if (base != null && readRev !== base) throw conflict(readRev);
-      const notes = [];
-      const toSave = [];   // [kind, item] — presets / templates written to the library once the project is saved
-      const savedList = (kind) => [...savedItems(kind), ...toSave.filter((x) => x[0] === kind).map((x) => x[1])];
-      // Locks mirror the editor: a clip is locked by its own flag or its track,
-      // and a linked A/V group with any locked member is locked as a whole.
-      const lockedTracks = () => new Set(Array.isArray(proj.lockedTracks) ? proj.lockedTracks : []);
-      const lockReason = (c) => {
-        const group = c.linkGroup ? proj.clips.filter((x) => x.linkGroup === c.linkGroup) : [c];
-        for (const x of group) {
-          const who = x.id === c.id ? `clip ${c.id}` : `clip ${c.id} is linked to ${x.id}, which`;
-          if (x.locked === true) return `${who} is locked`;
-          if (lockedTracks().has(x.track)) return `${who} is on locked track ${x.track}`;
-        }
-        return null;
-      };
-      const refuseLocked = (opName, reason, op) => {
-        if (reason && op.force !== true)
-          throw new Error(`${opName}: ${reason} — the user locked it. Leave it alone, or pass force:true if they asked you to change it`);
-      };
-      /* The effect chain an op names: a clip (and its linked stems), an
-         A-track, a submix bus or the master → {label, read(), write(list)}. */
-      const fxTarget = (op, name) => {
-        const target = op.target || (op.id && /^A\d+$/.test(op.id) ? "track" : op.id && /^B\d+$/.test(op.id) ? "bus" : op.id ? "clip" : "master");
-        if (target === "clip") {
-          const c = proj.clips.find((x) => x.id === op.id);
-          if (!c) throw new Error(`${name}: no clip ${op.id}`);
-          if (c.kind !== "audio") throw new Error(`${name}: clip ${op.id} is ${c.kind} — effects go on audio clips (a video's sound is on its linked A-track clips)`);
-          refuseLocked(name, lockReason(c), op);
-          const group = c.linkGroup ? proj.clips.filter((x) => x.linkGroup === c.linkGroup && x.kind === "audio") : [c];
-          return { label: group.map((x) => x.id).join("+"), read: () => c.fx, write(next) {
-            for (const x of group) { if (next.length) x.fx = next.map((e) => JSON.parse(JSON.stringify(e))); else delete x.fx; }
-          } };
-        }
-        if (target === "track") {
-          if (!/^A\d+$/.test(String(op.id || ""))) throw new Error(`${name}: track id must be an audio track (A1, A2, …)`);
-          if (!Array.isArray(proj.tracks) || !proj.tracks.length) proj.tracks = DEFAULT_TRACKS.map((t) => ({ ...t }));
-          let t = proj.tracks.find((x) => x.id === op.id);
-          if (!t) { t = { id: op.id, kind: "audio" }; proj.tracks.push(t); }
-          return { label: op.id, read: () => t.fx, write(next) { if (next.length) t.fx = next; else delete t.fx; } };
-        }
-        if (target === "bus") {
-          const b = (proj.buses || []).find((x) => x.id === op.id);
-          if (!b) throw new Error(`${name}: no bus ${JSON.stringify(op.id)} — create it with {op:"setBus", id:"B1"}`);
-          return { label: op.id, read: () => b.fx, write(next) { if (next.length) b.fx = next; else delete b.fx; } };
-        }
-        if (target === "master") {
-          return { label: "master", read: () => proj.master?.fx, write(next) {
-            const m = proj.master && typeof proj.master === "object" ? proj.master : {};
-            if (next.length) m.fx = next; else delete m.fx;
-            if (Object.keys(m).length) proj.master = m; else delete proj.master;
-          } };
-        }
-        throw new Error(`${name}: target must be clip, track, bus or master`);
-      };
-      const mergeInto = (target, set) => {
-        for (const [k, v] of Object.entries(set || {})) {
-          if (v === null) delete target[k];
-          else if (k === "props" && target.props && typeof v === "object" && !Array.isArray(v)) {
-            for (const [pk, pv] of Object.entries(v)) {
-              if (pv === null) delete target.props[pk]; else target.props[pk] = pv;
-            }
-          } else target[k] = v;
-        }
-      };
-      // props.masks written wholesale (addClip / updateClip) is validated like setMask
-      const checkMasks = (c, label) => {
-        if (!c.props || c.props.masks == null) return;
-        if (c.kind === "audio") throw new Error(`${label}: masks go on video, image, svg, text or adjust clips`);
-        let n;
-        try { n = Mask.normalizeMasks(c.props.masks, true); } catch (err) { throw new Error(`${label}: props.${err.message}`); }
-        if (n) c.props.masks = n; else delete c.props.masks;
-      };
-      // props.tracks written wholesale is validated too (the editor writes them; agents rarely should)
-      const checkTracks = (c, label) => {
-        if (!c.props || c.props.tracks == null) return;
-        if (c.kind !== "video") throw new Error(`${label}: tracks belong to video clips`);
-        let n;
-        try { n = Tracker.normalizeTracks(c.props.tracks, true); } catch (err) { throw new Error(`${label}: props.${err.message}`); }
-        if (n) c.props.tracks = n; else delete c.props.tracks;
-      };
-      // props.shapes (shape layers) and clip.parent: validated like setShape / setParent
-      const NO_MEDIA = ["text", "adjust", "shape", "null", "comp"];
-      let inCompId = null;   // set while an inComp op runs its ops inside a comp
-      // a comp clip names a comp that exists, and placing it here makes no loop
-      const checkCompClip = (c, label) => {
-        if (c.kind !== "comp") { if (c.compId != null) throw new Error(`${label}: compId is for kind:"comp" clips`); return; }
-        if (typeof c.compId !== "string" || !CompLib.getComp(proj, c.compId))
-          throw new Error(`${label}: compId must name a comp in project.comps${(proj.comps || []).length ? ` (${proj.comps.map((x) => x.id).join(", ")})` : " — add one with addComp"}`);
-        if (CompLib.wouldCycle(proj, inCompId, c.compId)) throw new Error(`${label}: comp ${c.compId} can't go inside ${inCompId} — that would contain itself`);
-        c.props = c.props || {};
-        if (c.props.fit == null) c.props.fit = "none";   // a comp shows at its own size unless told otherwise
-        if (c.in == null) c.in = 0;
-      };
-      const checkShapes = (c, label) => {
-        if (!c.props || c.props.shapes == null) return;
-        if (c.kind !== "shape") throw new Error(`${label}: shapes go on shape clips (kind:"shape")`);
-        let n;
-        try { n = Motion.normalizeShapes(c.props.shapes, true); } catch (err) { throw new Error(`${label}: props.${err.message}`); }
-        if (n) c.props.shapes = n; else delete c.props.shapes;
-      };
-      const byId = (id) => proj.clips.find((x) => x.id === id) || null;
-      // motion blur, auto-orient, text paths and motion-path handles (pin / pout on x / y keys)
-      const checkMotion = (c, label) => {
-        const p = c.props || {};
-        if (p.motionBlur != null && !(typeof p.motionBlur === "number" && p.motionBlur >= 0 && p.motionBlur <= 720)) throw new Error(`${label}: props.motionBlur is a shutter angle 0…720 (0 = off)`);
-        if (p.motionBlurSamples != null && !(Number.isInteger(p.motionBlurSamples) && p.motionBlurSamples >= 2 && p.motionBlurSamples <= 32)) throw new Error(`${label}: props.motionBlurSamples is a whole number 2…32`);
-        if (p.autoOrient != null && typeof p.autoOrient !== "boolean") throw new Error(`${label}: props.autoOrient is true or false`);
-        if (p.pathAlign != null && !["start", "center", "end"].includes(p.pathAlign)) throw new Error(`${label}: props.pathAlign is start | center | end`);
-        if (p.textPath != null) {
-          if (c.kind !== "text") throw new Error(`${label}: textPath goes on text clips`);
-          try { p.textPath = Motion.normalizeTextPath(p.textPath, true); } catch (err) { throw new Error(`${label}: props.${err.message}`); }
-        }
-        for (const ch of ["x", "y"]) for (const k of (c.keyframes && Array.isArray(c.keyframes[ch]) ? c.keyframes[ch] : []))
-          for (const h of ["pin", "pout"]) if (k && k[h] != null && !(typeof k[h] === "number" && Number.isFinite(k[h])))
-            throw new Error(`${label}: keyframes.${ch} ${h} must be a number (px, the motion path's curve handle)`);
-      };
-      const checkParent = (c, label) => {
-        if (c.parent == null) { delete c.parent; return; }
-        const par = typeof c.parent === "string" && byId(c.parent);
-        if (!par) throw new Error(`${label}: parent ${JSON.stringify(c.parent)} is not a clip`);
-        if (par.id === c.id || Motion.wouldCycle(c.id, par.id, byId)) throw new Error(`${label}: parenting ${c.id} to ${par.id} makes a loop`);
-        if (par.kind === "audio" || par.kind === "adjust" || c.kind === "audio" || c.kind === "adjust")
-          throw new Error(`${label}: parenting is for visual clips (video, image, svg, text, shape, null)`);
-      };
-      // blend / matte / matteTrack: checked when the op writes them
-      const videoTrackIds = () => {
-        const ids = (Array.isArray(proj.tracks) && proj.tracks.length ? proj.tracks : DEFAULT_TRACKS).filter((t) => t.kind === "video").map((t) => t.id);
-        for (const x of proj.clips) if (/^V\d+$/.test(x.track) && !ids.includes(x.track)) ids.push(x.track);
-        return ids;
-      };
-      const checkCompositing = (c, label, props) => {
-        if (!props || !["blend", "matte", "matteTrack"].some((k) => props[k] != null)) return;
-        if (c.kind === "audio") throw new Error(`${label}: blend and track mattes go on video, image, svg, text or adjust clips`);
-        try { Mask.checkCompositing(c.props, videoTrackIds(), c.track, true); } catch (err) { throw new Error(`${label}: props.${err.message}`); }
-        if (!c.props.matte) delete c.props.matteTrack;
-      };
-      const applyOps = (opList) => { for (const op of opList) {
-        switch (op.op) {
-          case "addClip": {
-            const c = op.clip;
-            if (!c || !c.track || typeof c.start !== "number" || typeof c.duration !== "number")
-              throw new Error("addClip needs clip{track, start, duration}");
-            c.id = c.id || "c_" + uid();
-            if (proj.clips.some((x) => x.id === c.id)) throw new Error("addClip: duplicate clip id " + c.id);
-            refuseLocked("addClip", lockedTracks().has(c.track) ? `track ${c.track} is locked` : null, op);
-            if (!NO_MEDIA.includes(c.kind) && !proj.media.some((m) => m.id === c.mediaId))
-              throw new Error(`addClip: unknown mediaId ${c.mediaId}`);
-            if (NO_MEDIA.includes(c.kind)) c.mediaId = null;
-            checkMasks(c, "addClip");
-            checkShapes(c, "addClip");
-            checkParent(c, "addClip");
-            checkMotion(c, "addClip");
-            checkCompClip(c, "addClip");
-            checkTracks(c, "addClip");
-            checkCompositing(c, "addClip", c.props);
-            proj.clips.push(c);
-            notes.push("+" + c.id);
-            break;
-          }
-          case "updateClip": {
-            const c = proj.clips.find((x) => x.id === op.id);
-            if (!c) throw new Error("updateClip: no clip " + op.id);
-            // Toggling the lock itself is always allowed — that's how you unlock.
-            const onlyLock = Object.keys(op.set || {}).every((k) => k === "locked");
-            if (!onlyLock) {
-              refuseLocked("updateClip", lockReason(c), op);
-              if (op.set && op.set.track && lockedTracks().has(op.set.track))
-                refuseLocked("updateClip", `track ${op.set.track} is locked`, op);
-            }
-            mergeInto(c, op.set);
-            checkMasks(c, "updateClip");
-            if (op.set && op.set.props && "tracks" in op.set.props) checkTracks(c, "updateClip");
-            if (op.set && op.set.props && "shapes" in op.set.props) checkShapes(c, "updateClip");
-            if (op.set && "parent" in op.set) checkParent(c, "updateClip");
-            checkMotion(c, "updateClip");
-            if (op.set && ("compId" in op.set || "kind" in op.set)) checkCompClip(c, "updateClip");
-            // a track move re-checks the matte too (a clip can't be its own matte)
-            checkCompositing(c, "updateClip", op.set && op.set.track ? c.props : op.set && op.set.props);
-            if (c.props && c.props.matteTrack && !c.props.matte) delete c.props.matteTrack;   // matte:null clears its track too
-            notes.push("~" + op.id);
-            break;
-          }
-          case "removeClip": {
-            const doomed = proj.clips.find((x) => x.id === op.id);
-            if (doomed) refuseLocked("removeClip", lockReason(doomed), op);
-            const n = proj.clips.length;
-            // its children stay where they are (at their own start), under its own parent if it has one
-            const kids = doomed ? proj.clips.filter((x) => x.parent === op.id).map((x) => x.id) : [];
-            if (doomed) EditOps.detachChildren(proj, new Set([op.id]));
-            for (const id of kids) notes.push(`~${id}.parent(${byId(id).parent || "none"})`);
-            proj.clips = proj.clips.filter((x) => x.id !== op.id);
-            if (proj.clips.length === n) throw new Error("removeClip: no clip " + op.id);
-            notes.push("-" + op.id);
-            break;
-          }
-          case "addMedia": {
-            const m = op.media;
-            if (!m || !m.src || !m.kind) throw new Error("addMedia needs media{src, kind}");
-            m.id = m.id || "m_" + uid();
-            if (proj.media.some((x) => x.id === m.id)) throw new Error("addMedia: duplicate media id " + m.id);
-            m.name = m.name || path.basename(decodeURIComponent(m.src));
-            proj.media.push(m);
-            notes.push("+" + m.id);
-            break;
-          }
-          case "removeMedia": {
-            const used = proj.clips.find((c) => c.mediaId === op.id);
-            if (used) throw new Error(`removeMedia: media ${op.id} is used by clip ${used.id}`);
-            for (const comp of proj.comps || []) {
-              const inner = (comp.clips || []).find((c) => c.mediaId === op.id);
-              if (inner) throw new Error(`removeMedia: media ${op.id} is used by clip ${inner.id} in comp ${comp.id}`);
-            }
-            const n = proj.media.length;
-            proj.media = proj.media.filter((x) => x.id !== op.id);
-            if (proj.media.length === n) throw new Error("removeMedia: no media " + op.id);
-            notes.push("-" + op.id);
-            break;
-          }
-          case "setFx": {
-            // {op:"setFx", target:"clip"|"track"|"bus"|"master", id?, fx?:[…] | preset?:"podcast", append?:true}
-            const t = fxTarget(op, "setFx");
-            let chain;
-            if (op.preset != null) chain = FX.presetChain(String(op.preset));
-            else if (op.fx === null) chain = [];
-            else chain = FX.normalizeFx(op.fx, true);
-            t.write(op.append ? [...FX.normalizeFx(t.read()), ...chain] : chain);
-            notes.push("~" + t.label + ".fx");
-            break;
-          }
-          case "setFxKeys": {
-            // {op:"setFxKeys", target, id?, index?|type?, param, keys:[{t, v, ease?}] | null}
-            const t = fxTarget(op, "setFxKeys");
-            const list = FX.normalizeFx(t.read()).map((e) => ({ ...e }));
-            let i = Number.isInteger(op.index) ? op.index : op.type != null ? list.findIndex((e) => e.type === op.type) : list.length === 1 ? 0 : -1;
-            if (!list[i]) throw new Error(`setFxKeys: pick the effect with index (0…${list.length - 1}) or type — ${t.label} has ${FX.summarizeFx(list) || "no effects"}`);
-            const e = list[i];
-            if (!FX.FX_DEFS[e.type].params[op.param]) throw new Error(`setFxKeys: ${e.type} has no parameter ${JSON.stringify(op.param)} (has: ${Object.keys(FX.FX_DEFS[e.type].params).join(", ")})`);
-            const keys = { ...(e.keys || {}) };
-            if (op.keys == null || (Array.isArray(op.keys) && !op.keys.length)) delete keys[op.param];
-            else Object.assign(keys, FX.normalizeKeys(e.type, { [op.param]: op.keys }, true) || {});
-            if (Object.keys(keys).length) e.keys = keys; else delete e.keys;
-            t.write(list);
-            notes.push(`~${t.label}.fx[${i}].${op.param}` + (keys[op.param] ? `(${keys[op.param].length} keys)` : "(keys cleared)"));
-            break;
-          }
-          case "setGrade": {
-            // {op:"setGrade", id | ids, grade:{…} | null, replace?:true}
-            const ids = Array.isArray(op.ids) ? op.ids : op.id != null ? [op.id] : [];
-            if (!ids.length) throw new Error("setGrade needs id or ids");
-            if (op.grade !== null && (typeof op.grade !== "object" || Array.isArray(op.grade)))
-              throw new Error("setGrade needs grade:{…} (or grade:null to clear)");
-            if (op.grade) Color.normalizeGrade(Object.fromEntries(Object.entries(op.grade).filter(([, v]) => v !== null)), true); // validate first
-            for (const id of ids) {
-              const c = proj.clips.find((x) => x.id === id);
-              if (!c) throw new Error("setGrade: no clip " + id);
-              if (!["video", "image", "svg", "adjust"].includes(c.kind)) throw new Error(`setGrade: ${id} is a ${c.kind} clip — grades go on video, image, svg or adjust clips`);
-              refuseLocked("setGrade", lockReason(c), op);
-              const next = op.grade === null ? null : Color.mergeGrade(op.replace ? null : c.props?.grade, op.grade, true);
-              c.props = c.props || {};
-              if (next) c.props.grade = next; else delete c.props.grade;
-              notes.push(`~${id}.grade(${Color.summarizeGrade(next)})`);
-            }
-            break;
-          }
-          case "setGradeLayer": {
-            // {op:"setGradeLayer", id | ids, layer: index | "name", set?:{…}, replace?:true, remove?:true}
-            const ids = Array.isArray(op.ids) ? op.ids : op.id != null ? [op.id] : [];
-            if (!ids.length) throw new Error("setGradeLayer needs id or ids");
-            const byName = typeof op.layer === "string" && op.layer.trim() !== "";
-            if (!byName && !(Number.isInteger(op.layer) && op.layer >= 0)) throw new Error("setGradeLayer needs layer: an index (0 = first) or a layer name");
-            if (!op.remove && (op.set == null || typeof op.set !== "object" || Array.isArray(op.set))) throw new Error("setGradeLayer needs set:{…} (or remove:true)");
-            for (const id of ids) {
-              const c = proj.clips.find((x) => x.id === id);
-              if (!c) throw new Error("setGradeLayer: no clip " + id);
-              if (!["video", "image", "svg", "adjust"].includes(c.kind)) throw new Error(`setGradeLayer: ${id} is a ${c.kind} clip — grades go on video, image, svg or adjust clips`);
-              refuseLocked("setGradeLayer", lockReason(c), op);
-              const layers = (c.props?.grade?.layers || []).map((l) => ({ ...l }));
-              let i = byName ? layers.findIndex((l) => l.name === op.layer.trim()) : op.layer;
-              if (op.remove) {
-                if (i < 0 || i >= layers.length) throw new Error(`setGradeLayer: ${id} has no layer ${JSON.stringify(op.layer)}`);
-                layers.splice(i, 1);
-              } else {
-                if (i < 0 || i === layers.length) { // a new layer
-                  if (layers.length >= Color.MAX_LAYERS) throw new Error(`setGradeLayer: at most ${Color.MAX_LAYERS} layers`);
-                  i = layers.length; layers.push({ name: byName ? op.layer.trim() : `Layer ${i + 1}` });
-                } else if (i > layers.length) throw new Error(`setGradeLayer: ${id} has ${layers.length} layer(s) — use layer:${layers.length} to add one`);
-                const base = op.replace ? { name: layers[i].name } : layers[i];
-                let next;
-                try { next = Color.mergeLayer(base, op.set, true); } catch (err) { throw new Error(`setGradeLayer: ${err.message.replace(/^grade\.layers\[0\]\.?/, "")}`); }
-                if (!next.name) next.name = layers[i].name || `Layer ${i + 1}`;
-                layers[i] = next;
-              }
-              const g = Color.mergeGrade(c.props?.grade, { layers: layers.length ? layers : null }, true);
-              c.props = c.props || {};
-              if (g) c.props.grade = g; else delete c.props.grade;
-              notes.push(`~${id}.grade(${Color.summarizeGrade(g)})`);
-            }
-            break;
-          }
-          case "setMask":
-          case "removeMask":
-          case "setMaskKeys": {
-            // {op:"setMask", id | ids, mask?: index | "name", set:{…}, replace?:true, remove?:true}
-            // {op:"removeMask", id | ids, mask} · {op:"setMaskKeys", id | ids, mask, keys:[…] | null}
-            const name = op.op;
-            const ids = Array.isArray(op.ids) ? op.ids : op.id != null ? [op.id] : [];
-            if (!ids.length) throw new Error(`${name} needs id or ids`);
-            const remove = name === "removeMask" || op.remove === true;
-            const byName = typeof op.mask === "string" && op.mask.trim() !== "";
-            if (op.mask != null && !byName && !(Number.isInteger(op.mask) && op.mask >= 0)) throw new Error(`${name}: mask is an index (0 = first) or a mask name`);
-            if ((remove || name === "setMaskKeys") && op.mask == null) throw new Error(`${name} needs mask: an index or a name`);
-            let set;
-            if (name === "setMaskKeys") {
-              if (op.keys !== null && !Array.isArray(op.keys)) throw new Error("setMaskKeys needs keys:[{t, x?, y?, …}] (or keys:null to stop animating)");
-              set = { keys: op.keys && op.keys.length ? op.keys : null };
-            } else if (!remove) {
-              if (op.set == null || typeof op.set !== "object" || Array.isArray(op.set)) throw new Error("setMask needs set:{shape?, x?, y?, …} (or remove:true)");
-              set = op.set;
-            }
-            for (const id of ids) {
-              const c = proj.clips.find((x) => x.id === id);
-              if (!c) throw new Error(`${name}: no clip ${id}`);
-              if (c.kind === "audio") throw new Error(`${name}: ${id} is an audio clip — masks go on video, image, svg, text or adjust clips`);
-              refuseLocked(name, lockReason(c), op);
-              const list = (Mask.normalizeMasks(c.props?.masks) || []).slice();
-              let i = op.mask == null ? list.length : byName ? list.findIndex((m) => m.name === op.mask.trim()) : op.mask;
-              const where = `${name}: ${id}`;
-              if (remove) {
-                if (i < 0 || i >= list.length) throw new Error(`${where} has no mask ${JSON.stringify(op.mask)}`);
-                list.splice(i, 1);
-              } else {
-                const adding = i < 0 || i === list.length;
-                if (adding && name === "setMaskKeys") throw new Error(`${where} has no mask ${JSON.stringify(op.mask)}`);
-                if (!adding && i > list.length) throw new Error(`${where} has ${list.length} mask(s) — use mask:${list.length} (or leave mask out) to add one`);
-                if (adding && list.length >= Mask.MAX_MASKS) throw new Error(`${where}: at most ${Mask.MAX_MASKS} masks`);
-                const base = adding ? (byName ? { name: op.mask.trim() } : null) : op.replace ? { name: list[i].name } : list[i];
-                if (adding && !set.shape && !(base && base.shape)) throw new Error(`${where}: a new mask needs set.shape (rect | ellipse | bezier | freehand)`);
-                let next;
-                try { next = Mask.mergeMask(base, set, true); }
-                catch (err) { throw new Error(`${where}: ${err.message.replace(/^mask\.?/, "mask.")}`); }
-                if (adding) { i = list.length; list.push(next); } else list[i] = next;
-              }
-              c.props = c.props || {};
-              if (list.length) c.props.masks = list; else delete c.props.masks;
-              notes.push(`~${id}.masks(${Mask.describe(list) || "none"})`);
-            }
-            break;
-          }
-          case "setShape":
-          case "removeShape": {
-            // {op:"setShape", id | ids, shape?: index | "name" | "2.0" (group path), set:{…}, replace?:true, remove?:true}
-            const name = op.op;
-            const ids = Array.isArray(op.ids) ? op.ids : op.id != null ? [op.id] : [];
-            if (!ids.length) throw new Error(`${name} needs id or ids`);
-            const remove = name === "removeShape" || op.remove === true;
-            if (remove && op.shape == null) throw new Error(`${name} needs shape: an index, a name or a path like "2.0"`);
-            if (!remove && (op.set == null || typeof op.set !== "object" || Array.isArray(op.set))) throw new Error("setShape needs set:{type?, x?, y?, w?, h?, fill?, …} (or remove:true)");
-            const isPath = (v) => Array.isArray(v) || (typeof v === "string" && /^\d+(\.\d+)*$/.test(v.trim()));
-            for (const id of ids) {
-              const c = byId(id);
-              if (!c) throw new Error(`${name}: no clip ${id}`);
-              if (c.kind !== "shape") throw new Error(`${name}: ${id} is a ${c.kind} clip — shapes go on shape clips (addClip kind:"shape")`);
-              refuseLocked(name, lockReason(c), op);
-              const where = `${name}: ${id}`;
-              let list = (Motion.normalizeShapes(c.props?.shapes) || []).slice();
-              // the target as a path [i, j…]; its last index may be one past the end (= add there)
-              let path, named = null;
-              if (op.shape == null) path = [list.length];
-              else if (Number.isInteger(op.shape) && op.shape >= 0) path = [op.shape];
-              else if (isPath(op.shape)) path = (Array.isArray(op.shape) ? op.shape : op.shape.trim().split(".")).map(Number);
-              else if (typeof op.shape === "string" && op.shape.trim()) {
-                path = Motion.itemPaths(list).find((q) => Motion.getItem(list, q).name === op.shape.trim());
-                if (!path) { if (remove) throw new Error(`${where} has no shape named ${JSON.stringify(op.shape)}`); path = [list.length]; named = op.shape.trim(); }
-              } else throw new Error(`${name}: shape is an index (0 = first), a name or a path like "2.0"`);
-              if (path.some((i) => !Number.isInteger(i) || i < 0)) throw new Error(`${name}: bad shape path ${JSON.stringify(op.shape)}`);
-              const parentPath = path.slice(0, -1), last = path[path.length - 1];
-              const group = parentPath.length ? Motion.getItem(list, parentPath) : null;
-              if (parentPath.length && (!group || group.type !== "group")) throw new Error(`${where}: ${parentPath.join(".")} is not a group`);
-              const siblings = group ? group.items : list;
-              const it = siblings[last];
-              if (remove) {
-                if (!it) throw new Error(`${where} has no shape ${JSON.stringify(op.shape)}${list.length ? ` (it has ${Motion.describe(list)})` : ""}`);
-                list = Motion.updateItem(list, path, () => null);
-              } else if (!it) {
-                if (last !== siblings.length) throw new Error(`${where}: ${parentPath.length ? `group ${parentPath.join(".")}` : "the layer"} has ${siblings.length} item(s) — use index ${siblings.length} (or leave shape out) to add one`);
-                if (!op.set.type) throw new Error(`${where}: a new shape needs set.type (${Motion.TYPES.join(" | ")})`);
-                let next;
-                try { next = Motion.normalizeItem({ ...op.set, ...(named && !op.set.name ? { name: named } : {}) }, true, "shape"); }
-                catch (err) { throw new Error(`${where}: ${err.message}`); }
-                list = group ? Motion.updateItem(list, parentPath, (g) => ({ ...g, items: [...g.items, next] })) : [...list, next];
-              } else {
-                let next;
-                const base = op.replace ? { type: it.type, name: it.name, ...(it.type === "group" ? { items: it.items } : {}) } : it;
-                try { next = Motion.mergeItem(base, op.set, true); }
-                catch (err) { throw new Error(`${where}: ${err.message}`); }
-                list = Motion.updateItem(list, path, () => next);
-              }
-              let n;
-              try { n = Motion.normalizeShapes(list, true); } catch (err) { throw new Error(`${where}: ${err.message}`); }
-              c.props = c.props || {};
-              if (n) c.props.shapes = n; else delete c.props.shapes;
-              notes.push(`~${id}.shapes(${Motion.describe(n) || "none"})`);
-            }
-            break;
-          }
-          case "setParent": {
-            // {op:"setParent", id | ids, parent: "c_…" | null, keep?: true, at?: seconds}
-            const ids = Array.isArray(op.ids) ? op.ids : op.id != null ? [op.id] : [];
-            if (!ids.length) throw new Error("setParent needs id or ids");
-            if (op.parent !== null && typeof op.parent !== "string") throw new Error("setParent needs parent: a clip id (or null to unparent)");
-            if (op.at != null && typeof op.at !== "number") throw new Error("setParent: at is a timeline time in seconds");
-            for (const id of ids) {
-              const c = byId(id);
-              if (!c) throw new Error("setParent: no clip " + id);
-              refuseLocked("setParent", lockReason(c), op);
-              const prev = c.parent;
-              c.parent = op.parent;
-              try { checkParent(c, `setParent: ${id}`); } finally { if (prev) c.parent = prev; else delete c.parent; }
-              if (op.keep !== false) {
-                const t = op.at != null ? Math.min(Math.max(op.at, c.start), c.start + c.duration) : c.start;
-                const v = Motion.reparentValues(c, op.parent, byId, t);
-                c.props = c.props || {};
-                for (const [k, val] of Object.entries(v)) if (!c.keyframes?.[k]?.length) c.props[k] = val;
-              }
-              if (op.parent) c.parent = op.parent; else delete c.parent;
-              notes.push(`~${id}.parent(${op.parent || "none"})`);
-            }
-            break;
-          }
-          case "setMotionPath": {
-            // {op:"setMotionPath", id | ids, path?: "smooth" | "straight", autoOrient?: bool}
-            const ids = Array.isArray(op.ids) ? op.ids : op.id != null ? [op.id] : [];
-            if (!ids.length) throw new Error("setMotionPath needs id or ids");
-            if (op.path != null && !["smooth", "straight"].includes(op.path)) throw new Error('setMotionPath: path is "smooth" (curve through the position keys) or "straight"');
-            if (op.autoOrient != null && typeof op.autoOrient !== "boolean") throw new Error("setMotionPath: autoOrient is true or false");
-            if (op.path == null && op.autoOrient == null) throw new Error('setMotionPath needs path:"smooth"|"straight" and / or autoOrient');
-            for (const id of ids) {
-              const c = byId(id);
-              if (!c) throw new Error("setMotionPath: no clip " + id);
-              if (c.kind === "audio" || c.kind === "adjust") throw new Error(`setMotionPath: ${id} is a ${c.kind} clip`);
-              refuseLocked("setMotionPath", lockReason(c), op);
-              if (op.path) {
-                if (Motion.posKeys(c).length < 2) throw new Error(`setMotionPath: ${id} needs x and y keyed together at two or more times first (the position keys)`);
-                c.keyframes = op.path === "smooth" ? Motion.smoothPath(c.keyframes) : Motion.straightPath(c.keyframes);
-              }
-              if (op.autoOrient != null) { c.props = c.props || {}; if (op.autoOrient) c.props.autoOrient = true; else delete c.props.autoOrient; }
-              notes.push(`~${id}.motionPath(${Motion.posKeys(c).length} keys${Motion.hasPathHandles(c) ? ", curved" : ""}${c.props && c.props.autoOrient ? ", auto-orient" : ""})`);
-            }
-            break;
-          }
-          case "setTextPath": {
-            // {op:"setTextPath", id | ids, path: "line" | "arc" | "circle" | "wave" | {type, …} | null, offset?, align?}
-            const ids = Array.isArray(op.ids) ? op.ids : op.id != null ? [op.id] : [];
-            if (!ids.length) throw new Error("setTextPath needs id or ids");
-            if (op.path === undefined && op.offset == null && op.align == null) throw new Error("setTextPath needs path (a preset name, a shape item or null), offset and / or align");
-            let item;
-            if (op.path === null) item = null;
-            else if (typeof op.path === "string") {
-              if (!Motion.TEXT_PATH_PRESETS[op.path]) throw new Error(`setTextPath: path is ${Object.keys(Motion.TEXT_PATH_PRESETS).join(" | ")}, a shape item or null`);
-              item = Motion.normalizeTextPath(Motion.TEXT_PATH_PRESETS[op.path], true);
-            } else if (op.path !== undefined) {
-              try { item = Motion.normalizeTextPath(op.path, true); } catch (err) { throw new Error(`setTextPath: ${err.message}`); }
-            }
-            if (op.offset != null && typeof op.offset !== "number") throw new Error("setTextPath: offset is % of the path's length");
-            if (op.align != null && !["start", "center", "end"].includes(op.align)) throw new Error("setTextPath: align is start | center | end");
-            for (const id of ids) {
-              const c = byId(id);
-              if (!c) throw new Error("setTextPath: no clip " + id);
-              if (c.kind !== "text") throw new Error(`setTextPath: ${id} is a ${c.kind} clip — text paths go on text clips`);
-              refuseLocked("setTextPath", lockReason(c), op);
-              c.props = c.props || {};
-              if (op.path !== undefined) { if (item) c.props.textPath = JSON.parse(JSON.stringify(item)); else delete c.props.textPath; }
-              if (op.offset != null) c.props.pathOffset = op.offset;
-              if (op.align != null) c.props.pathAlign = op.align;
-              notes.push(`~${id}.textPath(${c.props.textPath ? c.props.textPath.type : "none"})`);
-            }
-            break;
-          }
-          case "addComp": {
-            // {op:"addComp", comp:{id?, name, width?, height?, duration, background?, tracks?, clips?:[…]}}
-            const src = op.comp;
-            if (!src || typeof src !== "object") throw new Error("addComp needs comp:{name, duration, …}");
-            const id = src.id || "comp_" + uid();
-            if (CompLib.getComp(proj, id)) throw new Error(`addComp: comp ${id} already exists`);
-            let comp;
-            try { comp = CompLib.normalizeComp({ ...src, id, clips: [] }, true, proj); } catch (err) { throw new Error(`addComp: ${err.message}`); }
-            if (!comp.tracks) comp.tracks = CompLib.DEFAULT_TRACKS.map((t) => ({ ...t }));
-            proj.comps = [...(proj.comps || []), comp];
-            notes.push(`+comp ${id}`);
-            // its clips go in through the same checks as addClip
-            if (Array.isArray(src.clips) && src.clips.length) applyOps([{ op: "inComp", comp: id, ops: src.clips.map((clip) => ({ op: "addClip", clip })) }]);
-            break;
-          }
-          case "updateComp": {
-            // {op:"updateComp", id, set:{name?, width?, height?, duration?, background?, tracks?}}
-            const comp = CompLib.getComp(proj, op.id);
-            if (!comp) throw new Error("updateComp: no comp " + op.id);
-            const set = op.set || {};
-            for (const k of Object.keys(set)) if (!["name", "width", "height", "duration", "background", "tracks", "disabledTracks"].includes(k))
-              throw new Error(`updateComp: ${k} can't be set here (name, width, height, duration, background, tracks, disabledTracks) — edit its clips with inComp`);
-            const next = { ...comp, ...set };
-            for (const [k, v] of Object.entries(set)) if (v === null) delete next[k];
-            let n;
-            try { n = CompLib.normalizeComp(next, true, proj); } catch (err) { throw new Error(`updateComp: ${err.message}`); }
-            proj.comps = proj.comps.map((c) => (c.id === comp.id ? n : c));
-            notes.push(`~comp ${comp.id}`);
-            break;
-          }
-          case "removeComp": {
-            const comp = CompLib.getComp(proj, op.id);
-            if (!comp) throw new Error("removeComp: no comp " + op.id);
-            const used = CompLib.usages(proj, comp.id);
-            if (used.length) throw new Error(`removeComp: ${comp.id} is used by ${used.map((u) => u.clip.id + (u.in ? ` (in ${u.in})` : "")).join(", ")} — remove those clips first`);
-            proj.comps = proj.comps.filter((c) => c.id !== comp.id);
-            notes.push(`-comp ${comp.id}`);
-            break;
-          }
-          case "precompose": {
-            // {op:"precompose", ids:[…], name?, id?} — the clips (here, or inside the comp an inComp op is in) move into a new comp
-            const ids = Array.isArray(op.ids) ? op.ids : [];
-            if (!ids.length) throw new Error("precompose needs ids:[…] (the clips to move into the new comp)");
-            for (const id of ids) {
-              const c = proj.clips.find((x) => x.id === id);
-              if (!c) throw new Error("precompose: no clip " + id + (inCompId ? ` in comp ${inCompId}` : ""));
-              refuseLocked("precompose", lockReason(c), op);
-            }
-            const doc = { clips: proj.clips, comps: proj.comps || [], tracks: proj.tracks, width: proj.width, height: proj.height };
-            let r;
-            try { r = CompLib.precompose(doc, ids, { id: op.id, name: op.name }); } catch (err) { throw new Error(err.message); }
-            proj.clips = doc.clips; proj.comps = doc.comps;
-            r.clip.id = "c_" + uid();
-            notes.push(`+comp ${r.comp.id} (${ids.length} clips) +${r.clip.id}`);
-            break;
-          }
-          case "applyPreset": {
-            // {op:"applyPreset", id | ids, preset: name | {anchor, length, keys…}, length?, at?} — at: timeline seconds, for an "at" (emphasis) preset
-            const ids = Array.isArray(op.ids) ? op.ids : op.id ? [op.id] : [];
-            if (!ids.length) throw new Error("applyPreset needs id or ids:[…]");
-            let p;
-            try { p = Templates.findPreset(op.preset, savedList("presets")); } catch (err) { throw new Error(`applyPreset: ${err.message}`); }
-            if (!p) throw new Error(`applyPreset: no preset ${JSON.stringify(op.preset)} — built in: ${Templates.PRESETS.map((x) => x.id).join(", ")}` +
-              (savedList("presets").length ? `; saved: ${savedList("presets").map((x) => x.id).join(", ")}` : ""));
-            if (op.length != null && !(typeof op.length === "number" && op.length > 0)) throw new Error("applyPreset: length is seconds, more than 0");
-            for (const id of ids) {
-              const c = proj.clips.find((x) => x.id === id);
-              if (!c) throw new Error("applyPreset: no clip " + id + (inCompId ? ` in comp ${inCompId}` : ""));
-              if (c.kind === "audio" || c.kind === "adjust") throw new Error(`applyPreset: clip ${id} is ${c.kind} — presets animate visual clips`);
-              refuseLocked("applyPreset", lockReason(c), op);
-              Templates.applyPreset(c, p, { length: op.length, at: typeof op.at === "number" ? op.at - c.start : undefined });
-            }
-            notes.push(`~${ids.join(",")}.${p.id}`);
-            break;
-          }
-          case "addTemplate": {
-            // {op:"addTemplate", template: name | {…}, start?, track?, duration?, fields?:{key: value}, id?, compId?, name?}
-            let t;
-            try { t = Templates.findTemplate(op.template, savedList("templates")); } catch (err) { throw new Error(`addTemplate: ${err.message}`); }
-            if (!t) throw new Error(`addTemplate: no template ${JSON.stringify(op.template)} — built in: ${Templates.TEMPLATES.map((x) => x.id).join(", ")}` +
-              (savedList("templates").length ? `; saved: ${savedList("templates").map((x) => x.id).join(", ")}` : ""));
-            let r;
-            try {
-              r = Templates.instantiate(proj, t, { compId: op.compId || "comp_" + uid(), clipId: op.id || "c_" + uid(), name: op.name,
-                start: typeof op.start === "number" ? op.start : 0, track: op.track || "V2", duration: op.duration, fields: op.fields });
-            } catch (err) { throw new Error(`addTemplate: ${err.message}`); }
-            notes.push(`+comp ${r.comp.id} (${t.id})`);
-            applyOps([{ op: "addClip", clip: r.clip }]);   // the same checks as any clip: track, locks
-            break;
-          }
-          case "setTemplate": {
-            // {op:"setTemplate", id: comp clip id | comp id, fields?:{key: value}, duration?}
-            let comp = CompLib.getComp(proj, op.id);
-            if (!comp) { const c = proj.clips.find((x) => x.id === op.id && x.kind === "comp"); comp = c && CompLib.getComp(proj, c.compId); }
-            if (!comp) throw new Error("setTemplate: no template clip or comp " + op.id);
-            if (!comp.template) throw new Error(`setTemplate: comp ${comp.id} isn't a placed template — edit its clips with inComp`);
-            try {
-              for (const [k, v] of Object.entries(op.fields || {})) Templates.setField(comp, Templates.slug(k), v, proj);
-              if (op.duration != null) {
-                const old = comp.duration;
-                Templates.retime(comp, op.duration);
-                // clips that showed the comp to its end keep doing so
-                for (const u of CompLib.usages(proj, comp.id)) if (Math.abs((+u.clip.in || 0) + u.clip.duration - old) < 1e-3) u.clip.duration = +(comp.duration - (+u.clip.in || 0)).toFixed(4);
-              }
-            } catch (err) { throw new Error(`setTemplate: ${err.message}`); }
-            notes.push(`~template ${comp.id}`);
-            break;
-          }
-          case "savePreset": {
-            // {op:"savePreset", id: clip id, name, anchor?:"in"|"out"|"whole", from?, to?} (clip seconds) or {op:"savePreset", preset:{…}}
-            let p;
-            try {
-              if (op.preset) p = Templates.normalizePreset(op.preset, true);
-              else {
-                const c = proj.clips.find((x) => x.id === op.id);
-                if (!c) throw new Error("no clip " + op.id);
-                const times = Object.values(c.keyframes || {}).flat().map((x) => x.t);
-                if (!times.length) throw new Error(`clip ${c.id} has no keyframes to save`);
-                const anchor = op.anchor || "in";
-                p = Templates.presetFromClip(c, { name: op.name, anchor,
-                  from: typeof op.from === "number" ? op.from : anchor === "out" ? Math.min(...times) : 0,
-                  to: typeof op.to === "number" ? op.to : anchor === "in" ? Math.max(...times) : c.duration });
-              }
-            } catch (err) { throw new Error(`savePreset: ${err.message}`); }
-            p = Templates.asSaved(p, "presets");
-            toSave.push(["presets", p]);
-            notes.push(`saved preset ${p.id} → library/presets/${p.id}.json`);
-            break;
-          }
-          case "saveTemplate": {
-            // {op:"saveTemplate", comp, name?, fields?, hold?} or {op:"saveTemplate", template:{…}}
-            let t;
-            try {
-              if (op.template) t = Templates.normalizeTemplate(op.template, true);
-              else {
-                const comp = CompLib.getComp(proj, op.comp);
-                if (!comp) throw new Error("no comp " + op.comp);
-                t = Templates.templateFromComp(comp, { name: op.name, fields: op.fields, hold: op.hold, media: proj.media });
-              }
-            } catch (err) { throw new Error(`saveTemplate: ${err.message}`); }
-            t = Templates.asSaved(t, "templates");
-            toSave.push(["templates", t]);
-            notes.push(`saved template ${t.id} → library/templates/${t.id}.json`);
-            break;
-          }
-          case "inComp": {
-            // {op:"inComp", comp, ops:[…clip / timeline ops…]} — run ops on the comp's own clips and tracks
-            const comp = CompLib.getComp(proj, op.comp);
-            if (!comp) throw new Error("inComp: no comp " + op.comp);
-            if (!Array.isArray(op.ops)) throw new Error("inComp needs ops:[…]");
-            const allowed = ["addClip", "updateClip", "removeClip", "setGrade", "setGradeLayer", "setMask", "removeMask", "setMaskKeys", "setMatte",
-              "setShape", "removeShape", "setParent", "setMotionPath", "setTextPath", "setFx", "setFxKeys", "precompose", "inComp",
-              "applyPreset", "addTemplate", "setTemplate",
-              "split", "rippleDelete", "closeGap", "lift", "extract", "rippleTrim", "roll", "slip", "slide", "crossfade"];
-            for (const o of op.ops) {
-              if (!o || !allowed.includes(o.op)) throw new Error(`inComp: ${o && o.op} can't run inside a comp (clip and timeline ops only: ${allowed.join(", ")})`);
-              // the same target rule as fxTarget: no id means master, A… a track, B… a bus — none of them live in a comp
-              const fxAt = o.target || (o.id && /^A\d+$/.test(o.id) ? "track" : o.id && /^B\d+$/.test(o.id) ? "bus" : o.id ? "clip" : "master");
-              if ((o.op === "setFx" || o.op === "setFxKeys") && fxAt !== "clip")
-                throw new Error(`inComp: ${o.op} inside a comp works on its clips only (target:"clip", id) — the ${fxAt} effects are the main timeline's`);
-            }
-            const keep = { clips: proj.clips, tracks: proj.tracks, width: proj.width, height: proj.height, lockedTracks: proj.lockedTracks,
-              untargetedTracks: proj.untargetedTracks, disabledTracks: proj.disabledTracks, inPoint: proj.inPoint, outPoint: proj.outPoint };
-            const prevIn = inCompId;
-            Object.assign(proj, { clips: comp.clips || [], tracks: CompLib.compTracks(comp), width: comp.width, height: comp.height,
-              lockedTracks: [], untargetedTracks: [], disabledTracks: comp.disabledTracks || [], inPoint: null, outPoint: null });
-            inCompId = comp.id;
-            const n0 = notes.length;
-            try { applyOps(op.ops); }
-            finally {
-              const live = CompLib.getComp(proj, comp.id) || comp;
-              live.clips = proj.clips;
-              inCompId = prevIn;
-              Object.assign(proj, keep);
-            }
-            const inner = notes.splice(n0);
-            notes.push(`${comp.id}{${inner.join(" ")}}`);
-            break;
-          }
-          case "removeTrack": {
-            // {op:"removeTrack", id, track: "name" | index} — what follows it keeps its keys
-            const c = proj.clips.find((x) => x.id === op.id);
-            if (!c) throw new Error("removeTrack: no clip " + op.id);
-            refuseLocked("removeTrack", lockReason(c), op);
-            const list = Tracker.normalizeTracks(c.props?.tracks) || [];
-            const i = typeof op.track === "string" ? list.findIndex((t) => t.name === op.track) : op.track;
-            if (!list[i]) throw new Error(`removeTrack: ${op.id} has no track ${JSON.stringify(op.track)}${list.length ? ` (it has ${Tracker.describe(list)})` : ""}`);
-            list.splice(i, 1);
-            if (list.length) c.props.tracks = list; else delete c.props.tracks;
-            notes.push(`~${op.id}.tracks(${Tracker.describe(list) || "none"})`);
-            break;
-          }
-          case "setMatte": {
-            // {op:"setMatte", id | ids, matte:"alpha"|"alpha-inverted"|"luma"|"luma-inverted"|null, track?:"V3"|null}
-            const ids = Array.isArray(op.ids) ? op.ids : op.id != null ? [op.id] : [];
-            if (!ids.length) throw new Error("setMatte needs id or ids");
-            if (op.matte !== null && !Mask.MATTES.includes(op.matte)) throw new Error(`setMatte needs matte: ${Mask.MATTES.join(" | ")} (or null for none)`);
-            for (const id of ids) {
-              const c = proj.clips.find((x) => x.id === id);
-              if (!c) throw new Error("setMatte: no clip " + id);
-              if (c.kind === "audio") throw new Error(`setMatte: ${id} is an audio clip — track mattes go on video, image, svg, text or adjust clips`);
-              refuseLocked("setMatte", lockReason(c), op);
-              c.props = c.props || {};
-              if (op.matte === null) { delete c.props.matte; delete c.props.matteTrack; notes.push(`~${id}.matte(none)`); continue; }
-              c.props.matte = op.matte;
-              if (op.track === null) delete c.props.matteTrack;
-              else if (op.track != null) c.props.matteTrack = op.track;
-              try { Mask.checkCompositing(c.props, videoTrackIds(), c.track, true); } catch (err) { throw new Error(`setMatte: ${id}: ${err.message.replace(/^matteTrack/, "track")}`); }
-              const from = Mask.matteTrackFor(c, videoTrackIds());
-              if (!from) throw new Error(`setMatte: ${id} is on ${c.track} and there is no video track above it — pass track:"Vn" (or add a track)`);
-              notes.push(`~${id}.matte(${op.matte} from ${from})`);
-            }
-            break;
-          }
-          case "setTrack": {
-            // Mixer settings on one lane: {op:"setTrack", id:"A1", set:{gain:-6, pan:0.2}}.
-            if (!/^A\d+$/.test(String(op.id || ""))) throw new Error("setTrack: id must be an audio track (A1, A2, …)");
-            if (!Array.isArray(proj.tracks) || !proj.tracks.length) proj.tracks = DEFAULT_TRACKS.map((t) => ({ ...t }));
-            let t = proj.tracks.find((x) => x.id === op.id);
-            if (!t) { t = { id: op.id, kind: "audio" }; proj.tracks.push(t); }
-            for (const [k, v] of Object.entries(op.set || {})) {
-              if (k === "out") { // route into a submix bus, or back to the master
-                if (v == null || v === "master") { delete t.out; continue; }
-                if (!(proj.buses || []).some((b) => b.id === v)) throw new Error(`setTrack: no bus ${JSON.stringify(v)} — create it first with {op:"setBus", id:"B1"}`);
-                t.out = v;
-                continue;
-              }
-              const range = k === "gain" ? [-60, 12] : k === "pan" ? [-1, 1] : null;
-              if (!range) throw new Error(`setTrack: '${k}' not settable (gain, pan, out)`);
-              if (v === null || v === 0) { delete t[k]; continue; }
-              if (typeof v !== "number" || !Number.isFinite(v) || v < range[0] || v > range[1])
-                throw new Error(`setTrack: ${k} must be a number ${range[0]}…${range[1]}`);
-              t[k] = v;
-            }
-            notes.push("~" + op.id);
-            break;
-          }
-          case "setBus": {
-            // {op:"setBus", id:"B1", set:{name?, gain?, pan?, mute?}} — creates the bus if needed
-            if (!/^B\d+$/.test(String(op.id || ""))) throw new Error("setBus: id must be B1, B2, …");
-            proj.buses = Array.isArray(proj.buses) ? proj.buses : [];
-            let b = proj.buses.find((x) => x.id === op.id);
-            if (!b) {
-              if (proj.buses.length >= 8) throw new Error("setBus: up to 8 buses");
-              b = { id: op.id };
-              proj.buses.push(b);
-              proj.buses.sort((x, y) => parseInt(x.id.slice(1), 10) - parseInt(y.id.slice(1), 10));
-            }
-            for (const [k, v] of Object.entries(op.set || {})) {
-              if (k === "name") { if (v == null || v === "") delete b.name; else b.name = String(v).slice(0, 40); continue; }
-              if (k === "mute") { if (v === true) b.mute = true; else delete b.mute; continue; }
-              const range = k === "gain" ? [-60, 12] : k === "pan" ? [-1, 1] : null;
-              if (!range) throw new Error(`setBus: '${k}' not settable (name, gain, pan, mute; effects via setFx target:"bus")`);
-              if (v === null || v === 0) { delete b[k]; continue; }
-              if (typeof v !== "number" || !Number.isFinite(v) || v < range[0] || v > range[1])
-                throw new Error(`setBus: ${k} must be a number ${range[0]}…${range[1]}`);
-              b[k] = v;
-            }
-            notes.push("~" + op.id);
-            break;
-          }
-          case "removeBus": {
-            const n = (proj.buses || []).length;
-            proj.buses = (proj.buses || []).filter((b) => b.id !== op.id);
-            if (proj.buses.length === n) throw new Error("removeBus: no bus " + op.id);
-            if (!proj.buses.length) delete proj.buses;
-            for (const t of proj.tracks || []) if (t.out === op.id) delete t.out; // back to the master
-            notes.push("-" + op.id);
-            break;
-          }
-          case "setProject": {
-            const allowed = ["name", "width", "height", "fps", "background", "markers", "disabledTracks", "lockedTracks", "untargetedTracks", "exportFrame", "encodeProfile", "master", "inPoint", "outPoint"];
-            for (const [k, v] of Object.entries(op.set || {})) {
-              if (!allowed.includes(k)) throw new Error(`setProject: '${k}' not settable (allowed: ${allowed.join(", ")})`);
-              if ((k === "inPoint" || k === "outPoint") && v != null && (typeof v !== "number" || !Number.isFinite(v) || v < 0))
-                throw new Error(`setProject: ${k} must be seconds ≥ 0 (null clears it)`);
-              if (k === "encodeProfile" && v != null) {
-                resolveProfile(String(v)); // validate id exists
-              }
-              if (k === "master" && v != null) {
-                const g = v.gain;
-                if (typeof v !== "object" || Object.keys(v).some((x) => x !== "gain") ||
-                    (g != null && (typeof g !== "number" || !Number.isFinite(g) || g < -60 || g > 12)))
-                  throw new Error("setProject: master is {gain} — master fader in dB, -60…+12");
-              }
-              if (v === null) delete proj[k]; else proj[k] = v;
-            }
-            if (proj.inPoint != null && proj.outPoint != null && !(proj.outPoint > proj.inPoint))
-              throw new Error("setProject: outPoint must be after inPoint");
-            notes.push("~project");
-            break;
-          }
-          case "split": case "rippleDelete": case "closeGap": case "lift": case "extract":
-          case "rippleTrim": case "roll": case "slip": case "slide":
-          case "insert": case "overwrite": case "crossfade":
-            notes.push(timelineEdit(proj, op, refuseLocked, lockReason));
-            break;
-          default:
-            throw new Error("Unknown op: " + op.op + " (addClip|updateClip|removeClip|addMedia|removeMedia|setProject|setTrack|setBus|removeBus|setFx|setFxKeys|setGrade|setGradeLayer|setMask|removeMask|setMaskKeys|setMatte|removeTrack|setShape|removeShape|setParent|setMotionPath|setTextPath|" +
-              "split|rippleDelete|closeGap|lift|extract|rippleTrim|roll|slip|slide|insert|overwrite|crossfade|" +
-              "addComp|updateComp|removeComp|precompose|inComp|applyPreset|addTemplate|setTemplate|savePreset|saveTemplate)");
-        }
-      } };
-      applyOps(ops);
+      const { notes, toSave } = ProjectOps.applyPatch(proj, ops, {
+        savedItems,
+        audioChannels: (m) => { const f = mediaFile(m.src); return f ? probeChannels(f) || 0 : null; },
+        checkProfile: resolveProfile,
+        deliveryPresets: savedDeliveryPresets(),
+        mediaInfo: (src) => { const f = mediaFile(src); return f ? probeFile(f) : null; },
+      });
       // Someone else saved while the ops ran: writing now would drop their change.
       // Without a baseRevision the ops just re-apply on the newer document.
       let diskRev = readRev;
@@ -1711,34 +961,7 @@ async function callTool(name, args, attempt = 0) {
       if (!doc || typeof doc !== "object") throw new Error("`project` must be an object");
       if (!Array.isArray(doc.clips) || !Array.isArray(doc.media))
         throw new Error("project must contain `clips` and `media` arrays");
-      if (doc.comps != null) {
-        if (!Array.isArray(doc.comps)) throw new Error("comps must be a list of compositions");
-        // saved as normalized (trimmed id, default name and size, rounded duration)
-        try { doc.comps = doc.comps.map((comp) => CompLib.normalizeComp(comp, true, doc)); } catch (err) { throw new Error(err.message); }
-        const seen = new Set();
-        for (const comp of doc.comps) {
-          if (seen.has(comp.id)) throw new Error(`two comps have the id ${comp.id} — comp ids must be unique`);
-          seen.add(comp.id);
-        }
-      }
-      // the same checks for clips on the timeline and clips inside comps
-      const checkClip = (c, where) => {
-        const at = where ? `comp ${where}: ` : "";
-        if (!c.id || !c.track || typeof c.start !== "number" || typeof c.duration !== "number")
-          throw new Error(`${at}clip ${c.id || "?"} needs id, track, numeric start and duration`);
-        if (!["text", "adjust", "shape", "null", "comp"].includes(c.kind) && !doc.media.some((m) => m.id === c.mediaId))
-          throw new Error(`${at}clip ${c.id} references unknown mediaId ${c.mediaId}`);
-        if (c.kind === "comp" && !CompLib.getComp(doc, c.compId)) throw new Error(`${at}clip ${c.id} references unknown compId ${c.compId}`);
-        if (c.kind === "comp" && where && CompLib.wouldCycle(doc, where, c.compId))
-          throw new Error(`comp ${where}: clip ${c.id} uses comp ${c.compId}, which is missing or would contain itself`);
-        if (c.kind === "shape" && c.props && c.props.shapes != null) {
-          let n;
-          try { n = Motion.normalizeShapes(c.props.shapes, true); } catch (err) { throw new Error(`${at}clip ${c.id}: props.${err.message}`); }
-          if (n) c.props.shapes = n; else delete c.props.shapes;
-        }
-      };
-      for (const c of doc.clips) checkClip(c, null);
-      for (const comp of doc.comps || []) for (const c of comp.clips) checkClip(c, comp.id);
+      ProjectOps.checkProject(doc);
       let cur = { revision: 0 };
       try { cur = readProject(); } catch {}
       const curRev = cur.revision || 0;
@@ -1953,6 +1176,7 @@ async function callTool(name, args, attempt = 0) {
         src: "/media/" + encodeURIComponent(path.basename(target)),
         duration: kind === "image" || kind === "svg" ? undefined : ffprobeDuration(target),
       };
+      Object.assign(entry, infoForEntry(await probeFile(target), entry));
       const proj = readProject();
       // import only appends a media entry (never touches clips), so it merges
       // into the live document; keep lastReadRevision in step only if it
@@ -1968,6 +1192,14 @@ async function callTool(name, args, attempt = 0) {
           : "Ready to use in clips via mediaId.");
     }
     case "fablecut_encode_profiles": {
+      if (args.preset) {
+        const saved = savedDeliveryPresets();
+        const id = String(args.preset);
+        if (!Delivery.PRESETS[id] && !saved[id]) throw new Error(`no delivery preset "${id}" — built-in: ${Delivery.PRESET_IDS.join(", ")}${Object.keys(saved).length ? "; saved: " + Object.keys(saved).join(", ") : ""}`);
+        const { spec } = Delivery.normalize(id, { presets: saved });
+        const p = Delivery.PRESETS[id] || saved[id];
+        return JSON.stringify({ preset: id, label: p.label, note: p.note || "", summary: Delivery.describe(spec), spec }, null, 2);
+      }
       if (args.profile) {
         const p = resolveProfile(String(args.profile));
         return JSON.stringify({
@@ -1981,7 +1213,20 @@ async function callTool(name, args, attempt = 0) {
           args: p.args,
         }, null, 2);
       }
-      return JSON.stringify(listProfilesPublic(!!args.detail), null, 2);
+      const saved = savedDeliveryPresets();
+      let encoders = null;
+      try { const r = await apiJSON("GET", "/api/export/presets"); if (r.status === 200) encoders = r.body.encoders; } catch {}
+      const presets = {};
+      for (const id of [...Delivery.PRESET_IDS, ...Object.keys(saved)]) {
+        const p = Delivery.PRESETS[id] || saved[id];
+        presets[id] = { label: p.label, ...(saved[id] ? { saved: true } : {}), summary: Delivery.describe(Delivery.normalize(id, { presets: saved }).spec) };
+      }
+      // the encoding-profile fields stay at the top level, as they always were
+      return JSON.stringify({
+        ...listProfilesPublic(!!args.detail),
+        deliveryPresets: presets,
+        encoders: encoders || "(start the editor server to list them)",
+      }, null, 2);
     }
     default:
       throw new Error("Unknown tool: " + name);
@@ -2001,7 +1246,7 @@ async function handle(msg) {
         result: {
           protocolVersion: negotiateProtocolVersion(params?.protocolVersion),
           capabilities: { tools: {} },
-          serverInfo: { name: "fablecut", version: "1.14.0" },
+          serverInfo: { name: "fablecut", version: "1.15.0" },
         },
       });
     }
@@ -2009,8 +1254,11 @@ async function handle(msg) {
     if (method === "tools/call") {
       pending++;
       try {
-        const text = await callTool(params.name, params.arguments || {});
-        send({ jsonrpc: "2.0", id, result: { content: [{ type: "text", text }] } });
+        const out = await callTool(params.name, params.arguments || {});
+        /* A tool may answer with ready-made content blocks (fablecut_frame
+           returns an image); everything else answers with a string. */
+        const content = Array.isArray(out) ? out : [{ type: "text", text: String(out) }];
+        send({ jsonrpc: "2.0", id, result: { content } });
       } catch (e) {
         send({ jsonrpc: "2.0", id, result: { content: [{ type: "text", text: "Error: " + e.message }], isError: true } });
       } finally {