davinci-resolve-mcp 2.189.0 → 2.191.0

package/CHANGELOG.md

@@ -2,6 +2,65 @@
 
 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.191.0 — E139: a .drt timeline walks into events; two Resolve versions diff
+
+### Added
+
+- **A `.drt`/`.drp` timeline walks into normalized events, so two Resolve
+  timeline VERSIONS diff.** `parse_interchange {format:'drt', content: PATH}`
+  (optional `timeline` = pool name or index) returns the same event shape as
+  every other format, with sequence-relative record positions plus the
+  timeline's `fps`, `startFrame` and `startTimecode` read from the pool
+  sequence. Measured on a real 19.1.3.7 export of a 229-clip reel: 230 events
+  on V–V4 and A–A2, 11 dissolves attached with their witnessed alignment, the
+  4 retimed clips flagged, and v19 vs v20 of that reel reads `identical, 229
+  of 229 retained` through `turnover_changelist`.
+- **The DRT parser reads the fields it used to skip.** Per clip: `in` (the
+  source in-point — EMPTY on a real export's audio clips, reported `null`, and
+  `srcInAbsent` on the event, never a silent 0), `mediaStartTime`,
+  `mediaFrameRate` (decoded from Resolve's little-endian double blob) and
+  `timemap` (`linear` vs a keyed `curve`; a curve is a retime this reader does
+  not decode, so the event carries `speed: null`, `srcOut: null` and
+  `retimeUnknown` instead of a faked 100%). Per track: `transitions`
+  (`Sm2TiTransition` span, type, `alignmentType` → `alignment`: 2 centres on
+  the cut, 3 ends at it, witnessed on all 11 real dissolves). Per timeline:
+  `frameRate`, `startFrame`, `startTimecode` and `resolution` now fill from the
+  pool `Sm2Sequence` (`FrameRate` LE double, `MediaExtents` seconds,
+  `Resolution` BE uint64 pair) when the container carries none — a real export
+  used to report them all `null`.
+
+### Measured (filed in api-limitations)
+
+- The EXPORT_DRT clip, transition and pool-sequence field encodings.
+
+## What's New in v2.190.0 — E138: the changelist names its shape; pairing is closest-first globally
+
+### Added
+
+- **`turnover_changelist` leads with a SHAPE verdict.** A real Premiere
+  auto-save of a locked reel kept 3 of its 335 cuts, byte-identical at their
+  record positions, and deleted the rest: a patch/selects reel of the same
+  cut. Per-event kinds read that as 332 `gone`. The result now names the
+  relationship first: `identical` | `subset` (new keeps some of old's cuts
+  unchanged in place and nothing else) | `superset` (the reverse) | `edit`,
+  with `retained`, `oldCuts`, `newCuts`, and for subset/superset `sparse`,
+  the `retainedWindows`, and a plain-language `note`. A transition that
+  vanished or appeared with the cuts it joins counts as a consequence, not an
+  edit. `gone`/`new` changes carry their record OUT so a dropped junction can
+  be attributed to them.
+
+### Fixed
+
+- **Event pairing was first-come, not closest-first.** Walking new cuts in
+  order let the first new instance of a source consume an old instance 6,000
+  frames away while the old instance at its own position went unpaired, so
+  the same two reels compared as `subset` one way and `moved + 332 new` the
+  other. Every same-signature (old, new) pair now sorts by record distance
+  and is taken once; the diff is symmetric under swapping old and new. On
+  the real reels: `subset 3 of 335` forward, `superset 3 of 335` back.
+  Sweep across every sequence the two auto-saves share: 739 compared, 738
+  `identical`, 1 `subset`, 0 asymmetric in either shape or counts.
+
 ## What's New in v2.189.0 — E136: Premiere markers belong to their sequence and read their real fields
 
 ### Fixed

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.189.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.191.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.189.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.191.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.189.0 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
+> 本翻译对应 v2.191.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:** 40 missing capabilities, 50 bugs / unreliable behaviors.
+**Totals:** 41 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_DRT (clip, transition and pool-sequence field encodings)
+
+- **Object:** `Timeline`
+- **Signature:** `(filePath, EXPORT_DRT) -> bool`
+- **Behavior:** Measured on a Studio 19.1.3.7 export of a 229-clip reel (E139). A SeqContainer clip (Sm2TiVideoClip / Sm2TiAudioClip) carries its record window as <Start> and <Duration> (frames, absolute), its SOURCE in-point as <In> (frames) — written EMPTY (<In/>) on every audio clip and on generator tails — <MediaFilePath>, <MediaStartTime> (seconds), <MediaFrameRate> as a 16-hex blob = one little-endian IEEE double + 8 pad bytes (24.0 = 0000000000003840…), and <MediaTimemapBA>: tag byte 0x02 + one double (the media length in seconds) on a 100% clip, a keyed curve opening 00000001… on a retimed clip and on generators. An Sm2TiTransition sits in the same <Items> list as the clips with <Start>/<Duration> (its span), <PrettyType> (Cross Dissolve), <AlignmentType> and <Position>: type 2 centres the span on the cut, type 3 ends it at the cut (11/11 witnessed against the clip edges; the one-sided 8-frame fade-in is type 3 / Position 1). The container carries NO frame rate, start or resolution — they live in the pool folder's embedded Sm2Sequence: <FrameRate> (LE double blob), <MediaExtents> = two LE doubles, record start SECONDS then duration SECONDS (7192.0 → frame 172608 = 01:59:52:00 at 24), <Resolution> = two big-endian uint64, width then height.
+- **Workaround / current handling:** Read record timing from Start/Duration, source in from In (null when empty — do not fake 0 silently), fps and start from the pool sequence (frames = round(seconds × fps)); treat a curve timemap as a retime whose speed is not decoded here (speed null) rather than 100%. The parser exposes these and editorial.parse_interchange {format:'drt', content: PATH} walks one timeline into normalized events so two timeline versions diff through turnover_changelist (v19 vs v20 of a real reel: identical, 229 of 229 retained).
+- **Tags:** timeline, export, drt, interchange
+
 ### Timeline.Export EXPORT_EDL (video-only, reel AX, clip-name comments)
 
 - **Object:** `Timeline`

package/install.py

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

package/resolve-advanced/server/editorial.mjs

@@ -606,13 +606,93 @@ export function parseInterchange(format, content, opts = {}) {
     case 'drt':
     case 'drp':
       throw new Error(
-        `parse_interchange: .${String(format).toLowerCase()} is a ZIP container — parse it via the path-based reader (drt.mjs \`parseDRT(path)\`), not the sync parseInterchange(). Entry points: editorial \`list_sequences({path})\` or drt \`parse({drtPath})\`.`,
+        `parse_interchange: .${String(format).toLowerCase()} is a ZIP container — parse it via the async path-based reader (editorial.mjs \`parseDrtEvents(path, {timeline})\` over drt-parser \`parseDRT(path)\`, E139), not the sync parseInterchange(). Entry points: editorial \`parse_interchange({format:'drt', content: PATH})\`, \`list_sequences({path})\` or drt \`parse({drtPath})\`.`,
       );
     default:
       throw new Error(`parse_interchange: unknown format '${format}' (edl|otio|xml|xmeml|fcp7|drt|drp|aaf|prproj)`);
   }
 }
 
