davinci-resolve-mcp 2.118.0 → 2.120.0

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

@@ -49,6 +49,7 @@ window. `render.verify_output` covers the container-level checks.
 | Built-in generators | `elements: [{type:'generator', generatorName}]` | v2.110 |
 | Custom start timecode | `spec.startFrame` / `preserveStartTimecode` | v2.117 |
 | Timeline markers | `spec.markers` (16 colors, notes, durations, customData) | v2.118 |
+| Turnover markers | EDL `* LOC:` locators + OTIO markers → authored | v2.119 |
 | Fusion titles | `elements: [{type:'title', text}]` — **21-gen hosts only** | v2.108 |
 
 `assemble_from_interchange` drives the same engine from an EDL / OTIO /

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.118.0"
+VERSION = "2.120.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.118.0",
+  "version": "2.120.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

@@ -229,9 +229,24 @@ export function eventsToAssembleSpec(events, opts = {}) {
   }
   const DEFAULT_ORIGIN = 86400;
   const isAudio = (t) => /^A\d*$/.test(String(t || ''));
-  const vids = events.filter((e) => !isAudio(e.track) && e.recIn != null && e.recOut != null);
-  const auds = events.filter((e) => isAudio(e.track) && e.recIn != null && e.recOut != null);
-  const audioSkipped = events.length - vids.length - auds.length;
+  const isMarker = (t) => t === 'MARKER';
+  const vids = events.filter((e) => !isAudio(e.track) && !isMarker(e.track) && e.recIn != null && e.recOut != null);
+  // AAF exports one event per audio CHANNEL — a stereo/dual-mono clip arrives
+  // as identical A-track legs (measured on a Resolve 19 rich export: every
+  // audio event duplicated). Merge exact duplicates (same track/source/range)
+  // so they place once instead of refusing as a same-track overlap.
+  const audsRaw = events.filter((e) => isAudio(e.track) && e.recIn != null && e.recOut != null);
+  const seenAud = new Set();
+  const auds = [];
+  let audioChannelLegsMerged = 0;
+  for (const e of audsRaw) {
+    const k = `${e.track}|${e.source}|${e.recIn}|${e.recOut}|${e.srcIn}`;
+    if (seenAud.has(k)) { audioChannelLegsMerged += 1; continue; }
+    seenAud.add(k);
+    auds.push(e);
+  }
+  const markerEvents = events.filter((e) => isMarker(e.track) && e.recIn != null);
+  const audioSkipped = events.length - vids.length - audsRaw.length - markerEvents.length;
   if (!vids.length) throw new Error('eventsToAssembleSpec: no video events with record ranges');
 
   const unmapped = [...new Set([...vids, ...auds].map((e) => e.source).filter((srcName) => !sourceMap[srcName]))];
@@ -426,12 +441,32 @@ export function eventsToAssembleSpec(events, opts = {}) {
     transitions.push({ track: c.track, atFrame: c.atFrame, durationFrames: c.durationFrames, trackType: 'audio' });
   }
 
