davinci-resolve-mcp 2.161.0 → 2.163.0

package/CHANGELOG.md

@@ -2,6 +2,57 @@
 
 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.163.0 — E105: QC through every export format
+
+One faded, dissolved, retimed conform exported from Resolve three ways — OTIO,
+FCP7 XML, and CMX EDL — and pushed through `editorial.verify_roundtrip`. All
+three now close `pass: true`; getting there measured four laws of Resolve's own
+writers and fixed the parsers to match.
+
+### Fixed
+
+- **Every FCP7-XML retime read as a FREEZE**: Resolve's timeremap effect
+  writes `speed` 50 followed by `variablespeed` 0, and a loose `/speed/`
+  parameter match let the second overwrite the first. Exact parameter
+  matching now, with the `reverse` flag read alongside.
+- **FCP7 `-1` clip edges** (transition-adjacent) are resolved to the
+  transition's junction — the span center for `center` alignment — with the
+  clip's `in` advanced by the overlap offset so source stays record-aligned;
+  `out - in` is the record duration even under a retime. Solid Color
+  `generatoritem`s walk as black legs, and fade transitions attach to the
+  picture rather than the black.
+- **CMX EDL exports name every file source reel `AX`** with the real names in
+  `* FROM/TO CLIP NAME` comments; `parseEDL` now applies them (TO = incoming,
+  FROM = outgoing of a dissolve pair), keeping specific reels intact.
+- **`timeline.export_timeline_checked` refuses unresolved export constants
+  loudly.** A made-up `EXPORT_CMX_3600` reached `Timeline.Export` as a string
+  and came back as a bare `success: false`; the real constant is `EXPORT_EDL`,
+  and the refusal now lists the vocabulary.
+
+### Added
+
+- `verify_roundtrip` reports `audioNotInExport` when the export carries no
+  audio at all (Resolve's EDL writer is video-only — measured) instead of
+  failing, mirroring `markersNotInExport`.
+
+### Measured (filed in api-limitations)
+
+- `EXPORT_EDL` is video-only, writes reel `AX` + clip-name comments, places
+  dissolve junctions at the CMX start-at-cut position, and writes the BL
+  fades its own importer drops.
+
+## What's New in v2.162.0 — freeze parity: Avid 0% motion effects are freezes
+
+### Fixed
+
+- **An Avid freeze frame silently read as a 100% clip.** A motion effect at
+  0% (`PARAM_SPEED_RATIO_U 0.0`, or a flat speed map at 0) fell into the AAF
+  walker's "no play rate recoverable" branch, and the freeze vanished. An
+  explicit zero now reports `speed: 0, freeze: true`, and the bridge authors
+  the real freeze — completing freeze parity across all five ingest formats
+  (EDL `M2 000.0`, OTIO `FreezeFrame`, XMEML `timeremap` 0, PrProj
+  `InPoint == OutPoint`, and now AAF).
+
 ## What's New in v2.161.0 — OTIO freeze frames close the loop
 
 ### Fixed

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.161.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.163.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.161.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.163.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.161.0 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
+> 本翻译对应 v2.163.0 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
 
 一个 Model Context Protocol (MCP) 服务器，让 AI 助手通过官方脚本 API 控制 DaVinci Resolve Studio（达芬奇）。它提供完整的 API 覆盖，外加带护栏的工作流助手，涵盖剪辑、媒体池整理、渲染设置、审阅标记、调色、Fusion、Fairlight、项目生命周期任务、扩展开发，以及不碰源媒体的媒体分析。
 

package/docs/reference/api-limitations.md

@@ -12,7 +12,7 @@ that none exists).
 
 **Verified on:** DaVinci Resolve Studio 21.0.2
 
-**Totals:** 35 missing capabilities, 50 bugs / unreliable behaviors.
+**Totals:** 36 missing capabilities, 50 bugs / unreliable behaviors.
 
 The authoritative source is the runtime-queryable `api_truth` ledger
 (`resolve_control api_truth "<query>"`); this document is generated from