+// ── DRT → normalized events (E139) ─────────────────────────────────────
+/**
+ * Normalized events for ONE timeline of a parsed .drt/.drp (drt-parser
+ * `parseDRT`), so two Resolve timeline versions diff through
+ * turnover_changelist and a DRT re-export verifies like any other format.
+ * Measured on a real 19.1.3.7 EXPORT_DRT: a clip's record window is
+ * <Start>/<Duration>, its source in-point <In> (EMPTY on audio clips and on
+ * generator tails — reported srcInAbsent, never faked to 0 silently), its
+ * media <MediaFilePath>; <MediaTimemapBA> tag 0x02 = linear 100%, a keyed
+ * curve = a retime this reader does not decode (speed null + retimeUnknown);
+ * Sm2TiTransition alignment 2 centres on the cut, 3 ends at it. Record
+ * positions are sequence-relative (start frame subtracted), like every other
+ * parser here; `startFrame` is returned beside the events.
+ * @param {object} parsed  parseDRT output
+ * @param {{timeline?: string|number}} [opts] pool name or index; default = first `timeline` kind
+ */
+export function drtEventsFromParsed(parsed, opts = {}) {
+  const tls = (parsed && parsed.timelines) || [];
+  if (!tls.length) throw new Error('drt events: the archive holds no SeqContainer');
+  let tl = null;
+  if (typeof opts.timeline === 'number') tl = tls[opts.timeline] || null;
+  else if (typeof opts.timeline === 'string' && opts.timeline) tl = tls.find((t) => t.name === opts.timeline) || null;
+  else tl = tls.find((t) => t.kind === 'timeline') || tls[0];
+  if (!tl) throw new Error(`drt events: no timeline '${opts.timeline}' in [${tls.map((t) => t.name).join(', ')}]`);
+  const fps = Number(tl.frameRate) || 24;
+  const startFrame = Number.isFinite(Number(tl.startFrame)) ? Number(tl.startFrame) : 0;
+  const events = [];
+  let index = 1;
+  const base = (pth, name) => (pth ? String(pth).split(/[\\/]/).pop() : name);
+  const walk = (tracks, prefix) => {
+    (tracks || []).forEach((t, i) => {
+      const label = i === 0 ? prefix : `${prefix}${i + 1}`;
+      const before = events.length;
+      const clips = [...(t.clips || [])].filter((c) => Number.isFinite(c.start) && Number.isFinite(c.duration)).sort((a, b) => a.start - b.start);
+      for (const c of clips) {
+        const srcIn = c.in != null ? c.in : 0;
+        const media = c.mediaFilePath || null;
+        const isGen = !media && !c.compound;
+        const ev = {
+          index: index++, track: label, source: media ? base(media, c.name) : (c.name || 'BL'),
+          // A keyed speed curve makes the source OUT unknowable here — null, never
+          // srcIn + duration as if it played at 100%.
+          srcIn, srcOut: c.timemap === 'curve' ? null : srcIn + c.duration, recIn: c.start - startFrame, recOut: c.start - startFrame + c.duration,
+          speed: c.timemap === 'curve' ? null : 100, reverse: false, transition: null, fps,
+        };
+        if (media) ev.sourcePath = media;
+        if (c.in == null) ev.srcInAbsent = true;
+        if (c.timemap === 'curve') ev.retimeUnknown = true;
+        if (c.compound) ev.compound = c.compound;
+        if (isGen) ev.generatorName = c.name || null;
+        events.push(ev);
+      }
+      for (const tr of t.transitions || []) {
+        if (!Number.isFinite(tr.start) || !Number.isFinite(tr.duration)) continue;
+        const s0 = tr.start - startFrame, e0 = s0 + tr.duration;
+        const lane = events.slice(before).filter((ev) => ev.track === label);
+        const incoming = lane.find((ev) => ev.recIn > s0 - 1 && ev.recIn <= e0);
+        const outgoing = lane.find((ev) => ev !== incoming && ev.recOut > s0 - 1 && ev.recOut <= e0);
+        const transition = { type: String(tr.type || 'Cross Dissolve'), duration: tr.duration, recStart: s0 };
+        if (tr.alignment) transition.alignment = tr.alignment;
+        if (incoming) {
+          incoming.transition = transition;
+          if (!outgoing) events.push({ index: index++, track: label, source: 'BL', srcIn: 0, srcOut: 0, recIn: incoming.recIn, recOut: incoming.recIn, speed: 100, reverse: false, transition: null, fps });
+        } else if (outgoing) {
+          events.push({ index: index++, track: label, source: 'BL', srcIn: 0, srcOut: 0, recIn: outgoing.recOut, recOut: outgoing.recOut, speed: 100, reverse: false, transition, fps });
+        }
+      }
+    });
+  };
+  walk(tl.videoTracks, 'V');
+  walk(tl.audioTracks, 'A');
+  return { events, timeline: tl.name, kind: tl.kind || null, fps, startFrame, startTimecode: tl.startTimecode || null };
+}
+
+/** Path-based DRT/DRP → events (async: ZIP). */
+export async function parseDrtEvents(filePath, opts = {}) {
+  const { parseDRT } = require('../vendor/drt-format/drt-parser.js');
+  return drtEventsFromParsed(await parseDRT(filePath), opts);
+}
+
 // ── turnover_changelist ────────────────────────────────────────────────
 const sig = (e) => `${e.track}:${e.source}`;
 const isBlackSource = (s) => /^(bl|black|solid color)$/i.test(String(s || '').trim());
