davinci-resolve-mcp 2.123.0 → 2.125.0

package/docs/guides/native-drt-authoring.md

@@ -54,8 +54,9 @@ window. `render.verify_output` covers the container-level checks.
 | Fusion titles | `elements: [{type:'title', text}]` — **21-gen hosts only** | v2.108 |
 
 `assemble_from_interchange` drives the same engine from an EDL / OTIO /
-FCP7-XML / AAF plus a `sourceMap` — all four formats are route-proven
-end-to-end (parse → assemble → import → measured frames and RMS) — and
+FCP7-XML / AAF / **.prproj** (Premiere, read offline — no Premiere needed)
+plus a `sourceMap` — all five formats are route-proven end-to-end
+(parse → assemble → import → measured frames and RMS) — and
 returns an honesty ledger
 (`authoredTransitions`, `droppedTransitions` with reasons, `authoredRetimes`,
 `flattenedRetimes`, `authoredAudioEvents`, `upperTrackCutsVideoOnly`).
@@ -110,6 +111,12 @@ Everything else stays in `droppedTransitions` with the reason.
 3. For audio: RMS per window (silence = -inf is a failed placement).
 4. Never trust `created_new: false` — a same-named timeline already in the
    project is returned as "success" (internal-name-wins law).
+5. Close the loop with `editorial.verify_roundtrip`: parse the original
+   interchange and Resolve's own re-export of the imported timeline, and the
+   verifier normalizes track labels, source naming, and per-source
+   TC-absolute source frames (fitting the offsets, e.g. 86400 for a
+   01:00:00:00 source) — `pass: true` means the authored timeline's export
+   matches the turnover's intent event-for-event.
 
 ## References
 

package/install.py

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

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

@@ -575,3 +575,62 @@ export async function authorInterchange(events, target, opts = {}) {
   }
   throw new Error(`authorInterchange: unknown target '${target}' (otio|edl|drt)`);
 }
+
+/**
+ * verifyRoundtrip — assert that a re-EXPORT of an authored timeline matches
+ * the interchange it was built from, normalizing the three cross-format
+ * conventions measured on a live AAF→assemble→import→OTIO-export loop
+ * (19.1.3.7):
+ *   1. track labels: first tracks read 'V'/'A' in one format, 'V1'/'A1' in
+ *      the other — canonicalized to the numbered form;
+ *   2. source names: AAF mob name vs file basename ('rt_source_1' vs
+ *      'rt_source_1.mov') — compared after stripping the extension,
+ *      case-insensitively;
+ *   3. source frames: Resolve's OTIO export is TIMECODE-ABSOLUTE while
+ *      event lists are usually source-relative — a CONSTANT per-source
+ *      offset is fitted from the first pair and every other pair must agree
+ *      (the offset itself is reported, e.g. 86400 for a 01:00:00:00 source).
+ * Record positions are min-anchored per side. Video events only (audio
+ * channel legs merge by design).
+ *
+ * @returns {{pass:boolean, pairs:number, srcOffsets:Object, mismatches:Array}}
+ */
+export function verifyRoundtrip(inputEvents, exportedEvents, opts = {}) {
+  const recTol = opts.recTol ?? 1;
+  const srcTol = opts.srcTol ?? 1;
+  const canonTrack = (t) => {
+    const m = /^([VA])(\d+)?$/.exec(String(t || ''));
+    return m ? `${m[1]}${m[2] || '1'}` : String(t);
+  };
+  const canonSource = (x) => String(x || '').replace(/\.[^.]+$/, '').toLowerCase();
+  const vids = (evts) => evts.filter((e) => /^V\d*$/.test(String(e.track)) && e.recIn != null && e.recOut != null);
+  const norm = (evts) => {
+    const v = vids(evts);
+    if (!v.length) return [];
+    const off = Math.min(...v.map((e) => e.recIn));
+    return v
+      .map((e) => ({ track: canonTrack(e.track), source: canonSource(e.source), recIn: e.recIn - off, recOut: e.recOut - off, srcIn: e.srcIn ?? 0 }))
+      .sort((a, b) => a.track.localeCompare(b.track) || a.recIn - b.recIn);
+  };
+  const a = norm(inputEvents);
+  const b = norm(exportedEvents);
+  const mismatches = [];
+  if (a.length !== b.length) mismatches.push({ kind: 'count', input: a.length, exported: b.length });
+  const srcOffsets = {};
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i += 1) {
+    const x = a[i], y = b[i];
+    if (x.track !== y.track) { mismatches.push({ kind: 'track', at: i, input: x.track, exported: y.track }); continue; }
+    if (x.source !== y.source) { mismatches.push({ kind: 'source', at: i, input: x.source, exported: y.source }); continue; }
+    if (Math.abs(x.recIn - y.recIn) > recTol || Math.abs(x.recOut - y.recOut) > recTol) {
+      mismatches.push({ kind: 'record', at: i, input: [x.recIn, x.recOut], exported: [y.recIn, y.recOut] });
+      continue;
+    }
+    const off = y.srcIn - x.srcIn;
+    if (srcOffsets[x.source] === undefined) srcOffsets[x.source] = off;
+    else if (Math.abs(off - srcOffsets[x.source]) > srcTol) {
+      mismatches.push({ kind: 'source-frames', at: i, source: x.source, expectedOffset: srcOffsets[x.source], gotOffset: off });
+    }
+  }
+  return { pass: mismatches.length === 0, pairs: n, srcOffsets, mismatches };
+}

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

