davinci-resolve-mcp 2.119.0 → 2.121.0

package/install.py

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

@@ -231,9 +231,22 @@ export function eventsToAssembleSpec(events, opts = {}) {
   const isAudio = (t) => /^A\d*$/.test(String(t || ''));
   const isMarker = (t) => t === 'MARKER';
   const vids = events.filter((e) => !isAudio(e.track) && !isMarker(e.track) && e.recIn != null && e.recOut != null);
-  const auds = events.filter((e) => isAudio(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 - auds.length - markerEvents.length;
+  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]))];
@@ -453,6 +466,7 @@ export function eventsToAssembleSpec(events, opts = {}) {
       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

@@ -141,6 +141,16 @@ export function parseOTIO(otio, opts = {}) {
     // First track of each kind keeps the bare letter (compat); higher tracks
     // are numbered ('V2', 'A2', …).
     const kind = isAudio ? (aNum === 1 ? 'A' : `A${aNum}`) : (vNum === 1 ? 'V' : `V${vNum}`);
+    // Track-level markers: marked_range is already in track (record) time.
+    for (const mk of track.markers || []) {
+      const mrStart = (mk.marked_range && mk.marked_range.start_time && mk.marked_range.start_time.value) || 0;
+      const mrRate = (mk.marked_range && mk.marked_range.start_time && mk.marked_range.start_time.rate) || opts.fps || 24;
+      events.push(evt({
+        index: idx++, track: 'MARKER', source: '',
+        recIn: mrStart, recOut: null,
+        name: mk.name || undefined, color: mk.color || undefined, fps: mrRate,
+      }));
+    }
     let rec = 0;
     for (const child of track.children || []) {
       const schema = child.OTIO_SCHEMA || '';
@@ -429,5 +439,20 @@ export function markerRoundtrip(markers, opts = {}) {
     throw new Error(`marker_roundtrip: ${markers.length} in, ${decoded.length} out — round-trip dropped markers`);
   const provenanceOk = decoded.every((m) => typeof m.provenance === 'string' && m.provenance.length);
   if (markers.length && !provenanceOk) throw new Error('marker_roundtrip: a marker lost its provenance tag');
-  return { count: decoded.length, markers: decoded, provenanceOk, roundTrip: 'ok' };
+  // Binary round-trip through the REAL Sm2SequenceLockableBlob codec
+  // (byte-exact vs a live export): provenance rides in customData, so an
+  // authored .drt carries it. Colors outside the measured 16 refuse there —
+  // markerRoundtrip normalizes to 'Blue' above, so this cannot throw for
+  // valid input; if it ever does, that IS the failed round-trip.
+  let blobRoundTrip = 'skipped (no markers)';
+  if (normalized.length) {
+    const { encodeTimelineMarkersBlob, decodeTimelineMarkersBlob } = require('../vendor/drp-format/timeline-markers-blob.js');
+    const back = decodeTimelineMarkersBlob(encodeTimelineMarkersBlob(normalized.map((m) => ({
+      frame: m.frame, color: m.color, name: m.name, note: m.note, customData: m.provenance,
+    }))));
+    if (back.length !== normalized.length) throw new Error(`marker_roundtrip: blob codec ${normalized.length} in, ${back.length} out`);
+    if (!back.every((m) => m.customData && m.customData.length)) throw new Error('marker_roundtrip: provenance lost in the blob codec');
+    blobRoundTrip = 'ok';
+  }
+  return { count: decoded.length, markers: decoded, provenanceOk, roundTrip: 'ok', blobRoundTrip };
 }

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/resolve-advanced/vendor/drp-format/seq-container-builder.js

@@ -338,9 +338,15 @@ function buildLockableBlobElement(markers, blobId, frameRate) {
     ]);
   }
 
-  // Build marker protobuf (simplified - actual markers would need full encoding)
-  // For now, return minimal structure that DaVinci can parse
-  const fieldsBlobHex = buildMarkersFieldsBlob(markers, frameRate);
+  // Real Sm2SequenceLockableBlob encoding (byte-exact vs a live 19.1.3.7
+  // export; see timeline-markers-blob.js) — replaces the old simplified
+  // marker-encoder blob, whose bytes never matched a real export.
+  const { encodeTimelineMarkersBlob } = require('./timeline-markers-blob');
+  const fieldsBlobHex = encodeTimelineMarkersBlob(markers.map((m) => ({
+    frame: Number(m.frame) || 0,
+    color: m.color, name: m.name, note: m.note ?? m.description,
+    duration: m.duration, customData: m.customData,
+  }))).toString('hex');
 
   return buildXmlElement('Sm2SequenceLockableBlob', { DbId: blobId }, [
     buildXmlElement('FieldsBlob', {}, fieldsBlobHex),

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.119.0"
+VERSION = "2.121.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.119.0"
+VERSION = "2.121.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)