@@ -712,21 +792,39 @@ function pairEvents(oldEvents, newEvents, recTol = 1) {
     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 });
+  // Pairing is closest-first GLOBALLY (E138), not first-come in new order:
+  // walking new cuts in order let the first new instance of a source consume
+  // an old instance 6,000 frames away while the old instance at its own
+  // position went unpaired — a subset reel read back as moved + new. Every
+  // same-signature (old, new) pair sorts by record distance and is taken
+  // once; the result is symmetric under swapping old and new.
+  const pool = o.cuts.map((e) => ({ e, used: false, sig: sig(e) }));
+  const newSigs = n.cuts.map(sig);
+  const cands = [];
+  for (let ni = 0; ni < n.cuts.length; ni++) {
+    for (let oi = 0; oi < pool.length; oi++) {
+      if (pool[oi].sig !== newSigs[ni]) continue;
+      cands.push({ oi, ni, d: Math.abs((pool[oi].e.recIn ?? 0) - (n.cuts[ni].recIn ?? 0)) });
+    }
+  }
+  cands.sort((a, b) => a.d - b.d || a.ni - b.ni || a.oi - b.oi);
+  const usedNew = new Set();
+  const taken = [];
+  for (const c of cands) {
+    if (pool[c.oi].used || usedNew.has(c.ni)) continue;
+    pool[c.oi].used = true; usedNew.add(c.ni);
+    taken.push(c);
   }