@@ -30,7 +30,7 @@ const authorSchema = z.object({
 });
 const validateSchema = z.object({ drtPath: z.string().describe('Absolute path to a .drt file') });
 const assembleFromInterchangeSchema = z.object({
-  format: z.enum(['edl', 'otio', 'xml', 'aaf']).describe('Interchange format of the input'),
+  format: z.enum(['edl', 'otio', 'xml', 'aaf', 'prproj']).describe('Interchange format of the input'),
   path: z.string().optional().describe('Path to the interchange file (aaf REQUIRES a path)'),
   content: z.string().optional().describe('Inline interchange text (edl/otio/xml)'),
   fps: z.number().optional().describe('Event frame rate for parsing (default 24; use e.g. 29.97 for NTSC EDLs)'),
@@ -211,14 +211,23 @@ export const drtTool = {
       const { parseInterchange } = await import('../editorial.mjs');
       const { eventsToAssembleSpec } = await import('../author-interchange.mjs');
       let content = p.content;
+      let events;
       if (p.format === 'aaf') {
         if (!p.path) return { error: 'aaf input requires path' };
         content = p.path;
+      } else if (p.format === 'prproj') {
+        // Premiere: offline gunzip+graph read (no Premiere, no Resolve import
+        // path). parsePrproj flattens EVERY sequence's events; a multi-sequence
+        // .prproj with overlapping record ranges refuses naturally in the
+        // overlap check — pre-split via editorial.list_sequences if needed.
+        if (!p.path) return { error: 'prproj input requires path' };
+        const { parsePrproj } = await import('../prproj.mjs');
+        events = parsePrproj(p.path);
       } else if (!content) {
         if (!p.path) return { error: 'provide content or path' };
         content = await fs.readFile(p.path, 'utf8');
       }
-      const events = parseInterchange(p.format, content, { fps: p.fps ?? 24 });
+      if (!events) events = parseInterchange(p.format, content, { fps: p.fps ?? 24 });
       if (!events || !events.length) return { error: 'no events parsed from the interchange input' };
       const { spec, report } = eventsToAssembleSpec(events, {
         sourceMap: p.sourceMap, timelineName: p.timelineName,
@@ -248,7 +257,7 @@ export const drtTool = {
         stamped,
         conform: report,
         note:
-          'Import with timeline.import_timeline_checked (timeline is named after the FILE). ' +
+          'Import with timeline.import_timeline_checked (timeline is named after the FILE). Dissolves/cross-fades, forward+reverse retimes, multi-track video, audio events and markers are AUTHORED when geometry allows; everything else drops WITH a reason — see `conform` for the ledger.' +
           'Retimes are flattened and transitions become cuts — see `conform` for the ledger.',
       };
     }

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

@@ -17,7 +17,7 @@ import { parseInterchange, diffChangelist, timingGuards, conformManifest, marker
 import { parseAAF, parseAafDocument } from '../aaf.mjs';
 import { parsePrproj, parsePrprojDoc } from '../prproj.mjs';
 import { listSequences, detectFormat } from '../sequences.mjs';
-import { authorInterchange } from '../author-interchange.mjs';
+import { authorInterchange, verifyRoundtrip } from '../author-interchange.mjs';
 
 const eventArray = z.array(z.object({}).passthrough());
 
@@ -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; 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 .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), marker_roundtrip (markers with provenance tags). 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 + AAF via pyaaf2 + PRPROJ via gunzip+XML → normalized events; 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 .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), marker_roundtrip (markers with provenance tags), verify_roundtrip (input events vs re-export events -> pass/mismatches + fitted per-source TC offsets; 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);
@@ -145,6 +145,20 @@ export const editorialTool = {
       const p = conformManifestSchema.parse(args);
       return conformManifest(p.events, p.resolution, { minHandle: p.minHandle, expectTcBase: p.expectTcBase });
     }
+    if (action === 'verify_roundtrip') {
+      // Round-trip QC: input interchange events vs a re-EXPORT of the
+      // authored timeline, normalized for the three measured cross-format
+      // conventions (track label, source naming, per-source TC-absolute
+      // source frames). Live-proven: AAF -> assemble -> import -> Resolve
+      // OTIO export verified pass with srcOffsets 86400.
+      const p = z.object({
+        input: z.array(z.any()).describe('Normalized events of the ORIGINAL interchange (parse_interchange output)'),
+        exported: z.array(z.any()).describe('Normalized events of the re-export (parse_interchange on the exported OTIO/EDL/XML)'),
+        recTol: z.number().optional(),
+        srcTol: z.number().optional(),
+      }).parse(args);
+      return verifyRoundtrip(p.input, p.exported, { recTol: p.recTol, srcTol: p.srcTol });
+    }
     if (action === 'marker_roundtrip') {
       const p = markerSchema.parse(args);
       return markerRoundtrip(p.markers, { provenanceTag: p.provenanceTag });

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.123.0"
+VERSION = "2.125.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.123.0"
+VERSION = "2.125.0"
 
 import base64
 import os