davinci-resolve-mcp 2.162.0 → 2.164.0

package/CHANGELOG.md

@@ -2,6 +2,81 @@
 
 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.164.0 — E106: the changelist sees junctions
+
+`editorial.turnover_changelist` diffed clips and was blind to everything
+that happens *between* them. Measured on a faded, dissolved, retimed EDL
+pair: a 24→12-frame dissolve change reported nothing, both dropped fades
+read as "BL gone", and the zero-length CMX carrier line of a dissolve's
+outgoing side read as "B002 gone". The timing guards paired first-row-wins,
+so an identical cut with one A2 leg dropped flagged a FALSE flattened
+retime and never flagged the audio drop (`track === 'A'` missed `A2`).
+
+### Fixed
+
+- **The changelist diffs junctions.** `transition_added` /
+  `transition_dropped` / `transition_changed` entries name the outgoing and
+  incoming sources, classify fade in/out vs dissolve, and carry the span and
+  duration/type/pre-roll deltas — a dissolve reshaped from centered to
+  start-at-cut is a change even when both clips stayed put. Spans derive
+  exactly as the bridge places them (CMX start-at-cut, OTIO `in_offset`,
+  XMEML/PrProj `recStart`, AAF overlap start).
+- **Carrier lines and fade legs never read as sources.** Zero-length events
+  (CMX outgoing marker lines, the synthesized BL fade slugs) and the black
+  legs a transition references fold into the junction diff; the changelist
+  reports how many in `carriersFolded`. A cut diffed against itself is
+  silent on every axis.
+- **`timingGuards` pairs instance-to-instance.** Same track+source, closest
+  record position, consumed once — the pairing the changelist already used —
+  so a source cut twice at two speeds no longer cross-compares. Flags carry
+  `recIn`. Dropped-audio detection reads any `A`-track (`A`, `A2`, …), and a
+  lost fade or dissolve is now a timing lie (`transition_dropped`).
+
+### Added
+
+- `editorial.mjs` exports `transitionSpan(event)` and
+  `listTransitions(events)` — the junction model shared by the changelist
+  and the guards.
+
+## 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

package/README.md

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

package/docs/kernels/timeline-conform-interchange-kernel.md

@@ -142,7 +142,8 @@ files and the project DB.
   inside `.drp`/`.drt` as `<OfflineClip>` entries; patch them here.
 - **`editorial`** — `parse_interchange` (EDL/OTIO/XMEML natively; **AAF via pyaaf2**,
   multi-layer Avid turnovers included — honest refuse only when pyaaf2 is absent),
-  `turnover_changelist` (moved/retimed/replaced/new/gone with timing guards),
+  `turnover_changelist` (moved/retimed/trimmed/replaced/new/gone plus transitions
+  added/dropped/changed with fade in/out, with timing guards),
   `conform_manifest`, `marker_roundtrip`.
 - **`drt` / `project_db`** — timeline file authoring and DB patching.
 

package/docs/kernels/timeline-edit-kernel.md

@@ -188,8 +188,10 @@ timelines and reasons over editorial interchange with **no Resolve running**:
 
 - **`editorial`** — `parse_interchange` (EDL/OTIO/XMEML natively; **AAF via pyaaf2**,
   multi-layer Avid turnovers included — honest refuse only when pyaaf2 is absent),
-  `turnover_changelist` (moved/retimed/replaced/new/gone between two cuts, with
-  timing silent-lie guards), `conform_manifest`, `marker_roundtrip`.
+  `turnover_changelist` (moved/retimed/trimmed/replaced/new/gone between two cuts PLUS
+  the junction diff — transitions added/dropped/changed with fade in/out and span deltas,
+  CMX carriers and BL fade legs folded in — with timing silent-lie guards),
+  `conform_manifest`, `marker_roundtrip`.
 - **`drt`** — `.drt` timeline file authoring + structural diff.
 
 Use these to answer "what changed between v3 and v4" or to hand a conform an

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.162.0"
+VERSION = "2.164.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.162.0",
+  "version": "2.164.0",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/resolve-advanced/README.md

@@ -105,7 +105,11 @@ Each dispatches on an `action`. Highlights:
   the `otio` and `edl` targets only — this flat `drt` target has no per-clip speed field and reports
   every retime it flattens in `flattened`; for a `.drt` that AUTHORS retimes (plus dissolves,
   multi-track, audio) use `drt.assemble_from_interchange` instead),