+  taken.sort((a, b) => a.ni - b.ni);
+  const pairs = taken.map((c) => ({ oe: pool[c.oi].e, ne: n.cuts[c.ni] }));
+  const unmatchedNew = n.cuts.filter((_, i) => !usedNew.has(i));
   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|trimmed|replaced|new|gone}
+ * Diff two normalized event lists → a SHAPE verdict (identical|subset|superset|edit, E138)
+ * plus 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
@@ -762,6 +860,7 @@ export function diffChangelist(oldEvents, newEvents, opts = {}) {
   }
   const P = pairEvents(oldEvents.filter((e) => !skipOld.has(e)), newEvents.filter((e) => !skipNew.has(e)), recTol);
 
+  const retained = [];
   for (const { oe, ne } of P.pairs) {
     const deltas = {};
     let kind = 'unchanged';
@@ -777,8 +876,9 @@ export function diffChangelist(oldEvents, newEvents, opts = {}) {
       deltas.src = { old: [oe.srcIn, oe.srcOut], new: [ne.srcIn, ne.srcOut] };
     }
     if (kind !== 'unchanged') changes.push({ kind, source: ne.source, track: ne.track, oldRecIn: oe.recIn, newRecIn: ne.recIn, deltas });
+    else retained.push(ne);
   }
-  for (const ne of P.unmatchedNew) changes.push({ kind: 'new', source: ne.source, track: ne.track, newRecIn: ne.recIn });
+  for (const ne of P.unmatchedNew) changes.push({ kind: 'new', source: ne.source, track: ne.track, newRecIn: ne.recIn, newRecOut: ne.recOut });
   // Unconsumed old events → gone (unless a 'new' at the same rec position → replaced).
   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);
@@ -787,7 +887,7 @@ export function diffChangelist(oldEvents, newEvents, opts = {}) {
       replacement.oldSource = oe.source;
       replacement.oldRecIn = oe.recIn;
     } else {
-      changes.push({ kind: 'gone', source: oe.source, track: oe.track, oldRecIn: oe.recIn });
+      changes.push({ kind: 'gone', source: oe.source, track: oe.track, oldRecIn: oe.recIn, oldRecOut: oe.recOut });
     }
   }
 
@@ -825,10 +925,40 @@ export function diffChangelist(oldEvents, newEvents, opts = {}) {
   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));