+  // Turnover markers (EDL * LOC: locators, OTIO Marker objects) → authored
+  // timeline markers. Interchange colors map to the measured Resolve names;
+  // unknown colors fall back to Blue. Frames are timeline-absolute like cuts.
+  const COLOR_MAP = {
+    blue: 'Blue', cyan: 'Cyan', green: 'Green', yellow: 'Yellow', red: 'Red',
+    pink: 'Pink', purple: 'Purple', magenta: 'Fuchsia', fuchsia: 'Fuchsia',
+    rose: 'Rose', lavender: 'Lavender', sky: 'Sky', mint: 'Mint',
+    lemon: 'Lemon', sand: 'Sand', cocoa: 'Cocoa', cream: 'Cream',
+    orange: 'Sand', white: 'Cream', black: 'Cocoa',
+  };
+  const markers = markerEvents
+    .map((e) => ({
+      frame: ORIGIN + (toTl(e.recIn, e.fps) - minRec),
+      color: COLOR_MAP[String(e.color || '').toLowerCase()] || 'Blue',
+      ...(e.name ? { name: e.name } : {}),
+    }))
+    .filter((m) => m.frame >= (preserveStartTimecode ? startFrame : DEFAULT_ORIGIN));
+
   return {
-    spec: { timelineName, media, ...(preserveStartTimecode ? { startFrame } : {}), ...(transitions.length ? { transitions } : {}) },
+    spec: { timelineName, media, ...(preserveStartTimecode ? { startFrame } : {}), ...(markers.length ? { markers } : {}), ...(transitions.length ? { transitions } : {}) },
     report: {
       videoEvents: vids.length,
       sources: media.length,
       audioEventsSkipped: audioSkipped,
+      authoredMarkers: markers.length,
+      audioChannelLegsMerged,
       authoredAudioEvents: audioPlacements.length,
       audioRetimesSkipped,
       upperTrackCutsVideoOnly: placements.filter((pl) => pl.track > 1).length,

package/resolve-advanced/server/editorial.mjs

@@ -49,6 +49,8 @@ function evt(o) {
   return {
     index: o.index ?? null,
     track: o.track || 'V',
+    ...(o.name !== undefined ? { name: o.name } : {}),
+    ...(o.color !== undefined ? { color: o.color } : {}),
     source: o.source || 'UNKNOWN',
     srcIn: o.srcIn ?? null,
     srcOut: o.srcOut ?? null,
@@ -83,6 +85,19 @@ export function parseEDL(text, opts = {}) {
       }
       continue;
     }
+    // Avid-style locators: `* LOC: 01:00:01:12 BLUE marker text` — a marker
+    // 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.
+    const loc = /^\*\s*LOC:\s*(\d{2}:\d{2}:\d{2}[:;]\d{2})\s+(\S+)\s*(.*)$/i.exec(line);
+    if (loc) {
+      events.push(evt({
+        index: events.length + 1, track: 'MARKER', source: '',
+        recIn: tcToFrames(loc[1], fps), recOut: null,
+        name: loc[3].trim() || undefined, color: loc[2], fps,
+      }));
+      continue;
+    }
     const tokens = line.split(/\s+/);
     if (!/^\d+$/.test(tokens[0])) continue; // not an event line
     const tcs = tokens.filter(isTc);
@@ -147,6 +162,14 @@ export function parseOTIO(otio, opts = {}) {
           }
         }
         const src = (child.media_reference && (child.media_reference.target_url || child.media_reference.name)) || child.name || 'UNKNOWN';
+        for (const mk of child.markers || []) {
+          const mrStart = (mk.marked_range && mk.marked_range.start_time && mk.marked_range.start_time.value) || 0;
+          events.push(evt({
+            index: idx++, track: 'MARKER', source: '',
+            recIn: rec + (mrStart - startVal), recOut: null,
+            name: mk.name || undefined, color: mk.color || undefined, fps: rate,
+          }));
+        }
         events.push(
           evt({
             index: idx++,

package/resolve-advanced/vendor/drp-format/assemble-timeline.js

@@ -122,14 +122,19 @@ async function assembleTimeline(spec = {}) {
     sources.forEach((src, i) => {
       (src.cuts || []).forEach((cut) => {
         const out = mediaRefs[i] ? { ...cut, mediaRef: mediaRefs[i] } : { ...cut };
-        if (cut.audioOnly) {
-          out.srcMeta = {
-            name: src.mediaFilePath.split('/').pop(),
-            mediaFilePath: src.mediaFilePath,
-            fps: Math.round(src.spec.fps || 24),
-            frameCount: src.spec.frameCount,
-          };
-        }
+        if (caches[i] && caches[i].mediaStartTime) out.mediaStartTime = caches[i].mediaStartTime;
+        out.srcMeta = {
+          name: src.mediaFilePath.split('/').pop(),
+          mediaFilePath: src.mediaFilePath,
+          fps: Math.round(src.spec.fps || 24),
+          frameCount: src.spec.frameCount,
+        };
+        // Prefer cloning the source's own CAPTURED timeline clip: it carries
+        // every native identity field (FieldsBlob, rate, timemap, TC base)
+        // at once. Donor-clone + field rewrites is the fallback for caches
+        // captured before clip elements were harvested.
+        if (caches[i] && caches[i].videoClipElement) out.donorClipVideo = caches[i].videoClipElement;
+        if (caches[i] && caches[i].audioClipElement) out.donorClipAudio = caches[i].audioClipElement;
         if (cut.reverse || (cut.speed !== undefined && cut.speed !== 1)) {
           // Constant-speed retime (forward only). The Sm2TimeMap spans the
           // whole source stretched by 1/speed; the clip windows into it with

package/resolve-advanced/vendor/drp-format/cut-media.js

@@ -73,8 +73,19 @@ async function cutSourceIntoClips(drpInput, opts = {}) {
   let xml = seqXml;
   const clipDbIds = [];
 
-  const cloneCut = (donor, cut) => {
-    let c = freshDbIds(donor);
+  const cloneCut = (donor, cut, kind) => {
+    // Prefer the source's own CAPTURED clip of the matching kind — the A1
+    // mirror clones AUDIO even for plain video cuts, so the donor must be
+    // chosen per track type, never per cut flavor (a video element in an
+    // audio track aborts the whole import, measured E31e).
+    // NATIVE-DONOR PATH (live verification PENDING — a stuck Resolve modal
+    // ended the E31 session before any import of this path could be
+    // measured cleanly; only caches that carry videoClipElement /
+    // audioClipElement reach it, so ordinary captures keep the proven donor
+    // path). Donor clones from splitClipElements come <Element>-wrapped and
+    // Items concatenation depends on the wrapper.
+    const native = kind === 'audio' ? cut.donorClipAudio : cut.donorClipVideo;
+    let c = freshDbIds(native ? native.trim() : donor);
     c = setClipStart(c, cut.startFrame);
     c = setClipDuration(c, cut.durationFrames);
     c = setClipIn(c, cut.srcIn ?? 0);
@@ -83,13 +94,13 @@ async function cutSourceIntoClips(drpInput, opts = {}) {
       // element instead of the donor's.
       c = c.replace(/<MediaRef>[0-9a-f-]{36}<\/MediaRef>/, `<MediaRef>${cut.mediaRef}</MediaRef>`);
     }
-    if (cut.audioOnly && cut.srcMeta) {
-      // An audio-only clone must carry ITS OWN source identity — a live
-      // A2-placed clip (harvested via AppendToTimeline mediaType:2) differs
-      // from a donor clone in Name, MediaFilePath, MediaFrameRate (the
-      // template donor's was 29.97!), the identity MediaTimemapBA extent,
-      // and FieldsBlob. A clone keeping donor values imports and reads back
-      // fine but renders SILENT off A1.
+    if (cut.srcMeta && !native && cut.audioOnly) {
+      // Every clone must carry ITS OWN source identity — a donor clone
+      // keeping stale Name/MediaFilePath/MediaFrameRate (the template
+      // donor's was 29.97!) or the donor's identity-timemap extent imports
+      // and reads back fine but fails at render: audio renders SILENT off
+      // A1 (measured, E15), and a TC-bearing video source fails the whole
+      // render with "Full resolution media not found" (measured, E31).
       const { name, mediaFilePath, fps, frameCount } = cut.srcMeta;
       c = c.replace(/<Name>[\s\S]*?<\/Name>/, `<Name>${name}</Name>`);
       c = c.replace(/<MediaFilePath>[\s\S]*?<\/MediaFilePath>/, `<MediaFilePath>${mediaFilePath}</MediaFilePath>`);
@@ -100,8 +111,17 @@ async function cutSourceIntoClips(drpInput, opts = {}) {
       idm.writeUInt8(0x02, 0);
       idm.writeDoubleBE((frameCount - 1) / fps, 1);
       c = c.replace(/<MediaTimemapBA>[0-9a-fA-F]*<\/MediaTimemapBA>/, `<MediaTimemapBA>${idm.toString('hex')}</MediaTimemapBA>`);
-      // Generic audio-clip FieldsBlob, verbatim from the live A2 harvest.
-      c = c.replace(/<FieldsBlob>[0-9a-fA-F]*<\/FieldsBlob>/, '<FieldsBlob>0000000200000005800a022001</FieldsBlob>');
+      if (cut.audioOnly) {
+        // Generic audio-clip FieldsBlob, verbatim from the live A2 harvest.
+        // (Video clones keep their blob — repointClipBlobsInXml owns it.)
+        c = c.replace(/<FieldsBlob>[0-9a-fA-F]*<\/FieldsBlob>/, '<FieldsBlob>0000000200000005800a022001</FieldsBlob>');
+      }
+    }
+    if (cut.mediaStartTime !== undefined && cut.mediaStartTime !== null && !native) {
+      // Embedded source timecode base, in SECONDS (harvested with the media
+      // template). Donor default 0 makes Resolve seek the wrong TC and fail
+      // the render with "Full resolution media not found at <TC>".
+      c = c.replace(/<MediaStartTime>[\s\S]*?<\/MediaStartTime>/, `<MediaStartTime>${cut.mediaStartTime}</MediaStartTime>`);
     }
     if (cut.timemap) {
       // Constant-speed retime: swap the identity MediaTimemapBA for the
@@ -140,13 +160,13 @@ async function cutSourceIntoClips(drpInput, opts = {}) {
         for (let t = 1; t <= tracks.length; t += 1) {
           const mine = audioCuts.filter((cut) => (cut.track ?? 1) === t);
           if (t > 1 && !mine.length) continue;
-          tracks[t - 1] = setItemsInner(tracks[t - 1], mine.map((cut) => cloneCut(donor, cut)).join(''));
+          tracks[t - 1] = setItemsInner(tracks[t - 1], mine.map((cut) => cloneCut(donor, cut, 'audio')).join(''));
         }
       } else {
         // A1 mirrors track-1 video cuts only; higher video tracks stay
         // video-only, and so do RETIMED cuts (the audio clone would need its
         // own timemap and pitch handling — video-only is stated, not silent).
-        const a1 = cuts.filter((cut) => (cut.track ?? 1) === 1 && !cut.timemap).map((cut) => cloneCut(donor, cut));
+        const a1 = cuts.filter((cut) => (cut.track ?? 1) === 1 && !cut.timemap).map((cut) => cloneCut(donor, cut, 'audio'));
         tracks[0] = setItemsInner(tracks[0], a1.join(''));
       }
       xml = replaceTrackVec(xml, trackType, match, tracks);
@@ -159,7 +179,7 @@ async function cutSourceIntoClips(drpInput, opts = {}) {
     for (let t = 1; t <= tracks.length; t += 1) {
       const mine = vCuts.filter((cut) => (cut.track ?? 1) === t);
       if (t > 1 && !mine.length) continue; // grown-empty or untouched track keeps its items
-      const clones = mine.map((cut) => cloneCut(donor, cut));
+      const clones = mine.map((cut) => cloneCut(donor, cut, 'video'));
       for (const c of clones) clipDbIds.push(clipDbId(c));
       tracks[t - 1] = setItemsInner(tracks[t - 1], clones.join(''));
     }

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.118.0"
+VERSION = "2.120.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.118.0"
+VERSION = "2.120.0"
 
 import base64
 import os
@@ -13879,6 +13879,21 @@ def _capture_media_template(r, pm, p: Dict[str, Any]) -> Dict[str, Any]:
         media_ref_m = re.search(r"<MediaRef>([0-9a-f-]{36})</MediaRef>", seq_xml)
         if end < 0 or not media_ref_m:
             return _err("could not isolate the media element / MediaRef from the capture")
+        # Embedded source timecode: Resolve's own timeline clip stores it as
+        # <MediaStartTime> SECONDS. A transplant clone keeping the donor's 0
+        # renders "Full resolution media not found at <TC>" (measured on a
+        # 01:00:00:00-TC source). Carry it so assemble can set it per cut.
+        mst_m = re.search(r"<MediaStartTime>([-0-9.eE]+)</MediaStartTime>", seq_xml)
+        media_start_time = float(mst_m.group(1)) if mst_m else 0.0
+        # Harvest the NATIVE timeline clip elements too: for multi-source
+        # authoring, cloning the template donor leaves the donor's identity
+        # FieldsBlob on other sources' cuts — readback-fine, but the render
+        # fails ("Full resolution media not found") or, once Name/path are
+        # corrected, the whole import aborts on the inconsistency (measured,
+        # E31). Cloning the source's own captured clip carries every native
+        # field at once.
+        vclip_m = re.search(r"<Element>\s*<Sm2TiVideoClip[\s\S]*?</Sm2TiVideoClip>\s*</Element>", seq_xml)
+        aclip_m = re.search(r"<Element>\s*<Sm2TiAudioClip[\s\S]*?</Sm2TiAudioClip>\s*</Element>", seq_xml)
         pool_element = mp_xml[start:end]
         media_ref = media_ref_m.group(1)
         if media_ref not in pool_element:
@@ -13892,7 +13907,10 @@ def _capture_media_template(r, pm, p: Dict[str, Any]) -> Dict[str, Any]:
             "mtimeMs": stat.st_mtime * 1000.0,
             "sizeBytes": stat.st_size,
             "mediaRef": media_ref,
+            "mediaStartTime": media_start_time,
             "poolElement": pool_element,
+            "videoClipElement": vclip_m.group(0) if vclip_m else None,
+            "audioClipElement": aclip_m.group(0) if aclip_m else None,
         }
         with open(cache_path, "w", encoding="utf-8") as fh:
             json.dump(payload, fh)