davinci-resolve-mcp 2.193.0 → 2.194.0

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 Release history for the DaVinci Resolve MCP Server. The latest release is summarized in the root README; older entries live here to keep the README focused.
 
+## What's New in v2.194.0 — E142: a cut re-aligned inside a dissolve is the same picture
+
+### Added
+
+- **A cut re-aligned inside an unchanged dissolve is the same picture.**
+  Premiere keeps a fractional dissolve alignment (its cut sat 12 frames into a
+  46-frame span); Resolve's conform re-centres it (23). The dissolve covers
+  the same record frames from the same media either way, but the changelist
+  read each one as a `moved` incoming plus a `trimmed` outgoing. When a
+  transition's span is unchanged and the cut inside it moved with the
+  incoming's source-in and the outgoing's source-out sliding by the same
+  delta (scaled by the clip's speed for a retimed clip, read through a TC
+  rebase), the pair folds into ONE `junction_realigned` — a consequence, not
+  an edit — both sides count as retained, and the junction diff no longer
+  reports the pre-roll change as a second fact. A dissolve whose span moved,
+  or a cut whose source did not slide with it, stays a real move.
+- **Two labels of one transition family are a relabel.** `Cross Dissolve
+  (Legacy)` in Premiere and `Cross Dissolve` in Resolve are the same effect;
+  they now land in `transitionRelabels` instead of `transition_changed`. A
+  different family (a push, a wipe) is still a type change.
+- **Shape `equivalent`.** A diff whose only changes are consequences (junctions
+  re-aligned, labels) now says so, with a note, instead of `edit`.
+
+On the real reel (Premiere REEL_02 pix-lock vs the Resolve conform): 206 of
+228 cuts retained (189 before), 9 junctions re-aligned, 10 relabels, one real
+move (a dissolve whose span moved), one real transition change, 19 trims on
+the eye-matched files, the second mix track, the reversed tail leader and
+frozen black — symmetric in both directions.
+
 ## What's New in v2.193.0 — E141: relink-aware changelist
 
 ### Added

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.193.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.194.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
 [![npm](https://img.shields.io/npm/v/davinci-resolve-mcp.svg?label=npm&color=CB3837)](https://www.npmjs.com/package/davinci-resolve-mcp)
 [![API Coverage](https://img.shields.io/badge/API%20Coverage-100%25-brightgreen.svg)](docs/reference/api-coverage.md)
 [![Tools](https://img.shields.io/badge/MCP%20Tools-36%20(353%20full)-blue.svg)](#server-modes)

package/README.zh-CN.md

@@ -2,7 +2,7 @@
 
 [English](README.md) | 简体中文
 
-[![Version](https://img.shields.io/badge/version-2.193.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.194.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
 [![npm](https://img.shields.io/npm/v/davinci-resolve-mcp.svg?label=npm&color=CB3837)](https://www.npmjs.com/package/davinci-resolve-mcp)
 [![API Coverage](https://img.shields.io/badge/API%20Coverage-100%25-brightgreen.svg)](docs/reference/api-coverage.md)
 [![Tools](https://img.shields.io/badge/MCP%20Tools-36%20(353%20full)-blue.svg)](#服务器模式)
@@ -12,7 +12,7 @@
 [![Python](https://img.shields.io/badge/python-3.10+-green.svg)](https://www.python.org/downloads/)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-> 本翻译对应 v2.193.0 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
+> 本翻译对应 v2.194.0 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
 
 一个 Model Context Protocol (MCP) 服务器，让 AI 助手通过官方脚本 API 控制 DaVinci Resolve Studio（达芬奇）。它提供完整的 API 覆盖，外加带护栏的工作流助手，涵盖剪辑、媒体池整理、渲染设置、审阅标记、调色、Fusion、Fairlight、项目生命周期任务、扩展开发，以及不碰源媒体的媒体分析。
 

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.193.0"
+VERSION = "2.194.0"
 # Only hard floor: mcp[cli] requires Python 3.10+. There is no upper bound —
 # Resolve's scripting bridge loads into newer interpreters on recent builds
 # (Python 3.14 verified against Resolve Studio 20.3.2). Older Resolve builds

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "davinci-resolve-mcp",
-  "version": "2.193.0",
+  "version": "2.194.0",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/resolve-advanced/server/editorial.mjs

@@ -841,7 +841,11 @@ function pairEvents(oldEvents, newEvents, recTol = 1) {
  * opts.sourceAliases ({from,to} | {pattern,replace}) rename old sources first, a
  * systematic rename is inferred from same-window unpaired cuts (opts.inferAliases
  * !== false) and reported in sourceAliases, and a constant per-source source-window
- * shift witnessed on ≥2 cuts is a TC rebase (sourceTcOffsets), not trims.
+ * shift witnessed on ≥2 cuts is a TC rebase (sourceTcOffsets), not trims. A cut moved
+ * INSIDE an unchanged dissolve span with both source windows sliding by the same delta
+ * is one junction_realigned (E142) — a consequence — and two labels of one transition
+ * family are a relabel (transitionRelabels), so a picture-identical conform reads
+ * shape 'equivalent'.
  * PLUS per-junction {kind: transition_added|transition_dropped|transition_changed}
  * (fade 'in'/'out' or null for a dissolve). Zero-length carrier lines and the
  * black legs that carry fades fold into the junction diff instead of reading
@@ -1028,10 +1032,60 @@ function diffChangelistOnce(oldEvents, newEvents, opts = {}) {
     }
   }
 
+  // JUNCTION REALIGN (E142): a cut that moved INSIDE an unchanged dissolve
+  // span, with the incoming's source in and the outgoing's source out
+  // sliding by the same amount, shows the identical picture — the dissolve
+  // covers the same record frames from the same media either way. Premiere
+  // keeps a fractional alignment (its cut sat 12 frames into a 46-frame
+  // span); Resolve's conform re-centred it (23). Measured on a real reel: 9
+  // of 10 residual 'moved' cuts were this, the tenth a real edit (its span
+  // moved too). Fold each into one junction_realigned — a consequence, not
+  // an edit — and let the junction diff read the pre-roll change as the
+  // same fact.
+  const realigned = new Set();
+  const pairAtIn = (recIn, track) => P.pairs.find((pr) => pr.oe.track === track && pr.oe.recIn === recIn);
+  const pairAtOut = (recOut, track) => P.pairs.find((pr) => pr.oe.track === track && pr.oe.recOut === recOut);
+  for (const ot of P.old.transitions) {
+    const nt = P.new.transitions.find((t) => t.track === ot.track && Math.abs(t.start - ot.start) <= recTol && Math.abs(t.end - ot.end) <= recTol);
+    if (!nt) continue;
+    const delta = nt.junction - ot.junction;
+    if (!delta) continue;
+    const inc = pairAtIn(ot.junction, ot.track), out = pairAtOut(ot.junction, ot.track);
+    if (!inc || inc.ne.recIn !== nt.junction) continue;
+    // The source slides by the cut delta at the clip's speed (a retimed
+    // incoming at 80% slides 6 source frames for an 8-frame cut move —
+    // measured on the reel's V3 fade-in); a TC-rebased outgoing is read
+    // through its offset.
+    const slide = (ev) => Math.round(delta * ((ev.speed ?? 100) / 100));
+    const near = (a, b) => a != null && b != null && Math.abs(a - b) <= 1;
+    const offOf = (ev) => (tcOffsets.get(String(ev.source ?? '')) ? tcOffsets.get(String(ev.source ?? '')).offset : 0);
+    const incOk = near(inc.ne.srcIn - (inc.oe.srcIn + offOf(inc.ne)), slide(inc.ne)) && near(inc.ne.srcOut, inc.oe.srcOut + offOf(inc.ne));
+    const outOk = !out || (out.ne.recOut === nt.junction
+      && near(out.ne.srcOut - (out.oe.srcOut + offOf(out.ne)), slide(out.ne))
+      && near(out.ne.srcIn, out.oe.srcIn == null ? null : out.oe.srcIn + offOf(out.ne)));
+    if (!incOk || !outOk) continue;
+    const isMoveOfInc = (c) => c.kind === 'moved' && c.track === ot.track && c.oldRecIn === inc.oe.recIn && c.newRecIn === inc.ne.recIn;
+    const isTrimOfOut = (c) => out && c.kind === 'trimmed' && c.track === ot.track && c.oldRecIn === out.oe.recIn && c.newRecIn === out.ne.recIn;
+    const before = changes.length;
+    for (let i = changes.length - 1; i >= 0; i--) if (isMoveOfInc(changes[i]) || isTrimOfOut(changes[i])) changes.splice(i, 1);
+    if (changes.length === before && !P.pairs.includes(inc)) continue;
+    realigned.add(`${nt.track}|${nt.junction}`);
+    // Both sides show the same picture: they are retained cuts, not edits.
+    for (const pr of [inc, out]) if (pr && !retained.includes(pr.ne)) retained.push(pr.ne);
+    changes.push({
+      kind: 'junction_realigned', track: ot.track, oldRecIn: ot.junction, newRecIn: nt.junction, delta,
+      span: [nt.start, nt.end], outgoing: nt.outgoing, incoming: nt.incoming, type: nt.type, duration: nt.duration,
+    });
+  }
+
   // Junction diff: a transition is identified by what it joins (track,
   // outgoing, incoming, fade side) and pairs with the closest junction; only
   // its SHAPE (duration / type / pre-roll) makes a change — a junction that
-  // travelled with its clips is the clips' move, already reported.
+  // travelled with its clips is the clips' move, already reported. Two
+  // labels for one effect family ("Cross Dissolve (Legacy)" in Premiere,
+  // "Cross Dissolve" in Resolve — E142) are a relabel, not a change.
+  const typeFamily = (t) => String(t ?? '').toLowerCase().replace(/\(legacy\)/g, '').replace(/^(video|audio)\s+/, '').replace(/\s+/g, ' ').trim();
+  const relabels = [];
   const tKey = (t) => `${t.track}|${t.outgoing ?? ''}|${t.incoming}|${t.fade ?? 'x'}`;
   const tPool = P.old.transitions.map((t) => ({ t, used: false }));
   const tDesc = (t) => ({ track: t.track, outgoing: t.outgoing, incoming: t.incoming, fade: t.fade, type: t.type, duration: t.duration });
@@ -1046,8 +1100,11 @@ function diffChangelistOnce(oldEvents, newEvents, opts = {}) {
     const ot = cands[0].t;
     const deltas = {};
     if (ot.duration !== nt.duration) deltas.duration = { old: ot.duration, new: nt.duration };
-    if (String(ot.type) !== String(nt.type)) deltas.type = { old: ot.type, new: nt.type };
-    if (ot.pre !== nt.pre) deltas.pre = { old: ot.pre, new: nt.pre };
+    if (String(ot.type) !== String(nt.type)) {
+      if (typeFamily(ot.type) === typeFamily(nt.type)) relabels.push({ track: nt.track, junction: nt.junction, old: ot.type, new: nt.type });
+      else deltas.type = { old: ot.type, new: nt.type };
+    }
+    if (ot.pre !== nt.pre && !realigned.has(`${nt.track}|${nt.junction}`)) deltas.pre = { old: ot.pre, new: nt.pre };
     if (Object.keys(deltas).length) {
       changes.push({
         kind: 'transition_changed', ...tDesc(nt), oldRecIn: ot.junction, newRecIn: nt.junction,
@@ -1073,16 +1130,19 @@ function diffChangelistOnce(oldEvents, newEvents, opts = {}) {
   // appeared with the cuts it joins) is a consequence, not an edit.
   const touches = (kind, junction, track) => changes.some((c) => c.kind === kind && c.track === track
     && ((kind === 'gone' ? [c.oldRecIn, c.oldRecOut] : [c.newRecIn, c.newRecOut]).some((v) => Math.abs((v ?? -1e9) - junction) <= recTol)));
-  const consequential = (c) => (c.kind === 'transition_dropped' && touches('gone', c.oldRecIn, c.track))
+  const consequential = (c) => c.kind === 'junction_realigned'
+    || (c.kind === 'transition_dropped' && touches('gone', c.oldRecIn, c.track))
     || (c.kind === 'transition_added' && touches('new', c.newRecIn, c.track));
   const edits = changes.filter((c) => c.kind !== 'gone' && c.kind !== 'new' && !consequential(c)).length;
   const gone = counts.gone || 0, added = counts.new || 0;
   const oldCuts = P.old.cuts.length + skipOld.size, newCuts = P.new.cuts.length + skipNew.size;
   let shape = 'edit';
   if (!changes.length) shape = 'identical';
+  else if (!edits && !gone && !added) shape = 'equivalent';
   else if (!edits && gone && !added && retained.length) shape = 'subset';
   else if (!edits && added && !gone && retained.length) shape = 'superset';
   const shapeInfo = { shape, retained: retained.length, oldCuts, newCuts };
+  if (shape === 'equivalent') shapeInfo.note = `same picture: ${counts.junction_realigned || 0} junction(s) re-aligned inside unchanged dissolves${relabels.length ? `, ${relabels.length} transition label(s) differ` : ''} — nothing edited`;
   if (shape === 'subset' || shape === 'superset') {
     const of = shape === 'subset' ? oldCuts : newCuts;
     shapeInfo.sparse = retained.length / Math.max(1, of) < 0.5;
@@ -1097,6 +1157,7 @@ function diffChangelistOnce(oldEvents, newEvents, opts = {}) {
     carriersFolded: { old: P.old.carriers.length, new: P.new.carriers.length },
     ...shapeInfo,
     sourceTcOffsets: [...tcOffsets.values()].map((t) => ({ source: t.source, offset: t.offset, cuts: t.cuts, rebased: t.rebased })),
+    transitionRelabels: relabels.slice(0, 200),
     gate: 'review',
     __P: P,
   };

package/resolve-advanced/server/tools/editorial.mjs

@@ -90,7 +90,7 @@ const markerSchema = z.object({
 export const editorialTool = {
   name: 'editorial',
   description:
-    'Editorial integrity (Cluster E) — turnover interchange → normalized events → changelist + conform manifest with TIMING silent-lie guards (flattened retime / dropped J/L-cut audio / framerate-pulldown slip / reverse dropped / transition-handle starvation → flag, skip-not-fake). Report-only (gate: review). Actions: parse_interchange (EDL/OTIO/XMEML natively — incl. Resolve-written OTIO generator clips (a Solid Color is a Clip with a NULL media_reference; it walks as a BL leg with generatorName, and an OTIO GeneratorReference carries its colour) and nested OTIO Stacks (compound clips — Resolve\'s writer nests them with a trim window) FLATTEN into record time with fromCompound on each cut, so Resolve\'s own OTIO exports re-conform (its FCP7 XML writer flattens a compound to ONE media-less clipitem instead — tagged `compound`, which the bridge drops with a reason in unresolvedCompounds unless the sourceMap maps the compound name to a flattened media file), Resolve-written FCP7 -1 junction edges (paired in record order) + Solid Color / Color Matte generators carrying their `fillcolor` (BL legs with `color` → fade-to-white and colour mattes author, E110), XMEML audio-track transitionitems as audio cross-fades on numbered lanes A/A2/…, and CMX FROM/TO CLIP NAME comments over the generic AX reel — + AAF via pyaaf2 (flat sound/picture slots number A/A2/… and V/V2/… in slot order so separate beds keep their lanes; NestedScope layers keep layer numbering; a NESTED SEQUENCE used as a clip — a SourceClip referencing a named CompositionMob — flattens through its reference window with fromCompound, like OTIO Stacks) + PRPROJ via gunzip+XML (real Premiere 2025 files — uuid ObjectUID/ObjectURef graph, TrackGroups, ClipTrackItem→SubClip→VideoClip→MediaSource→Media chain, zeros written as absence — and the legacy ObjectID/VideoTracks shape both walk; measured on a 739-sequence turnover that used to list ZERO; a NESTED SEQUENCE used as a clip — Source = Video/AudioSequenceSource → Sequence — flattens through its in-point window with fromCompound, like OTIO Stacks and AAF nested compositions; 13,711 such events on one real reels project; real transitions live in the track\'s TransitionItems list — read alongside ClipItems, attached with their DisplayName as type, HasOutgoingClip/HasIncomingClip false = fade from/to black or silence; tracks number as lanes V/V2…/A/A2… and a flattened nested sequence\'s inner lanes first-fit above what the parent already stacks — laneShift records the shift; markers are the sequence\'s OWN, read from Premiere\'s DVAMarker JSON) → normalized events incl. span-explicit transitions, BL fade legs, and freezes as zero-speed events (OTIO FreezeFrame, XMEML timeremap 0, PrProj in==out, AAF 0% motion effects); for AAF/PRPROJ/DRT/DRP pass the file PATH as content; DRT/DRP walk ONE timeline (`timeline` = pool name or index; default the first timeline-kind container) into events with sequence-relative record positions + the returned startFrame/startTimecode/fps read from the pool sequence — <In> is the source in-point (EMPTY on real audio clips → srcInAbsent), a keyed MediaTimemapBA Sm2TimeMap decodes to the speed (E140: the four retimed clips of a real reel read 80 — Premiere\'s 80 for the same cuts — with srcOut following the record window at that speed; XMax 60000 + zero slope = a freeze → the zero-speed in==out event; a negative slope = reverse; a map the decoder cannot read stays speed null + retimeUnknown, never faked to 100%), Sm2TiTransition alignment 2 centres on the cut and 3 ends at it — so two Resolve timeline VERSIONS diff through turnover_changelist (E139); AAF also returns per-sequence startTimecode/startFrame — build the timeline at THAT start, not the Resolve 01:00:00:00 default — and per-clip `geometry` for Avid transform effects), list_sequences (ONE offline picker entry point across xml/edl/otio/drt/drp/aaf/prproj → [{id,name,eventCount}], plus startTimecode/startFrame for AAF and nestedIn — an AAF composition another composition uses as a clip is NESTED in it; offer the parent, its cuts arrive flattened), convert_to_interchange (author OTIO/EDL/DRT Resolve CAN import from events or a parsed source; the EDL target writes CMX transition pairs incl. BL fades — the .prproj→Resolve conform bridge, no Premiere needed; editorial timing/transitions survive and per-clip effects/color do not. SPEED/REVERSE survive on the otio (LinearTimeWarp) and edl (M2) targets ONLY — this FLAT drt target flattens every retime to 100% forward and returns `flattened`/`flattenedCount` naming each event that lost one (`flattened` is always present on `drt`, empty when there were none); for a .drt that AUTHORS retimes/dissolves/multi-track/audio, use drt.assemble_from_interchange), turnover_changelist (diff old vs new → a SHAPE verdict first — identical | subset (new keeps some of old\'s cuts unchanged in place and nothing else: a patch/selects reel of the same cut, NOT N deletions; a real Premiere auto-save kept 3 of 335) | superset (the reverse) | edit — with retained/oldCuts/newCuts, `sparse` and the retainedWindows for subset/superset, a transition that vanished or appeared with the cuts it joins counting as a consequence not an edit; RELINK-AWARE (E141): sourceAliases ({from,to} | {pattern,replace}) rename old sources before pairing, a systematic rename is INFERRED from unpaired cuts sharing a record window (one-to-one, recurring or clearly the same name) and reported in sourceAliases — a real offline→online turnover paired 15 of 228 cuts until the "4K-2K" proxies aliased to the "4K" masters, then 186 — and a constant per-source source-window shift witnessed on ≥2 cuts is a TC REBASE (sourceTcOffsets), not trims; then moved/retimed/trimmed/replaced/new/gone PLUS the junction diff: transition_added/transition_dropped/transition_changed with fade in/out or dissolve, outgoing/incoming, span and duration/type/pre-roll deltas — zero-length CMX carrier lines and the BL legs that carry fades fold into the junction diff instead of reading as gone/new sources; events pair by closest record position, consumed once, so a source cut twice at two speeds compares instance to instance; + timing flags incl. transition_dropped and dropped_split_audio on any A-track; a compound seen collapsed in one cut and flattened in the other reports compound_collapsed/compound_expanded once, never replaced+gone), conform_manifest (per-event assert: source resolved/handles/retime/reverse/TC-base; BL-aware — black legs need no source, fades no black-side handles, and a fade-out tail requirement lands on the picture source; a compound clipitem fails source_resolved by NAME with the remedy — map it to a flattened file or turn over as OTIO), marker_roundtrip (markers with provenance tags), verify_roundtrip (input events vs re-export events -> pass/mismatches + fitted per-source TC offsets + marker compare w/ markersNotInExport honesty flag; FADE-AWARE: BL/Solid-Color legs merge out as blackSegments and fade-window boundary reshapes are excused into fadeReshapedBoundaries instead of failing; RETIME-AWARE: speed/reverse compare pairwise — EXPORT_OTIO carries an authored Sm2TimeMap back as LinearTimeWarp (measured), so a flattened/lost retime fails as drift geometry alone cannot catch; AUDIO-AWARE: declared audio events compare (a video-only export such as EXPORT_EDL flags audioNotInExport instead of failing) (channel legs deduped, mismatches tagged trackType audio) while the mirrored-A1 export of a video-only turnover stays informational; COLOUR-AWARE: an input generator leg carrying a fillcolor (fade-to-white, colour matte) must come back on the same track over its span with the same colour — Resolve\'s FCP7 writer emits it — else generator-colour fails (generatorColours reports the compare) — pass exportedFormat: an OTIO/EDL re-export cannot carry colour (measured) and reports generatorColourNotInExport instead of failing; COMPOUND-AWARE: an XML re-export that collapsed a compound to one clipitem over cuts the input flattened from that compound reports compoundsCollapsedInExport instead of count/source drift; the conform QC loop-closer). Offline (AAF needs pyaaf2; live AAF/DRP import is on the Python davinci-resolve MCP).',
+    'Editorial integrity (Cluster E) — turnover interchange → normalized events → changelist + conform manifest with TIMING silent-lie guards (flattened retime / dropped J/L-cut audio / framerate-pulldown slip / reverse dropped / transition-handle starvation → flag, skip-not-fake). Report-only (gate: review). Actions: parse_interchange (EDL/OTIO/XMEML natively — incl. Resolve-written OTIO generator clips (a Solid Color is a Clip with a NULL media_reference; it walks as a BL leg with generatorName, and an OTIO GeneratorReference carries its colour) and nested OTIO Stacks (compound clips — Resolve\'s writer nests them with a trim window) FLATTEN into record time with fromCompound on each cut, so Resolve\'s own OTIO exports re-conform (its FCP7 XML writer flattens a compound to ONE media-less clipitem instead — tagged `compound`, which the bridge drops with a reason in unresolvedCompounds unless the sourceMap maps the compound name to a flattened media file), Resolve-written FCP7 -1 junction edges (paired in record order) + Solid Color / Color Matte generators carrying their `fillcolor` (BL legs with `color` → fade-to-white and colour mattes author, E110), XMEML audio-track transitionitems as audio cross-fades on numbered lanes A/A2/…, and CMX FROM/TO CLIP NAME comments over the generic AX reel — + AAF via pyaaf2 (flat sound/picture slots number A/A2/… and V/V2/… in slot order so separate beds keep their lanes; NestedScope layers keep layer numbering; a NESTED SEQUENCE used as a clip — a SourceClip referencing a named CompositionMob — flattens through its reference window with fromCompound, like OTIO Stacks) + PRPROJ via gunzip+XML (real Premiere 2025 files — uuid ObjectUID/ObjectURef graph, TrackGroups, ClipTrackItem→SubClip→VideoClip→MediaSource→Media chain, zeros written as absence — and the legacy ObjectID/VideoTracks shape both walk; measured on a 739-sequence turnover that used to list ZERO; a NESTED SEQUENCE used as a clip — Source = Video/AudioSequenceSource → Sequence — flattens through its in-point window with fromCompound, like OTIO Stacks and AAF nested compositions; 13,711 such events on one real reels project; real transitions live in the track\'s TransitionItems list — read alongside ClipItems, attached with their DisplayName as type, HasOutgoingClip/HasIncomingClip false = fade from/to black or silence; tracks number as lanes V/V2…/A/A2… and a flattened nested sequence\'s inner lanes first-fit above what the parent already stacks — laneShift records the shift; markers are the sequence\'s OWN, read from Premiere\'s DVAMarker JSON) → normalized events incl. span-explicit transitions, BL fade legs, and freezes as zero-speed events (OTIO FreezeFrame, XMEML timeremap 0, PrProj in==out, AAF 0% motion effects); for AAF/PRPROJ/DRT/DRP pass the file PATH as content; DRT/DRP walk ONE timeline (`timeline` = pool name or index; default the first timeline-kind container) into events with sequence-relative record positions + the returned startFrame/startTimecode/fps read from the pool sequence — <In> is the source in-point (EMPTY on real audio clips → srcInAbsent), a keyed MediaTimemapBA Sm2TimeMap decodes to the speed (E140: the four retimed clips of a real reel read 80 — Premiere\'s 80 for the same cuts — with srcOut following the record window at that speed; XMax 60000 + zero slope = a freeze → the zero-speed in==out event; a negative slope = reverse; a map the decoder cannot read stays speed null + retimeUnknown, never faked to 100%), Sm2TiTransition alignment 2 centres on the cut and 3 ends at it — so two Resolve timeline VERSIONS diff through turnover_changelist (E139); AAF also returns per-sequence startTimecode/startFrame — build the timeline at THAT start, not the Resolve 01:00:00:00 default — and per-clip `geometry` for Avid transform effects), list_sequences (ONE offline picker entry point across xml/edl/otio/drt/drp/aaf/prproj → [{id,name,eventCount}], plus startTimecode/startFrame for AAF and nestedIn — an AAF composition another composition uses as a clip is NESTED in it; offer the parent, its cuts arrive flattened), convert_to_interchange (author OTIO/EDL/DRT Resolve CAN import from events or a parsed source; the EDL target writes CMX transition pairs incl. BL fades — the .prproj→Resolve conform bridge, no Premiere needed; editorial timing/transitions survive and per-clip effects/color do not. SPEED/REVERSE survive on the otio (LinearTimeWarp) and edl (M2) targets ONLY — this FLAT drt target flattens every retime to 100% forward and returns `flattened`/`flattenedCount` naming each event that lost one (`flattened` is always present on `drt`, empty when there were none); for a .drt that AUTHORS retimes/dissolves/multi-track/audio, use drt.assemble_from_interchange), turnover_changelist (diff old vs new → a SHAPE verdict first — identical | subset (new keeps some of old\'s cuts unchanged in place and nothing else: a patch/selects reel of the same cut, NOT N deletions; a real Premiere auto-save kept 3 of 335) | superset (the reverse) | edit — with retained/oldCuts/newCuts, `sparse` and the retainedWindows for subset/superset, a transition that vanished or appeared with the cuts it joins counting as a consequence not an edit; RELINK-AWARE (E141): sourceAliases ({from,to} | {pattern,replace}) rename old sources before pairing, a systematic rename is INFERRED from unpaired cuts sharing a record window (one-to-one, recurring or clearly the same name) and reported in sourceAliases — a real offline→online turnover paired 15 of 228 cuts until the "4K-2K" proxies aliased to the "4K" masters, then 186 — and a constant per-source source-window shift witnessed on ≥2 cuts is a TC REBASE (sourceTcOffsets), not trims; a cut moved INSIDE an unchanged dissolve span with the incoming\'s source-in and the outgoing\'s source-out sliding by the same delta is ONE junction_realigned (E142: Premiere keeps a fractional alignment, Resolve\'s conform re-centres it — 9 of 10 residual moves on a real reel were this; same picture, a consequence not an edit) and two labels of one transition family ("Cross Dissolve (Legacy)" vs "Cross Dissolve") are a relabel in transitionRelabels, so a picture-identical conform reads shape `equivalent`; then moved/retimed/trimmed/replaced/new/gone PLUS the junction diff: transition_added/transition_dropped/transition_changed with fade in/out or dissolve, outgoing/incoming, span and duration/type/pre-roll deltas — zero-length CMX carrier lines and the BL legs that carry fades fold into the junction diff instead of reading as gone/new sources; events pair by closest record position, consumed once, so a source cut twice at two speeds compares instance to instance; + timing flags incl. transition_dropped and dropped_split_audio on any A-track; a compound seen collapsed in one cut and flattened in the other reports compound_collapsed/compound_expanded once, never replaced+gone), conform_manifest (per-event assert: source resolved/handles/retime/reverse/TC-base; BL-aware — black legs need no source, fades no black-side handles, and a fade-out tail requirement lands on the picture source; a compound clipitem fails source_resolved by NAME with the remedy — map it to a flattened file or turn over as OTIO), marker_roundtrip (markers with provenance tags), verify_roundtrip (input events vs re-export events -> pass/mismatches + fitted per-source TC offsets + marker compare w/ markersNotInExport honesty flag; FADE-AWARE: BL/Solid-Color legs merge out as blackSegments and fade-window boundary reshapes are excused into fadeReshapedBoundaries instead of failing; RETIME-AWARE: speed/reverse compare pairwise — EXPORT_OTIO carries an authored Sm2TimeMap back as LinearTimeWarp (measured), so a flattened/lost retime fails as drift geometry alone cannot catch; AUDIO-AWARE: declared audio events compare (a video-only export such as EXPORT_EDL flags audioNotInExport instead of failing) (channel legs deduped, mismatches tagged trackType audio) while the mirrored-A1 export of a video-only turnover stays informational; COLOUR-AWARE: an input generator leg carrying a fillcolor (fade-to-white, colour matte) must come back on the same track over its span with the same colour — Resolve\'s FCP7 writer emits it — else generator-colour fails (generatorColours reports the compare) — pass exportedFormat: an OTIO/EDL re-export cannot carry colour (measured) and reports generatorColourNotInExport instead of failing; COMPOUND-AWARE: an XML re-export that collapsed a compound to one clipitem over cuts the input flattened from that compound reports compoundsCollapsedInExport instead of count/source drift; the conform QC loop-closer). Offline (AAF needs pyaaf2; live AAF/DRP import is on the Python davinci-resolve MCP).',
   async handler({ action, args }) {
     if (action === 'parse_interchange') {
       const p = parseSchema.parse(args);

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.193.0"
+VERSION = "2.194.0"
 logger = logging.getLogger("davinci-resolve-mcp")
 logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION}")
 logger.info(f"Detected platform: {get_platform()}")

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 353-tool granular server instead
 """
 
-VERSION = "2.193.0"
+VERSION = "2.194.0"
 
 import base64
 import os