+
+  // SHAPE (E138): a real Premiere auto-save of a locked reel kept 3 of its
+  // 335 cuts — byte-identical at their record positions — and deleted the
+  // rest (a patch/selects reel). Per-event kinds read that as 332 'gone';
+  // it is a sparse SUBSET of the same cut with nothing edited. The verdict
+  // names the relationship so a reader never mistakes a subset for a
+  // re-cut: identical | subset (new ⊂ old) | superset (old ⊂ new) | edit.
+  // A transition that vanished because both cuts it joined vanished (or
+  // 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))
+    || (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 && retained.length) shape = 'subset';
+  else if (!edits && added && !gone && retained.length) shape = 'superset';
+  const shapeInfo = { shape, retained: retained.length, oldCuts, newCuts };
+  if (shape === 'subset' || shape === 'superset') {
+    const of = shape === 'subset' ? oldCuts : newCuts;
+    shapeInfo.sparse = retained.length / Math.max(1, of) < 0.5;
+    shapeInfo.retainedWindows = retained.slice(0, 200).map((e) => ({ track: e.track, source: e.source, recIn: e.recIn, recOut: e.recOut }));
+    shapeInfo.note = shape === 'subset'
+      ? `new keeps ${retained.length} of ${oldCuts} cuts unchanged in place and nothing else — a patch/selects reel of the same cut, not ${gone} deletions`
+      : `old is ${retained.length} of the new cut's ${newCuts} cuts, unchanged in place — the rest is the new cut's additions, not ${added} edits to old`;
+  }
   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 },
+    ...shapeInfo,
     gate: 'review',
   };
 }

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

@@ -3,17 +3,17 @@
  * changelist + conform manifest with TIMING silent-lie guards. Report-only (gate: review). No Resolve.
  *
  * Actions:
- *   parse_interchange     — EDL / OTIO / XMEML / AAF (pyaaf2) / PRPROJ (gunzip+XML) → normalized events
+ *   parse_interchange     — EDL / OTIO / XMEML / AAF (pyaaf2) / PRPROJ (gunzip+XML) / DRT+DRP (ZIP, one timeline) → normalized events
  *   list_sequences        — ONE picker entry point across xml/edl/otio/drt/drp/aaf/prproj → [{id,name,eventCount}]
  *                           (AAF rows also carry startTimecode/startFrame — see aaf.mjs sequenceSummary)
  *   convert_to_interchange— events (or a parsed source) → OTIO/EDL/DRT Resolve CAN import (the .prproj bridge)
- *   turnover_changelist   — diff old vs new events → moved/retimed/replaced/new/gone (+timing flags)
+ *   turnover_changelist   — diff old vs new events → shape verdict (identical|subset|superset|edit) + moved/retimed/replaced/new/gone (+timing flags)
  *   conform_manifest      — per-event assert: source resolved, handles, retime, reverse, TC-base
  *   marker_roundtrip      — marker/note round-trip with provenance tags
  */
 import fs from 'node:fs/promises';
 import { z } from 'zod';
-import { parseInterchange, diffChangelist, timingGuards, conformManifest, markerRoundtrip } from '../editorial.mjs';
+import { parseInterchange, parseDrtEvents, diffChangelist, timingGuards, conformManifest, markerRoundtrip } from '../editorial.mjs';
 import { parseAAF, parseAafDocument } from '../aaf.mjs';
 import { parsePrproj, parsePrprojDoc } from '../prproj.mjs';
 import { listSequences, detectFormat } from '../sequences.mjs';