-  `turnover_changelist` (moved/retimed/replaced/new/gone + timing silent-lie guards), `conform_manifest`,
+  `turnover_changelist` (moved/retimed/trimmed/replaced/new/gone PLUS the junction diff —
+  `transition_added`/`transition_dropped`/`transition_changed` with fade in/out, outgoing/incoming, span and
+  duration/type/pre-roll deltas; CMX carrier lines and BL fade legs fold into the junctions instead of
+  reading as gone/new sources; events pair instance-to-instance by closest record position — + timing
+  silent-lie guards incl. lost transitions and dropped audio on any A-track), `conform_manifest`,
   `marker_roundtrip`.
 - **`provenance`** — provenance / audit: `gallery_lineage`, `grade_provenance` ("why is this graded this
   way"), `cdl_export` (+ `cdl_diff`, round-trip asserted), `revision_tracking`, `episode_report`.
@@ -196,7 +200,7 @@ plausible-looking short event list. Three limits are deliberate:
   mattes) applies to what shows through from below and references no media of its own. OTIO materializes
   such layers as tracks of gaps, so its track count can exceed the number of layers with media.
 - **Only `NestedScope` layers are numbered.** Non-nested slots keep the flat `V`/`A` label, which is what
-  `editorial.mjs`'s `track === 'A'` audio-follows-video heuristic reads.
+  `editorial.mjs`'s `/^A\d*$/` audio-follows-video heuristic reads (`A`, `A2`, … all count as audio).
 
 ## Provenance & license
 Vendored libraries are clean offline format-interop and deterministic compute code: no secrets, no

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.
@@ -399,38 +476,139 @@ export function parseInterchange(format, content, opts = {}) {
 
 // ── turnover_changelist ────────────────────────────────────────────────
 const sig = (e) => `${e.track}:${e.source}`;
+const isBlackSource = (s) => /^(bl|black|solid color)$/i.test(String(s || '').trim());
+const isAudioTrack = (t) => /^A\d*$/i.test(String(t || ''));
+// A zero-length event is a CARRIER, never a cut: the outgoing marker line of
+// a CMX dissolve pair, or the zero-length BL slug every parser synthesizes at
+// a fade (E91/E92/E93). It has no picture of its own to be moved/gone/new.
+const isCarrier = (e) => e.recIn != null && e.recOut != null && e.recIn === e.recOut;
+
+/**
+ * The record SPAN a transition event occupies, derived exactly the way the
+ * bridge places it (author-interchange): alignment 'start' → the span begins
+ * at the incoming's recIn (CMX start-at-cut / AAF overlap start); OTIO
+ * inOffset → that many frames before the cut; XMEML/PrProj recStart → the
+ * explicit span start; nothing declared → centered. `junction` is the
+ * incoming event's recIn — the same frame verify_roundtrip's fade windows
+ * key on.
+ * @param {Object} e normalized event carrying `transition`
+ */
+export function transitionSpan(e) {
+  const t = e.transition;
+  if (!t || e.recIn == null) return null;
+  const d = Math.max(0, Number(t.duration) || 0);
+  let pre;
+  if (t.alignment === 'start') pre = 0;
+  else if (t.inOffset != null) pre = Math.max(0, Math.min(d, Number(t.inOffset) || 0));
+  else if (t.recStart != null) pre = Math.max(0, Math.min(d, e.recIn - Number(t.recStart)));
+  else pre = Math.floor(d / 2);
+  const start = e.recIn - pre;
+  return { start, end: start + d, junction: e.recIn, pre, duration: d };
+}
+
+/**
+ * Every junction in an event list as a transition record: span, type, the
+ * OUTGOING event (the same-track neighbour whose extent touches the span
+ * start — a CMX carrier line, an abutting clip, or the overlapping AAF
+ * predecessor) and the INCOMING (the carrier of the `transition` field), with
+ * black on either side classified as a fade. Pure over events.
+ * @param {Array} events
+ * @returns {Array<{track,type,duration,start,end,junction,pre,outgoing,incoming,fade,incomingEvent,outgoingEvent}>}
+ */
+export function listTransitions(events) {
+  const out = [];
+  for (const e of events) {
+    if (!e.transition || !(Number(e.transition.duration) > 0)) continue;
+    const span = transitionSpan(e);
+    if (!span) continue;
+    const cands = events.filter((o) => o !== e && o.track === e.track && o.recIn != null && o.recOut != null
+      && o.recIn <= span.start && o.recOut >= span.start);
+    // The latest-ending toucher is the outgoing: a carrier line sits exactly
+    // at the span start, an abutting clip ends there, an AAF predecessor
+    // overlaps past it. Prefer a picture over black only when both touch.
+    cands.sort((a, b) => (b.recOut - a.recOut) || ((events.indexOf(b)) - events.indexOf(a)));
+    let outgoingEvent = cands[0] || null;
+    if (!outgoingEvent) {
+      // Nothing touches the span start (a pre-rolled fade-in at track start
+      // whose span begins before frame 0, or a gap-adjacent junction): the
+      // outgoing is whatever last ENDED at or before the junction — the
+      // zero-length BL slug the parsers synthesize sits exactly there.
+      const before = events.filter((o) => o !== e && o.track === e.track && o.recOut != null && o.recOut <= span.junction);
+      before.sort((a, b) => (b.recOut - a.recOut) || (events.indexOf(b) - events.indexOf(a)));
+      outgoingEvent = before[0] || null;
+    }
+    const outgoing = outgoingEvent ? outgoingEvent.source : null;
+    const incoming = e.source;
+    const fade = isBlackSource(outgoing) ? 'in' : isBlackSource(incoming) ? 'out' : null;
+    out.push({
+      track: e.track, type: e.transition.type || 'dissolve', duration: span.duration,
+      start: span.start, end: span.end, junction: span.junction, pre: span.pre,
+      outgoing, incoming, fade, incomingEvent: e, outgoingEvent,
+    });
+  }
+  return out;
+}
+
+/**
+ * Pair old and new PICTURE/AUDIO events once each: same track+source, closest
+ * record position wins, consumed on match (a source used twice at two speeds
+ * pairs each instance with its own — never first-row-wins). Carriers and the
+ * black legs a transition references never enter the pairing: they are the
+ * junction's business (listTransitions), not sources.
+ */
+function pairEvents(oldEvents, newEvents, recTol = 1) {
+  const cutsOf = (events) => {
+    const trs = listTransitions(events);
+    const fadeBlack = new Set();
+    for (const t of trs) {
+      if (t.outgoingEvent && isBlackSource(t.outgoingEvent.source)) fadeBlack.add(t.outgoingEvent);
+      if (isBlackSource(t.incomingEvent.source)) fadeBlack.add(t.incomingEvent);
+    }
+    const cuts = [], carriers = [];
+    for (const e of events) {
+      if (e.track === 'MARKER') continue;
+      if (isCarrier(e) || fadeBlack.has(e)) carriers.push(e);
+      else cuts.push(e);
+    }
+    return { cuts, carriers, transitions: trs };
+  };
+  const o = cutsOf(oldEvents), n = cutsOf(newEvents);
+  const pool = o.cuts.map((e) => ({ e, used: false }));
+  const pairs = [], unmatchedNew = [];
+  for (const ne of n.cuts) {
+    const cands = pool.filter((p) => !p.used && sig(p.e) === sig(ne));
+    if (!cands.length) { unmatchedNew.push(ne); continue; }
+    cands.sort((a, b) => Math.abs((a.e.recIn ?? 0) - (ne.recIn ?? 0)) - Math.abs((b.e.recIn ?? 0) - (ne.recIn ?? 0)));
+    cands[0].used = true;
+    pairs.push({ oe: cands[0].e, ne });
+  }
+  const unmatchedOld = pool.filter((p) => !p.used).map((p) => p.e);
+  return { pairs, unmatchedOld, unmatchedNew, old: o, new: n, recTol };
+}
 
 /**
- * Diff two normalized event lists → per-event {kind: moved|retimed|replaced|new|gone|unchanged}.
+ * Diff two normalized event lists → per-event {kind: moved|retimed|trimmed|replaced|new|gone}
+ * 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
+ * as gone/new sources; a dissolve whose duration, type or span shape changed
+ * is a change even when both clips stayed put.
  * @param {Array} oldEvents
  * @param {Array} newEvents
  * @param {{recTolerance?:number}} [opts]
  */
 export function diffChangelist(oldEvents, newEvents, opts = {}) {
   const recTol = opts.recTolerance ?? 1;
-  const oldPool = oldEvents.map((e) => ({ e, used: false }));
+  const P = pairEvents(oldEvents, newEvents, recTol);
   const changes = [];
 
-  for (const ne of newEvents) {
-    // Prefer a same-source match; among those, the closest record position.
-    const candidates = oldPool.filter((o) => !o.used && sig(o.e) === sig(ne));
-    let match = null;
-    if (candidates.length) {
-      candidates.sort((a, b) => Math.abs((a.e.recIn ?? 0) - (ne.recIn ?? 0)) - Math.abs((b.e.recIn ?? 0) - (ne.recIn ?? 0)));
-      match = candidates[0];
-    }
-    if (!match) {
-      changes.push({ kind: 'new', source: ne.source, track: ne.track, newRecIn: ne.recIn });
-      continue;
-    }
-    match.used = true;
-    const oe = match.e;
+  for (const { oe, ne } of P.pairs) {
     const deltas = {};
     let kind = 'unchanged';
-    if (Math.abs((oe.speed ?? 100) - (ne.speed ?? 100)) > 0.01 || oe.reverse !== ne.reverse) {
+    if (Math.abs((oe.speed ?? 100) - (ne.speed ?? 100)) > 0.01 || Boolean(oe.reverse) !== Boolean(ne.reverse)) {
       kind = 'retimed';
       deltas.speed = { old: oe.speed, new: ne.speed };
-      if (oe.reverse !== ne.reverse) deltas.reverse = { old: oe.reverse, new: ne.reverse };
+      if (Boolean(oe.reverse) !== Boolean(ne.reverse)) deltas.reverse = { old: oe.reverse, new: ne.reverse };
     } else if (Math.abs((oe.recIn ?? 0) - (ne.recIn ?? 0)) > recTol) {
       kind = 'moved';
       deltas.recIn = { old: oe.recIn, new: ne.recIn };
@@ -440,51 +618,97 @@ export function diffChangelist(oldEvents, newEvents, opts = {}) {
     }
     if (kind !== 'unchanged') changes.push({ kind, source: ne.source, track: ne.track, oldRecIn: oe.recIn, newRecIn: ne.recIn, deltas });
   }
+  for (const ne of P.unmatchedNew) changes.push({ kind: 'new', source: ne.source, track: ne.track, newRecIn: ne.recIn });
   // Unconsumed old events → gone (unless a 'new' at the same rec position → replaced).
-  for (const o of oldPool.filter((x) => !x.used)) {
-    const replacement = changes.find((c) => c.kind === 'new' && c.track === o.e.track && Math.abs((c.newRecIn ?? 0) - (o.e.recIn ?? 0)) <= recTol);
+  for (const oe of P.unmatchedOld) {
+    const replacement = changes.find((c) => c.kind === 'new' && c.track === oe.track && Math.abs((c.newRecIn ?? 0) - (oe.recIn ?? 0)) <= recTol);
     if (replacement) {
       replacement.kind = 'replaced';
-      replacement.oldSource = o.e.source;
-      replacement.oldRecIn = o.e.recIn;
+      replacement.oldSource = oe.source;
+      replacement.oldRecIn = oe.recIn;
     } else {
-      changes.push({ kind: 'gone', source: o.e.source, track: o.e.track, oldRecIn: o.e.recIn });
+      changes.push({ kind: 'gone', source: oe.source, track: oe.track, oldRecIn: oe.recIn });
+    }
+  }
+
+  // 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.
+  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 });
+  for (const nt of P.new.transitions) {
+    const cands = tPool.filter((p) => !p.used && tKey(p.t) === tKey(nt));
+    if (!cands.length) {
+      changes.push({ kind: 'transition_added', ...tDesc(nt), newRecIn: nt.junction, newSpan: [nt.start, nt.end] });
+      continue;
+    }
+    cands.sort((a, b) => Math.abs(a.t.junction - nt.junction) - Math.abs(b.t.junction - nt.junction));
+    cands[0].used = true;
+    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 (Object.keys(deltas).length) {
+      changes.push({
+        kind: 'transition_changed', ...tDesc(nt), oldRecIn: ot.junction, newRecIn: nt.junction,
+        oldSpan: [ot.start, ot.end], newSpan: [nt.start, nt.end], deltas,
+      });
     }
   }
+  for (const p of tPool.filter((x) => !x.used)) {
+    changes.push({ kind: 'transition_dropped', ...tDesc(p.t), oldRecIn: p.t.junction, oldSpan: [p.t.start, p.t.end] });
+  }
+
   const counts = {};
   for (const c of changes) counts[c.kind] = (counts[c.kind] || 0) + 1;
   changes.sort((a, b) => (a.newRecIn ?? a.oldRecIn ?? 0) - (b.newRecIn ?? b.oldRecIn ?? 0));
-  return { changes, counts, changedCount: changes.length, gate: 'review' };
+  return {
+    changes, counts, changedCount: changes.length,
+    transitions: { old: P.old.transitions.length, new: P.new.transitions.length },
+    carriersFolded: { old: P.old.carriers.length, new: P.new.carriers.length },
+    gate: 'review',
+  };
 }
 
 // ── TIMING silent-lie guards ───────────────────────────────────────────
 /**
  * Detect timing lies between an old (locked-cut) and new (conformed) event list.
+ * Pairs events the same way the changelist does (closest record position,
+ * consumed once) so a source cut twice at two speeds is compared instance to
+ * instance — never the second old against the first new.
  * @returns {{flags:Array<{kind, source, detail}>}}
  */
 export function timingGuards(oldEvents, newEvents) {
   const flags = [];
-  const newBySig = new Map();
-  for (const e of newEvents) {
-    if (!newBySig.has(sig(e))) newBySig.set(sig(e), []);
-    newBySig.get(sig(e)).push(e);
+  const P = pairEvents(oldEvents, newEvents);
+  for (const oe of P.unmatchedOld) {
+    // A dropped audio event where its video sibling survives → dropped J/L-cut audio.
+    if (isAudioTrack(oe.track) && P.new.cuts.some((x) => !isAudioTrack(x.track) && x.track !== 'MARKER' && x.source === oe.source))
+      flags.push({ kind: 'dropped_split_audio', source: oe.source, track: oe.track, detail: `audio event (${oe.track}) gone but video sibling present (J/L-cut lost)` });
   }
-  for (const oe of oldEvents) {
-    const matches = newBySig.get(sig(oe)) || [];
-    const ne = matches[0];
-    if (!ne) {
-      // A dropped audio event where its video sibling survives → dropped J/L-cut audio.
-      if (oe.track === 'A' && newEvents.some((x) => x.track !== 'A' && x.source === oe.source))
-        flags.push({ kind: 'dropped_split_audio', source: oe.source, detail: 'audio event gone but video sibling present (J/L-cut lost)' });
-      continue;
-    }
+  for (const { oe, ne } of P.pairs) {
     // Flattened retime: a speed ramp/change flattened to 100%.
     if ((oe.speed ?? 100) !== 100 && (ne.speed ?? 100) === 100)
-      flags.push({ kind: 'flattened_retime', source: oe.source, detail: `speed ${oe.speed}% → 100% (retime lost)` });
+      flags.push({ kind: 'flattened_retime', source: oe.source, recIn: oe.recIn, detail: `speed ${oe.speed}% → 100% (retime lost)` });
     // Reverse dropped.
-    if (oe.reverse && !ne.reverse) flags.push({ kind: 'reverse_dropped', source: oe.source, detail: 'reversed clip conformed forward' });
+    if (oe.reverse && !ne.reverse) flags.push({ kind: 'reverse_dropped', source: oe.source, recIn: oe.recIn, detail: 'reversed clip conformed forward' });
     // Framerate/pulldown slip.
-    if (oe.fps && ne.fps && oe.fps !== ne.fps) flags.push({ kind: 'framerate_slip', source: oe.source, detail: `fps ${oe.fps} → ${ne.fps}` });
+    if (oe.fps && ne.fps && oe.fps !== ne.fps) flags.push({ kind: 'framerate_slip', source: oe.source, recIn: oe.recIn, detail: `fps ${oe.fps} → ${ne.fps}` });
+  }
+  // A fade or dissolve the conform lost is a timing lie too: the picture
+  // edges stay put while the blend at the junction silently hard-cuts.
+  const tKey = (t) => `${t.track}|${t.outgoing ?? ''}|${t.incoming}|${t.fade ?? 'x'}`;
+  const newKeys = P.new.transitions.map(tKey);
+  for (const ot of P.old.transitions) {
+    const i = newKeys.indexOf(tKey(ot));
+    if (i >= 0) { newKeys.splice(i, 1); continue; }
+    flags.push({
+      kind: 'transition_dropped', source: ot.incoming, track: ot.track, recIn: ot.junction,
+      detail: ot.fade ? `fade-${ot.fade} (${ot.duration}f) at ${ot.junction} lost` : `${ot.outgoing}→${ot.incoming} dissolve (${ot.duration}f) at ${ot.junction} lost`,
+    });
   }
   return { flags, flagged: flags.length > 0 };
 }

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 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 (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/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), 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.162.0"
+VERSION = "2.164.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.162.0"
+VERSION = "2.164.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",