@@ -301,6 +301,14 @@ equivalent, blocking full automation.
 - **Workaround / current handling:** Read item.GetNodeGraph().GetNumNodes() before SetCDL and diagnose a False against the node count and clip type. Prove the applied look with a rendered frame (gallery_stills grab_and_export or Project.ExportCurrentFrameAsStill), not the return value.
 - **Tags:** color, cdl, readback, silent-failure
 
+### Timeline.Export EXPORT_EDL (video-only, reel AX, clip-name comments)
+
+- **Object:** `Timeline`
+- **Signature:** `(filePath, EXPORT_EDL, EXPORT_NONE) -> bool`
+- **Behavior:** Resolve's CMX EDL writer (measured on Studio 19.1.3.7, E105) emits VIDEO events only — audio legs never appear; names every file source by the generic reel AX and carries the real names in `* FROM CLIP NAME:` / `* TO CLIP NAME:` comments; writes black legs as reel BL; places dissolve junctions at the CMX start-at-cut position (the overlap start, not the centered junction the timeline holds); and WRITES BL fades that its own EDL importer then drops. The FCP7 XML writer, by contrast, carries audio, writes transition-adjacent clip edges as -1 (the junction), and emits `speed` followed by `variablespeed` 0 in the same timeremap effect.
+- **Workaround / current handling:** For round-trip QC prefer EXPORT_OTIO (carries audio, retimes as LinearTimeWarp/FreezeFrame, exact spans). When an EDL is the required deliverable, expect no audio (editorial.verify_roundtrip reports audioNotInExport) and resolve AX reels through the clip-name comments (parseEDL does). Use EXPORT_EDL — there is no EXPORT_CMX_3600 constant, and an unknown name reaches Export as a string that returns a bare False (timeline.export_timeline_checked now refuses it loudly).
+- **Tags:** timeline, export, edl, audio, silent-failure
+
 ## Bugs / Unreliable Behavior (please fix)
 
 Methods that exist but misbehave — silent failures, unreliable return

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.161.0"
+VERSION = "2.163.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.161.0",
+  "version": "2.163.0",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/resolve-advanced/server/aaf_probe.py

@@ -726,6 +726,11 @@ def _retime_fields(op_group):
     play = None
     speed_map = None
     offset_map = None
+    # An EXPLICIT zero play rate is a freeze (Avid motion effect at 0%,
+    # E104): PARAM_SPEED_RATIO_U == 0.0 or a flat PARAM_SPEED_MAP_U at 0.
+    # It must not read as "nothing recoverable" — a freeze that silently
+    # became 100% is the loudest timing lie of all.
+    zero_seen = False
     length = _length(op_group)
     for param in _op_parameters(op_group):
         cls = type(param).__name__
@@ -754,6 +759,8 @@ def _retime_fields(op_group):
                 continue
             if value:
                 play = value  # *_U family stores the play rate directly
+            else:
+                zero_seen = True
     curve = {}
     for key, param in (("playRate", speed_map), ("sourceOffset", offset_map)):
         if param is None:
@@ -782,7 +789,11 @@ def _retime_fields(op_group):
             return {"speedVarying": True, **extra}
         if play is None and values and values[0]:
             play = values[0]  # a flat map's single value IS the constant play rate
+        elif play is None and values and values[0] == 0:
+            zero_seen = True
     if not play:
+        if zero_seen:
+            return {"speedRatio": 0.0, "speed": 0, "reverse": False, "freeze": True, **extra}
         return extra
     return {
         "speedRatio": round(abs(play), 6),

package/resolve-advanced/server/author-interchange.mjs

@@ -990,7 +990,14 @@ export function verifyRoundtrip(inputEvents, exportedEvents, opts = {}) {
   const aa = dedupeAud(norm(inputEvents, audsOf).filter((e) => !isBlackSeg(e)));
   const ba = dedupeAud(norm(exportedEvents, audsOf).filter((e) => !isBlackSeg(e)));
   let audio;
-  if (aa.length) {
+  let audioNotInExport = false;
+  if (aa.length && !ba.length) {
+    // The export carries NO audio at all while the input declares some: a
+    // capability gap (Resolve's EXPORT_EDL is video-only, measured E105),
+    // reported as audioNotInExport rather than failed — like markers.
+    audio = { input: aa.length, exported: 0, compared: false, note: 'export carries no audio events (format capability, e.g. EDL is video-only) — not compared' };
+    audioNotInExport = true;
+  } else if (aa.length) {
     audio = { input: aa.length, exported: ba.length, compared: true };
     comparePairs(aa, ba, junctionsFor(/^A\d*$/), 'audio');
   } else if (ba.length) {
@@ -1033,5 +1040,6 @@ export function verifyRoundtrip(inputEvents, exportedEvents, opts = {}) {
     ...(blackSegments.input || blackSegments.exported ? { blackSegments } : {}),
     ...(fadeReshapedBoundaries.length ? { fadeReshapedBoundaries } : {}),
     ...(audio ? { audio } : {}),
+    ...(audioNotInExport ? { audioNotInExport } : {}),
   };
 }

package/resolve-advanced/server/editorial.mjs

@@ -90,6 +90,29 @@ export function parseEDL(text, opts = {}) {
     // at an absolute record timecode. Emitted as track 'MARKER' pseudo-events
     // (recIn only) so the assemble bridge can author them; consumers that
     // filter video/audio by track shape ignore them.
+    // `* FROM CLIP NAME:` / `* TO CLIP NAME:` comments (E105): Resolve's own
+    // EDL writer names every file source by the generic reel AX and carries
+    // the real clip name here. TO names the incoming (the last event, a D
+    // line's), FROM the outgoing (the event before a transition pair, else
+    // the last event). A generic reel (AX/BL-less) takes the clip name as
+    // its source so sourceMap and QC key on something real; a specific reel
+    // keeps it, with clipName carried alongside.
+    const cn = /^\*\s*(FROM|TO)\s+CLIP\s+NAME:\s*(.+?)\s*$/i.exec(line);
+    if (cn) {
+      const which = cn[1].toUpperCase();
+      const clipName = cn[2];
+      const last = [...events].reverse().find((e) => e.track !== 'MARKER');
+      let target = last;
+      if (which === 'FROM' && last && last.transition) {
+        const prev = [...events].reverse().find((e) => e !== last && e.track === last.track && e.recOut === last.recIn);
+        if (prev) target = prev;
+      }
+      if (target && !/^(BL|BLACK)$/i.test(String(target.source))) {
+        target.clipName = clipName;
+        if (/^AX$/i.test(String(target.source))) target.source = clipName;
+      }
+      continue;
+    }
     const loc = /^\*\s*LOC:\s*(\d{2}:\d{2}:\d{2}[:;]\d{2})\s+(\S+)\s*(.*)$/i.exec(line);
     if (loc) {
       events.push(evt({
@@ -273,36 +296,69 @@ export function parseXMEMLEvents(xml, opts = {}) {
   const events = [];
   let idx = 1;
   const seqRate = opts.fps || 24;
+  let currentJunctions = [];
   const walk = (node, track) => {
     if (!node) return;
     const items = Array.isArray(node) ? node : [node];
     for (const it of items) {
       const name = it.name || (it.file && it.file.name) || 'UNKNOWN';
-      const start = Number(it.start);
-      const end = Number(it.end);
+      const start0 = Number(it.start);
+      const end0 = Number(it.end);
       const inF = Number(it.in);
       const outF = Number(it.out);
       let speed = 100,
         reverse = false;
-      // speed via a timeremap/motion filter (best-effort)
+      // speed via a timeremap/motion filter. EXACT parameter match (E105):
+      // Resolve's own FCP7 writer emits `speed` 50 followed by
+      // `variablespeed` 0 in the same effect, and a loose /speed/ match let
+      // the second overwrite the first — every retime read as a FREEZE.
       const filters = it.filter ? (Array.isArray(it.filter) ? it.filter : [it.filter]) : [];
       for (const fl of filters) {
         const params = fl.effect && fl.effect.parameter ? (Array.isArray(fl.effect.parameter) ? fl.effect.parameter : [fl.effect.parameter]) : [];
         for (const pm of params) {
-          if (/speed/i.test(pm.name || '') && pm.value != null) {
-            speed = Math.abs(Number(pm.value));
-            reverse = Number(pm.value) < 0;
+          const pid = String(pm.parameterid || pm.name || '').trim().toLowerCase();
+          if (pid === 'speed' && pm.value != null && typeof pm.value !== 'object') {
+            const v = Number(pm.value);
+            if (Number.isFinite(v)) { speed = Math.abs(v); reverse = v < 0; }
+          } else if (pid === 'reverse' && /^true$/i.test(String(pm.value))) {
+            reverse = true;
           }
         }
       }
-      if (Number.isFinite(start) && Number.isFinite(end)) {
+      // FCP7 `-1` EDGES (E105, measured against Resolve's own FCP7 writer):
+      // a clipitem edge under a transitionitem is written as -1 and means
+      // "this edge is the adjacent transition's JUNCTION" — the span center
+      // for alignment center, its start/end for start-black/end-black.
+      // `out - in` is the RECORD duration even under a retime (Resolve
+      // writes out = in + record length), which anchors the missing edge.
+      let start = start0;
+      let end = end0;
+      let inAdj = 0;
+      const dur = Number.isFinite(inF) && Number.isFinite(outF) ? outF - inF : null;
+      const junctions = currentJunctions;
+      if (start === -1 && end !== -1 && dur != null) start = end - dur;
+      else if (end === -1 && start !== -1 && dur != null) end = start + dur;
+      else if (start === -1 && end === -1 && dur != null && junctions.length) {
+        const js = junctions.map((j) => j.frame).sort((a, b) => a - b);
+        const pair = js.find((a) => js.includes(a + dur));
+        if (pair != null) { start = pair; end = pair + dur; }
+      }
+      // A -1 START edge's `in` is the source at the OVERLAP start (the
+      // clip's material begins under the transition), while the resolved
+      // start is the junction — so `in` advances by the same offset to stay
+      // record-aligned (measured: srcIn read 12 short without this).
+      if (start0 === -1 && Number.isFinite(start)) {
+        const j = junctions.find((jj) => jj.frame === start);
+        if (j) inAdj = start - j.start;
+      }
+      if (Number.isFinite(start) && Number.isFinite(end) && start >= 0 && end >= 0) {
         // FCP7 clipitem <marker> children are CLIP markers (frames relative
         // to the clip's own <in>) — routed to item markers like OTIO's (E81).
         const mks = it.marker ? (Array.isArray(it.marker) ? it.marker : [it.marker]) : [];
         const itemMarkers = mks
           .filter((mk) => Number.isFinite(Number(mk.in)))
           .map((mk) => ({ frame: Number(mk.in) - inF, name: mk.name != null ? String(mk.name) : undefined, note: mk.comment != null ? String(mk.comment) : undefined }));
-        events.push(evt({ index: idx++, track, source: name, srcIn: inF, srcOut: outF, recIn: start, recOut: end, speed, reverse, itemMarkers: itemMarkers.length ? itemMarkers : undefined, fps: seqRate }));
+        events.push(evt({ index: idx++, track, source: name, srcIn: Number.isFinite(inF) ? inF + inAdj : inF, srcOut: Number.isFinite(outF) ? outF + inAdj : outF, recIn: start, recOut: end, speed, reverse, itemMarkers: itemMarkers.length ? itemMarkers : undefined, fps: seqRate }));
       }
     }
   };
@@ -313,7 +369,24 @@ export function parseXMEMLEvents(xml, opts = {}) {
     vtracks.forEach((t, vi) => {
       const label = vi === 0 ? 'V' : `V${vi + 1}`;
       const before = events.length;
+      // Junctions of this track's transitionitems, for -1 edge resolution.
+      const tlist = t.transitionitem ? (Array.isArray(t.transitionitem) ? t.transitionitem : [t.transitionitem]) : [];
+      currentJunctions = tlist.map((tr) => {
+        const s0 = Number(tr.start), e0 = Number(tr.end);
+        if (!Number.isFinite(s0) || !Number.isFinite(e0)) return null;
+        const al = String(tr.alignment || 'center').toLowerCase();
+        const frame = al === 'start-black' || al === 'start' ? s0 : al === 'end-black' || al === 'end' ? e0 : Math.round((s0 + e0) / 2);
+        return { frame, start: s0, end: e0 };
+      }).filter(Boolean);
+      // Solid Color generatoritems are BLACK legs (what Resolve writes for a
+      // fade's black side); they walk as BL events so fades round-trip.
+      const gens = t.generatoritem ? (Array.isArray(t.generatoritem) ? t.generatoritem : [t.generatoritem]) : [];
+      for (const g of gens) {
+        if (!/solid color|black/i.test(String(g.name || ''))) continue;
+        walk([{ ...g, name: 'BL', filter: undefined, marker: undefined }], label);
+      }
       if (t.clipitem) walk(t.clipitem, label);
+      currentJunctions = [];
       // <transitionitem> siblings: attach each to the INCOMING clip event —
       // the one whose record-in falls inside the transition's span. Resolve's
       // OWN XMEML importer writes these as elements that render INERT on
@@ -326,7 +399,11 @@ export function parseXMEMLEvents(xml, opts = {}) {
         const s = Number(tr.start), e2 = Number(tr.end);
         if (!Number.isFinite(s) || !Number.isFinite(e2)) continue;
         const effectId = (tr.effect && (tr.effect.effectid || tr.effect.name)) || 'Cross Dissolve';
-        const incoming = events.slice(before).find((ev) => ev.track === label && ev.recIn > s - 1 && ev.recIn <= e2);
+        const isBLev = (ev) => /^(BL|BLACK)$/i.test(String(ev.source || '').trim());
+        const inSpan = (ev) => ev.track === label && ev.recIn > s - 1 && ev.recIn <= e2;
+        // Prefer the PICTURE as the incoming: a Solid Color generatoritem in
+        // the same span is the fade's black side, not the clip fading in.
+        const incoming = events.slice(before).find((ev) => inSpan(ev) && !isBLev(ev)) || events.slice(before).find(inSpan);
         // recStart carries the transitionitem's EXPLICIT record span start
         // (sequence-relative) so the bridge reproduces the editor's actual
         // alignment instead of assuming centered.

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

@@ -86,7 +86,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 + AAF via pyaaf2 + PRPROJ via gunzip+XML → normalized events incl. span-explicit transitions, BL fade legs, and OTIO FreezeFrame effects as zero-speed freezes; for AAF/PRPROJ pass the file PATH as content; 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), 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 → moved/retimed/replaced/new/gone + timing flags), 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), 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 (channel legs deduped, mismatches tagged trackType audio) while the mirrored-A1 export of a video-only turnover stays informational; 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 FCP7 -1 junction edges + Solid Color generators, and CMX FROM/TO CLIP NAME comments over the generic AX reel — + AAF via pyaaf2 + PRPROJ via gunzip+XML → 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 pass the file PATH as content; 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), 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 → moved/retimed/replaced/new/gone + timing flags), 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), 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; 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.161.0"
+VERSION = "2.163.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.161.0"
+VERSION = "2.163.0"
 
 import base64
 import os
@@ -6927,6 +6927,26 @@ def _export_timeline_checked(tl, p: Dict[str, Any]):
     # (which can be None and silently degrade the EXPORT_* args to strings — the
     # same failure class as issue #70).
     spec = _timeline_export_spec(p, get_resolve())
+    # An export type that did not resolve to a Resolve constant reaches
+    # Timeline.Export as a STRING, which returns a bare False — reported as
+    # success:false with no reason (measured E105 with a made-up
+    # EXPORT_CMX_3600: the real constant is EXPORT_EDL). Refuse loudly with
+    # the vocabulary instead of letting a typo read as an export failure.
+    # Only when this build exposes the export vocabulary at all (a bare stub
+    # or a degraded connection resolves nothing, and the old passthrough
+    # stays the honest behavior there).
+    _probe_const, _ = _timeline_export_value("EXPORT_OTIO", get_resolve())
+    vocab_known = not isinstance(_probe_const, str)
+    for field in ("export_type", "export_subtype"):
+        val = spec.get(field)
+        if vocab_known and isinstance(val, str) and val.startswith("EXPORT_"):
+            return _err(
+                f"{field} {val!r} is not a Resolve export constant on this build. "
+                f"Known aliases: {', '.join(sorted(_TIMELINE_EXPORT_ALIASES))}; "
+                "constants: EXPORT_AAF, EXPORT_DRT, EXPORT_EDL, EXPORT_FCP_7_XML, "
+                "EXPORT_FCPXML_1_8/1_9/1_10, EXPORT_OTIO (subtypes EXPORT_NONE, "
+                "EXPORT_AAF_NEW, EXPORT_AAF_EXISTING, EXPORT_CDL, EXPORT_SDL, EXPORT_MISSING_CLIPS)."
+            )
     if p.get("dry_run"):
         return _ok(path=path, would_export=True, spec={k: v for k, v in spec.items() if k != "export_type"})
 

package/src/utils/api_truth.py

@@ -2764,6 +2764,36 @@ API_TRUTH: List[Dict[str, Any]] = [
         "submit": "bug",
         "mitigation": ["drt.assemble_from_interchange black-leg authoring"],
     },
+    {
+        "symbol": "Timeline.Export EXPORT_EDL (video-only, reel AX, clip-name comments)",
+        "object": "Timeline",
+        "signature": "(filePath, EXPORT_EDL, EXPORT_NONE) -> bool",
+        "reality": "Resolve's CMX EDL writer (measured on Studio 19.1.3.7, "
+                   "E105) emits VIDEO events only — audio legs never appear; "
+                   "names every file source by the generic reel AX and carries "
+                   "the real names in `* FROM CLIP NAME:` / `* TO CLIP NAME:` "
+                   "comments; writes black legs as reel BL; places dissolve "
+                   "junctions at the CMX start-at-cut position (the overlap "
+                   "start, not the centered junction the timeline holds); and "
+                   "WRITES BL fades that its own EDL importer then drops. The "
+                   "FCP7 XML writer, by contrast, carries audio, writes "
+                   "transition-adjacent clip edges as -1 (the junction), and "
+                   "emits `speed` followed by `variablespeed` 0 in the same "
+                   "timeremap effect.",
+        "recommended": "For round-trip QC prefer EXPORT_OTIO (carries audio, "
+                       "retimes as LinearTimeWarp/FreezeFrame, exact spans). "
+                       "When an EDL is the required deliverable, expect no "
+                       "audio (editorial.verify_roundtrip reports "
+                       "audioNotInExport) and resolve AX reels through the "
+                       "clip-name comments (parseEDL does). Use EXPORT_EDL — "
+                       "there is no EXPORT_CMX_3600 constant, and an unknown "
+                       "name reaches Export as a string that returns a bare "
+                       "False (timeline.export_timeline_checked now refuses "
+                       "it loudly).",
+        "tags": ["timeline", "export", "edl", "audio", "silent-failure"],
+        "submit": "missing",
+        "mitigation": ["editorial.verify_roundtrip audioNotInExport", "timeline.export_timeline_checked"],
+    },
     {
         "symbol": "Project.SetRenderSettings ExportSubtitle/SubtitleFormat (inert on 19.x)",
         "object": "Project",