@@ -39,9 +39,10 @@ const parseSchema = z.object({
   content: z
     .union([z.string(), z.object({}).passthrough()])
     .describe(
-      'EDL text / OTIO JSON (string or object) / XMEML string. For AAF or PRPROJ (binary): the file PATH. For .drt/.drp (ZIP): use list_sequences or drt.parse — this action redirects.',
+      'EDL text / OTIO JSON (string or object) / XMEML string. For AAF, PRPROJ, DRT or DRP (binary/ZIP): the file PATH.',
     ),
   fps: z.number().optional(),
+  timeline: z.union([z.string(), z.number()]).optional().describe('drt/drp only: pool timeline name or index to walk (default: the first timeline-kind container; list_sequences names them)'),
 });
 
 const listSequencesSchema = z.object({
@@ -86,7 +87,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 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 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 → 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 curve is a retime this reader does not decode (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; 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);
@@ -98,6 +99,15 @@ export const editorialTool = {
         const { events, sequences } = await parseAafDocument(p.content);
         return { format: 'aaf', count: events.length, events, sequences };
       }
+      if (p.format === 'drt' || p.format === 'drp') {
+        // A .drt/.drp is a ZIP: the caller must hand over the PATH. Inline bytes
+        // (a slurped archive) name the requirement instead of surfacing ENOENT
+        // on the first four bytes of the file.
+        const isPath = typeof p.content === 'string' && await fs.access(p.content).then(() => true, () => false);
+        if (!isPath) throw new Error(`parse_interchange: for ${p.format} pass the file PATH as content — a .${p.format} is a ZIP read by parseDRT(path), not text`);
+        const r = await parseDrtEvents(p.content, { timeline: p.timeline });
+        return { format: p.format, count: r.events.length, events: r.events, timeline: r.timeline, kind: r.kind, fps: r.fps, startFrame: r.startFrame, startTimecode: r.startTimecode };
+      }
       if (p.format === 'prproj') {
         const doc = parsePrprojDoc(p.content);
         const events = parsePrproj(p.content);

package/resolve-advanced/vendor/drt-format/drt-parser.js

@@ -39,6 +39,60 @@ function extractInt(xml, tag) {
 
 const CLIP_TAGS = ['Sm2TiVideoClip', 'Sm2VideoClip', 'Sm2TiAudioClip', 'Sm2AudioClip'];
 
+// Resolve stores several scalars as 16-hex-char blobs (E139, measured on a
+// 19.1.3.7 EXPORT_DRT): <FrameRate> / <MediaFrameRate> = one little-endian
+// IEEE double + 8 pad bytes (24.0 = 0000000000003840…); <MediaExtents> = two
+// little-endian doubles, start SECONDS then duration SECONDS; <Resolution> =
+// two big-endian uint64, width then height.
+function leDouble(hex, offset = 0) {
+  const h = String(hex || '').replace(/[^0-9a-fA-F]/g, '');
+  if (h.length < offset + 16) return null;
+  const v = Buffer.from(h.slice(offset, offset + 16), 'hex').readDoubleLE(0);
+  return Number.isFinite(v) ? v : null;
+}
+function beUint64(hex, offset = 0) {
+  const h = String(hex || '').replace(/[^0-9a-fA-F]/g, '');
+  if (h.length < offset + 16) return null;
+  const v = Number(Buffer.from(h.slice(offset, offset + 16), 'hex').readBigUInt64BE(0));
+  return Number.isFinite(v) ? v : null;
+}
+// <MediaTimemapBA>: tag byte 0x02 + one double = a LINEAR (100%) clip whose
+// double is the media length in seconds; a blob opening 00000001… is a keyed
+// speed CURVE (retime) whose speed this parser does not decode — it is
+// reported as 'curve' so a consumer never fakes 100%.
+function timemapKind(hex) {
+  const h = String(hex || '').replace(/[^0-9a-fA-F]/g, '').toLowerCase();
+  if (!h) return null;
+  if (h.startsWith('02') && h.length === 18) return 'linear';
+  if (h.startsWith('02')) return 'linear-multi';
+  if (h.startsWith('00000001')) return 'curve';
+  return 'unknown';
+}
+// Sm2TiTransition alignment (E139, witnessed against the cut points of 11
+// real dissolves): 2 = centred on the cut, 3 = ends at the cut (the
+// one-sided 8-frame fade-in on a real reel is type 3 / Position 1).
+const ALIGNMENT_BY_TYPE = { 1: 'start', 2: 'center', 3: 'end' };
+
+function extractTransitionsFromTrackXml(trackXml) {
+  const out = [];
+  const re = /<(Sm2TiTransition)\b[^>]*?DbId="([^"]+)"[^>]*>([\s\S]*?)<\/\1>/g;
+  let m;
+  while ((m = re.exec(trackXml)) !== null) {
+    const inner = m[3];
+    const alignmentType = extractInt(inner, 'AlignmentType');
+    out.push({
+      transitionId: m[2],
+      type: extractScalar(inner, 'PrettyType') || 'Cross Dissolve',
+      start: extractInt(inner, 'Start'),
+      duration: extractInt(inner, 'Duration'),
+      alignmentType,
+      alignment: alignmentType != null ? ALIGNMENT_BY_TYPE[alignmentType] || null : null,
+      position: extractInt(inner, 'Position'),
+    });
+  }
+  return out;
+}
+
 function extractClipsFromTrackXml(trackXml, trackType) {
   const clips = [];
   const tagAlt = CLIP_TAGS.filter((t) => t.toLowerCase().includes(trackType)).join('|');
@@ -56,6 +110,8 @@ function extractClipsFromTrackXml(trackXml, trackType) {
       const stripped = bodyMatch[1].replace(/[^0-9a-fA-F]/g, '');
       if (stripped.length > 0) bodyHex = stripped;
     }
+    const inRaw = extractScalar(inner, 'In');
+    const mst = extractScalar(inner, 'MediaStartTime');
     clips.push({
       clipId: m[3],
       name: extractScalar(inner, 'Name'),
@@ -63,6 +119,13 @@ function extractClipsFromTrackXml(trackXml, trackType) {
       duration,
       mediaFilePath,
       bodyHex,
+      // E139: the clip's SOURCE in-point in frames (<In>); a real export writes
+      // an EMPTY <In/> on audio clips and on generator tails — null, not 0.
+      in: inRaw === null || inRaw === '' ? null : (Number.isFinite(Number.parseInt(inRaw, 10)) ? Number.parseInt(inRaw, 10) : null),
+      mediaStartTime: mst === null || mst === '' ? null : (Number.isFinite(Number(mst)) ? Number(mst) : null),
+      mediaFrameRate: leDouble(extractScalar(inner, 'MediaFrameRate')),
+      timemap: timemapKind(extractScalar(inner, 'MediaTimemapBA')),
+      prettyType: extractScalar(inner, 'PrettyType') || null,
     });
   }
   return clips;
@@ -90,6 +153,7 @@ function extractTracks(seqXml, trackVecTag, trackTagBase, trackType) {
       trackId,
       trackType,
       clips: extractClipsFromTrackXml(trackInner, trackType),
+      transitions: extractTransitionsFromTrackXml(trackInner),
     });
   }
   return tracks;
@@ -114,16 +178,47 @@ async function loadPoolSequenceNames(zip) {
     while ((m = re.exec(xml)) !== null) {
       const body = m[3];
       const name = extractScalar(body, 'Name');
-      const seqRe = /<Sm2Sequence DbId="([^"]+)">/g;
+      const seqRe = /<Sm2Sequence DbId="([^"]+)">([\s\S]*?)<\/Sm2Sequence>/g;
       let sm;
       while ((sm = seqRe.exec(body)) !== null) {
-        if (!map.has(sm[1])) map.set(sm[1], { name, kind: m[1] === 'Sm2MpCompoundClip' ? 'compound' : 'timeline' });
+        if (map.has(sm[1])) continue;
+        // E139: the embedded Sm2Sequence is also where a real export keeps the
+        // timeline's frame rate, record extents and resolution — the
+        // SeqContainer carries none of them.
+        const sb = sm[2];
+        const ext = extractScalar(sb, 'MediaExtents');
+        const res = extractScalar(sb, 'Resolution');
+        map.set(sm[1], {
+          name,
+          kind: m[1] === 'Sm2MpCompoundClip' ? 'compound' : 'timeline',
+          frameRate: leDouble(extractScalar(sb, 'FrameRate')),
+          startSeconds: ext ? leDouble(ext, 0) : null,
+          durationSeconds: ext ? leDouble(ext, 16) : null,
+          width: res ? beUint64(res, 0) : null,
+          height: res ? beUint64(res, 16) : null,
+        });
       }
     }
   }
   return map;
 }
 
+// E139: a real export's record start lives ONLY in the pool sequence's
+// MediaExtents (seconds) — frames = round(seconds × fps); the timecode is
+// derived at that rate (non-drop; the export writes no drop flag here).
+function poolStartFrame(pool) {
+  if (!pool || pool.startSeconds == null || !pool.frameRate) return null;
+  return Math.round(pool.startSeconds * pool.frameRate);
+}
+function poolStartTimecode(pool) {
+  const f = poolStartFrame(pool);
+  if (f == null) return null;
+  const fps = Math.round(pool.frameRate);
+  const ff = f % fps, totalS = Math.floor(f / fps);
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${pad(Math.floor(totalS / 3600))}:${pad(Math.floor(totalS / 60) % 60)}:${pad(totalS % 60)}:${pad(ff)}`;
+}
+
 function parseSeqContainer(seqXml, sequenceName, poolNames = new Map()) {
   const seqId = extractScalar(seqXml, 'Sequence');
   const pool = seqId ? poolNames.get(seqId) : null;
@@ -134,13 +229,13 @@ function parseSeqContainer(seqXml, sequenceName, poolNames = new Map()) {
     name: (pool && pool.name) || extractScalar(seqXml, 'Name') || sequenceName,
     kind: pool ? pool.kind : null,
     sequence: sequenceName,
-    frameRate: extractScalar(seqXml, 'FrameRate'),
-    startTimecode: extractScalar(seqXml, 'StartTC'),
-    startFrame: extractInt(seqXml, 'StartFrame'),
+    frameRate: extractScalar(seqXml, 'FrameRate') ?? (pool && pool.frameRate != null ? pool.frameRate : null),
+    startTimecode: extractScalar(seqXml, 'StartTC') ?? poolStartTimecode(pool),
+    startFrame: extractInt(seqXml, 'StartFrame') ?? poolStartFrame(pool),
     resolution: (() => {
       const w = extractInt(seqXml, 'ResolutionWidth');
       const h = extractInt(seqXml, 'ResolutionHeight');
-      if (w === null || h === null) return null;
+      if (w === null || h === null) return pool && pool.width && pool.height ? `${pool.width}x${pool.height}` : null;
       return `${w}x${h}`;
     })(),
     videoTracks: extractTracks(seqXml, 'VideoTrackVec', 'Sm2TiVideoTrack', 'video').map((t) => ({

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.189.0"
+VERSION = "2.191.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.189.0"
+VERSION = "2.191.0"
 
 import base64
 import os

package/src/utils/api_truth.py

@@ -2729,6 +2729,47 @@ API_TRUTH: List[Dict[str, Any]] = [
         "submit": "bug",
         "mitigation": ["drt.assemble cuts[].markers"],
     },
+    {
+        "symbol": "Timeline.Export EXPORT_DRT (clip, transition and pool-sequence field encodings)",
+        "object": "Timeline",
+        "signature": "(filePath, EXPORT_DRT) -> bool",
+        "reality": "Measured on a Studio 19.1.3.7 export of a 229-clip reel "
+                   "(E139). A SeqContainer clip (Sm2TiVideoClip / "
+                   "Sm2TiAudioClip) carries its record window as <Start> and "
+                   "<Duration> (frames, absolute), its SOURCE in-point as <In> "
+                   "(frames) — written EMPTY (<In/>) on every audio clip and on "
+                   "generator tails — <MediaFilePath>, <MediaStartTime> "
+                   "(seconds), <MediaFrameRate> as a 16-hex blob = one "
+                   "little-endian IEEE double + 8 pad bytes (24.0 = "
+                   "0000000000003840…), and <MediaTimemapBA>: tag byte 0x02 + "
+                   "one double (the media length in seconds) on a 100% clip, a "
+                   "keyed curve opening 00000001… on a retimed clip and on "
+                   "generators. An Sm2TiTransition sits in the same <Items> "
+                   "list as the clips with <Start>/<Duration> (its span), "
+                   "<PrettyType> (Cross Dissolve), <AlignmentType> and "
+                   "<Position>: type 2 centres the span on the cut, type 3 ends "
+                   "it at the cut (11/11 witnessed against the clip edges; the "
+                   "one-sided 8-frame fade-in is type 3 / Position 1). The "
+                   "container carries NO frame rate, start or resolution — they "
+                   "live in the pool folder's embedded Sm2Sequence: <FrameRate> "
+                   "(LE double blob), <MediaExtents> = two LE doubles, record "
+                   "start SECONDS then duration SECONDS (7192.0 → frame 172608 "
+                   "= 01:59:52:00 at 24), <Resolution> = two big-endian uint64, "
+                   "width then height.",
+        "recommended": "Read record timing from Start/Duration, source in from "
+                       "In (null when empty — do not fake 0 silently), fps and "
+                       "start from the pool sequence (frames = round(seconds × "
+                       "fps)); treat a curve timemap as a retime whose speed is "
+                       "not decoded here (speed null) rather than 100%. The "
+                       "parser exposes these and editorial.parse_interchange "
+                       "{format:'drt', content: PATH} walks one timeline into "
+                       "normalized events so two timeline versions diff through "
+                       "turnover_changelist (v19 vs v20 of a real reel: "
+                       "identical, 229 of 229 retained).",
+        "tags": ["timeline", "export", "drt", "interchange"],
+        "submit": "missing",
+        "mitigation": ["editorial.parse_interchange drt", "drt.parse"],
+    },
     {
         "symbol": "Timeline.Export EXPORT_OTIO (drops timeline markers)",
         "object": "Timeline",