davinci-resolve-mcp 2.111.0 → 2.113.0

package/docs/reference/api-limitations.md

@@ -12,7 +12,7 @@ that none exists).
 
 **Verified on:** DaVinci Resolve Studio 21.0.2
 
-**Totals:** 33 missing capabilities, 42 bugs / unreliable behaviors.
+**Totals:** 33 missing capabilities, 43 bugs / unreliable behaviors.
 
 The authoritative source is the runtime-queryable `api_truth` ledger
 (`resolve_control api_truth "<query>"`); this document is generated from
@@ -526,6 +526,13 @@ values, or automation-hostile modal prompts.
 - **Reference:** [issue #171](https://github.com/samuelgursky/davinci-resolve-mcp/issues/171)
 - **Tags:** timeline, import, silent-failure, unreliable-return
 
+### MediaTimemapBA keyframes are generation-split; 19.x silently ignores the R21 protobuf form
+
+- **Object:** `Sm2TimeMap (per-clip retime blob)`
+- **Behavior:** Resolve 21 encodes a retimed clip's KeyframesBA as protobuf points; Resolve 19.1.3 encodes it as a keyed-dict of keyed-dict keyframes ({interp, YOut, YIn, Y, XOut, XIn, X}). On import, 19 SILENTLY IGNORES the protobuf form — the clip reads back and plays at 100% with no warning (measured: identical timelines, one per form; protobuf → source 0..96 over 96 frames, keyed → source 0..48 over 96 frames and a live 50% render). The map spans the WHOLE source stretched by 1/speed; the clip's <In>/<Duration> window into it in RECORD frames (srcIn converts by /speed).
+- **Workaround / current handling:** Author retimes for pre-21 hosts with the keyed form (drt.assemble cuts[].speed does this; encoder byte-exact against a live 19.1.3.7 harvest). Treat any cross-generation timemap as unverified until a readback shows the retimed source range.
+- **Tags:** retime, import, silent-failure, drt
+
 ### Imported Fusion comps render via byte-keyed disk cache on 19.x (offline comp edits render black)
 
 - **Object:** `Fusion / render engine`

package/install.py

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

@@ -202,7 +202,9 @@ export function eventsToOTIO(events, opts = {}) {
  * timeline runs 24fps with origin 86400, so rec/src frames convert as
  * round(frames × 24 / nominalFps). Placement anchors the EARLIEST video
  * event at the origin. Honesty ledger in the returned report: flattened
- * retimes (the template clip schema has no per-clip speed), authored vs
+ * reverse retimes (forward constant speeds are AUTHORED as real Sm2TimeMaps
+ * — r19 keyed form, render/readback-verified; reverse flattens with the
+ * reason), authored vs
  * dropped transitions (cross-dissolves are AUTHORED when the predecessor
  * abuts the cut and both sides have handle media — render-verified on
  * 19.1.3.7; otherwise dropped with the reason, as a cut at the boundary),
@@ -238,7 +240,10 @@ export function eventsToAssembleSpec(events, opts = {}) {
   }
 
   const toTl = (frames, fps) => Math.round((frames * 24) / Math.round(fps || 24));
+  // 'V'/'V1' → 1, 'V2' → 2, … (parsers number video tracks; EDL is single-V).
+  const trackNum = (t) => { const m = /^V(\d+)?$/.exec(String(t || 'V')); return m ? (m[1] ? parseInt(m[1], 10) : 1) : 1; };
   const flattenedRetimes = [];
+  const authoredRetimes = [];
   const droppedTransitions = [];
   const transitionCandidates = [];
   const perSource = new Map();
@@ -250,10 +255,20 @@ export function eventsToAssembleSpec(events, opts = {}) {
     const recOut = ORIGIN + (toTl(e.recOut, e.fps) - minRec);
     const durationFrames = recOut - recIn;
     if (durationFrames <= 0) continue;
+    const vTrack = trackNum(e.track);
+    const cut = { startFrame: recIn, durationFrames, srcIn: toTl(e.srcIn ?? 0, e.fps), ...(vTrack > 1 ? { track: vTrack } : {}) };
     if ((e.speed ?? 100) !== 100 || e.reverse) {
-      flattenedRetimes.push({ index: e.index, source: e.source, speed: e.speed, reverse: !!e.reverse });
+      if (e.reverse || !(e.speed > 0)) {
+        // Reverse needs a descending timemap (not yet measured) — flatten, with the reason.
+        flattenedRetimes.push({ index: e.index, source: e.source, speed: e.speed, reverse: !!e.reverse, reason: 'reverse not supported — played forward at 100%' });
+      } else {
+        // Forward constant speed: authored as a real Sm2TimeMap on the cut
+        // (r19 keyed form; render/readback-verified on 19.1.3.7). Audio for
+        // retimed cuts is video-only downstream.
+        cut.speed = e.speed / 100;
+        authoredRetimes.push({ index: e.index, source: e.source, speed: e.speed });
+      }
     }
-    const cut = { startFrame: recIn, durationFrames, srcIn: toTl(e.srcIn ?? 0, e.fps) };
     if (e.transition) {
       // A dissolve INTO this event, at its record-in boundary. Whether it can
       // be authored (abutting predecessor + handles both sides) is decided
@@ -261,24 +276,33 @@ export function eventsToAssembleSpec(events, opts = {}) {
       let d = Math.max(2, toTl(e.transition.duration || 0, e.fps) || 2);
       d += d % 2; // placeTransition centers on the cut; keep it even
       transitionCandidates.push({
-        atFrame: recIn, durationFrames: d,
+        atFrame: recIn, durationFrames: d, track: vTrack,
         index: e.index, type: e.transition.type, rawDuration: e.transition.duration,
         source: e.source, srcIn: cut.srcIn,
       });
     }
-    placements.push({ start: recIn, end: recOut, index: e.index, source: e.source, srcIn: cut.srcIn, durationFrames });
+    placements.push({ start: recIn, end: recOut, index: e.index, source: e.source, srcIn: cut.srcIn, durationFrames, track: vTrack });
     if (!perSource.has(e.source)) perSource.set(e.source, []);
     perSource.get(e.source).push(cut);
   }
 
+  // Overlap is judged PER VIDEO TRACK — V2 stacking over V1 is legitimate
+  // conform geometry (render-verified: an upper-track clip covers the lower).
   placements.sort((a, b) => a.start - b.start);
-  for (let i = 1; i < placements.length; i += 1) {
-    if (placements[i].start < placements[i - 1].end) {
-      throw new Error(
-        `eventsToAssembleSpec: events ${placements[i - 1].index} and ${placements[i].index} ` +
-        'overlap on the record track after frame conversion — a single V1 cannot hold both. ' +
-        'Resolve the overlap upstream (transitions count as cuts at their boundary here).',
-      );
+  const byTrack = new Map();
+  for (const pl of placements) {
+    if (!byTrack.has(pl.track)) byTrack.set(pl.track, []);
+    byTrack.get(pl.track).push(pl);
+  }
+  for (const [trk, pls] of byTrack) {
+    for (let i = 1; i < pls.length; i += 1) {
+      if (pls[i].start < pls[i - 1].end) {
+        throw new Error(
+          `eventsToAssembleSpec: events ${pls[i - 1].index} and ${pls[i].index} ` +
+          `overlap on video track ${trk} after frame conversion — one track cannot hold both. ` +
+          'Resolve the overlap upstream (transitions count as cuts at their boundary here).',
+        );
+      }
     }
   }
 
@@ -297,7 +321,7 @@ export function eventsToAssembleSpec(events, opts = {}) {
   // with the reason.
   const transitions = [];
   for (const c of transitionCandidates) {
-    const prev = placements.find((pl) => pl.end === c.atFrame);
+    const prev = placements.find((pl) => pl.track === c.track && pl.end === c.atFrame);
     if (!prev) {
       droppedTransitions.push({ index: c.index, type: c.type, duration: c.rawDuration, reason: 'no abutting predecessor at the cut' });
       continue;
@@ -315,7 +339,7 @@ export function eventsToAssembleSpec(events, opts = {}) {
       });
       continue;
     }
-    transitions.push({ track: 1, atFrame: c.atFrame, durationFrames: c.durationFrames });
+    transitions.push({ track: c.track, atFrame: c.atFrame, durationFrames: c.durationFrames });
   }
 
   return {
@@ -324,7 +348,9 @@ export function eventsToAssembleSpec(events, opts = {}) {
       videoEvents: vids.length,
       sources: media.length,
       audioEventsSkipped: audioSkipped,
+      upperTrackCutsVideoOnly: placements.filter((pl) => pl.track > 1).length,
       flattenedRetimes,
+      authoredRetimes,
       authoredTransitions: transitions,
       droppedTransitions,
       origin: ORIGIN,

package/resolve-advanced/server/editorial.mjs

@@ -116,8 +116,12 @@ export function parseOTIO(otio, opts = {}) {
   const tracks = (doc.tracks && doc.tracks.children) || [];
   const events = [];
   let idx = 1;
+  let vNum = 0;
   for (const track of tracks) {
-    const kind = track.kind === 'Audio' ? 'A' : 'V';
+    const isAudio = track.kind === 'Audio';
+    if (!isAudio) vNum += 1;
+    // First video track stays 'V' (compat); higher tracks are 'V2', 'V3', …
+    const kind = isAudio ? 'A' : (vNum === 1 ? 'V' : `V${vNum}`);
     let rec = 0;
     for (const child of track.children || []) {
       const schema = child.OTIO_SCHEMA || '';
@@ -199,7 +203,7 @@ export function parseXMEMLEvents(xml, opts = {}) {
   const media = seq && seq.media;
   if (media) {
     const vtracks = media.video && media.video.track ? (Array.isArray(media.video.track) ? media.video.track : [media.video.track]) : [];
-    for (const t of vtracks) if (t.clipitem) walk(t.clipitem, 'V');
+    vtracks.forEach((t, vi) => { if (t.clipitem) walk(t.clipitem, vi === 0 ? 'V' : `V${vi + 1}`); });
     const atracks = media.audio && media.audio.track ? (Array.isArray(media.audio.track) ? media.audio.track : [media.audio.track]) : [];
     for (const t of atracks) if (t.clipitem) walk(t.clipitem, 'A');
   }
@@ -320,7 +324,7 @@ export function timingGuards(oldEvents, newEvents) {
     const ne = matches[0];
     if (!ne) {
       // A dropped audio event where its video sibling survives → dropped J/L-cut audio.
-      if (oe.track === 'A' && newEvents.some((x) => x.track === 'V' && x.source === oe.source))
+      if (oe.track === 'A' && newEvents.some((x) => x.track !== 'A' && x.source === oe.source))
         flags.push({ kind: 'dropped_split_audio', source: oe.source, detail: 'audio event gone but video sibling present (J/L-cut lost)' });
       continue;
     }

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

@@ -46,7 +46,7 @@ const assembleSchema = z.object({
   spec: z
     .object({})
     .passthrough()
-    .describe("assembleTimeline spec: { timelineName?, media?: {mediaFilePath, spec:{width,height,frameCount,fps}, cuts:[{startFrame,durationFrames,srcIn?}]} | [same, ...] (multi-source needs media_pool.capture_media_template run once per file), elements?: [{type:'title'|'generator', track, startFrame, durationFrames?, text?, generatorName? ('Solid Color'|'SMPTE Color Bar'|'Grey Scale' render-verified on 19), ...}], transitions? }. startFrame is timeline-absolute (origin 86400)."),
+    .describe("assembleTimeline spec: { timelineName?, media?: {mediaFilePath, spec:{width,height,frameCount,fps}, cuts:[{startFrame,durationFrames,srcIn?,track? (1-based video track; >1 = video-only, render-verified stacking),speed? (forward constant retime, e.g. 0.5; video-only; render-verified on 19)}]} | [same, ...] (multi-source needs media_pool.capture_media_template run once per file), elements?: [{type:'title'|'generator', track, startFrame, durationFrames?, text?, generatorName? ('Solid Color'|'SMPTE Color Bar'|'Grey Scale' render-verified on 19), ...}], transitions? }. startFrame is timeline-absolute (origin 86400)."),
   outputPath: z.string().describe('Absolute path where the importable .drt will be written'),
   targetAppVersion: z
     .union([z.string(), z.number()])

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

@@ -25,6 +25,8 @@ const { createEmptyProject, addMediaClip, DEFAULT_START_FRAME } = require('./aut
 const { loadMediaTemplate, transplantMediaElement, insertMediaElement } = require('./media-template-cache');
 const JSZip = require('jszip');
 const { cutSourceIntoClips } = require('./cut-media');
+const { buildConstantSpeedTimemapKeyed } = require('./media-timemap');
+const { randomUUID } = require('node:crypto');
 const { placeFusionTitle } = require('./place-fusion-title');
 const { placeGenerator } = require('./place-generator');
 const { placeTransition } = require('./place-transition');
@@ -111,7 +113,22 @@ async function assembleTimeline(spec = {}) {
     const allCuts = [];
     sources.forEach((src, i) => {
       (src.cuts || []).forEach((cut) => {
-        allCuts.push(mediaRefs[i] ? { ...cut, mediaRef: mediaRefs[i] } : { ...cut });
+        const out = mediaRefs[i] ? { ...cut, mediaRef: mediaRefs[i] } : { ...cut };
+        if (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
+          // RECORD-domain In/Duration (measured live on 19.1.3.7), so the
+          // source-domain srcIn converts by /speed here.
+          if (!(cut.speed > 0)) throw new RangeError('assembleTimeline: cut.speed must be > 0 (reverse not supported)');
+          const fps = Math.round(src.spec.fps || 24);
+          out.timemap = buildConstantSpeedTimemapKeyed({
+            speed: cut.speed, sourceFrames: src.spec.frameCount, fps,
+            uniqueId: randomUUID(),
+          }).toString('hex');
+          out.srcIn = Math.round((cut.srcIn ?? 0) / cut.speed);
+          delete out.speed;
+        }
+        allCuts.push(out);
       });
     });
     allCuts.sort((a, b) => a.startFrame - b.startFrame);

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

@@ -24,16 +24,20 @@ const {
   freshDbIds,
   getTrackVec,
   replaceTrackVec,
+  emptyTrackClone,
 } = require('./seq-surgery');
 const { clipDbId, setClipStart, setClipDuration, setClipIn } = require('./splice-clips');
 
 /**
  * @param {Buffer|string} drpInput
  * @param {object} opts
- * @param {Array<{startFrame:number, durationFrames:number, srcIn?:number}>} opts.cuts
+ * @param {Array<{startFrame:number, durationFrames:number, srcIn?:number, track?:number}>} opts.cuts
  *   Timeline placements. startFrame is timeline-absolute (origin 86400 on the
  *   bundled templates — clips before the origin are dropped by Resolve on
  *   import, silently). srcIn is the source in-point in TIMELINE frames.
+ *   track is the 1-based VIDEO track (default 1); missing tracks are grown as
+ *   empty clones. Cuts on track > 1 are placed VIDEO-ONLY — their audio would
+ *   overlap the track-1 cuts' audio on A1 (the template has a single A1).
  * @param {string} [opts.timelineUuid]
  * @returns {Promise<{buffer: Buffer, cutCount: number, clipDbIds: string[]}>}
  */
@@ -52,6 +56,12 @@ async function cutSourceIntoClips(drpInput, opts = {}) {
     if (cut.mediaRef !== undefined && !/^[0-9a-f-]{36}$/.test(cut.mediaRef)) {
       throw new TypeError(`cutSourceIntoClips: cuts[${i}].mediaRef must be a uuid`);
     }
+    if (cut.track !== undefined && (!Number.isInteger(cut.track) || cut.track < 1)) {
+      throw new TypeError(`cutSourceIntoClips: cuts[${i}].track must be a positive integer`);
+    }
+    if (cut.timemap !== undefined && !/^[0-9a-fA-F]+$/.test(cut.timemap)) {
+      throw new TypeError(`cutSourceIntoClips: cuts[${i}].timemap must be a hex MediaTimemapBA blob`);
+    }
   });
 
   const zip = await loadDrpZip(drpInput);
@@ -59,6 +69,25 @@ async function cutSourceIntoClips(drpInput, opts = {}) {
   let xml = seqXml;
   const clipDbIds = [];
 
+  const cloneCut = (donor, cut) => {
+    let c = freshDbIds(donor);
+    c = setClipStart(c, cut.startFrame);
+    c = setClipDuration(c, cut.durationFrames);
+    c = setClipIn(c, cut.srcIn ?? 0);
+    if (cut.mediaRef) {
+      // Multi-source: point this cut at ITS source's transplanted pool
+      // element instead of the donor's.
+      c = c.replace(/<MediaRef>[0-9a-f-]{36}<\/MediaRef>/, `<MediaRef>${cut.mediaRef}</MediaRef>`);
+    }
+    if (cut.timemap) {
+      // Constant-speed retime: swap the identity MediaTimemapBA for the
+      // caller-built Sm2TimeMap (r19 keyed form render/readback-verified;
+      // the clip's <In>/<Duration> are RECORD-domain, measured live).
+      c = c.replace(/<MediaTimemapBA>[0-9a-fA-F]*<\/MediaTimemapBA>/, `<MediaTimemapBA>${cut.timemap}</MediaTimemapBA>`);
+    }
+    return c;
+  };
+
   for (const trackType of ['video', 'audio']) {
     const { match, tracks } = getTrackVec(xml, trackType);
     if (!tracks.length) continue;
@@ -66,22 +95,25 @@ async function cutSourceIntoClips(drpInput, opts = {}) {
     const clips = splitClipElements(items);
     if (!clips.length) continue; // audio-less media: nothing to cut on A1
     const donor = clips[0];
-    const clones = cuts.map((cut) => {
-      let c = freshDbIds(donor);
-      c = setClipStart(c, cut.startFrame);
-      c = setClipDuration(c, cut.durationFrames);
-      c = setClipIn(c, cut.srcIn ?? 0);
-      if (cut.mediaRef) {
-        // Multi-source: point this cut at ITS source's transplanted pool
-        // element instead of the donor's.
-        c = c.replace(/<MediaRef>[0-9a-f-]{36}<\/MediaRef>/, `<MediaRef>${cut.mediaRef}</MediaRef>`);
-      }
-      return c;
-    });
-    if (trackType === 'video') {
+    if (trackType === 'audio') {
+      // 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));
+      tracks[0] = setItemsInner(tracks[0], a1.join(''));
+      xml = replaceTrackVec(xml, trackType, match, tracks);
+      continue;
+    }
+    const maxTrack = Math.max(1, ...cuts.map((cut) => cut.track ?? 1));
+    const cloneSource = tracks[0];
+    while (tracks.length < maxTrack) tracks.push(emptyTrackClone(cloneSource));
+    for (let t = 1; t <= tracks.length; t += 1) {
+      const mine = cuts.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));
       for (const c of clones) clipDbIds.push(clipDbId(c));
+      tracks[t - 1] = setItemsInner(tracks[t - 1], clones.join(''));
     }
-    tracks[0] = setItemsInner(tracks[0], clones.join(''));
     xml = replaceTrackVec(xml, trackType, match, tracks);
   }
 

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

@@ -209,8 +209,55 @@ function buildConstantSpeedTimemap({ speed, sourceDurationSec, uniqueId, recordD
   });
 }
 
+/**
+ * r19-generation constant-speed Sm2TimeMap. Resolve 19.x encodes KeyframesBA
+ * as a keyed-dict of keyed-dict keyframes ({interp,YOut,YIn,Y,XOut,XIn,X}),
+ * NOT the R21 protobuf points — and 19 silently IGNORES the protobuf form on
+ * import (measured: item read back at 100%). Shape harvested from a live
+ * 19.1.3.7 XMEML retime and rebuilt byte-exact. The map spans the ENTIRE
+ * source stretched by 1/speed (the clip's Start/Duration/In window into it):
+ *   YMax = (sourceFrames-1)/fps          — full source extent, seconds
+ *   XMax = (sourceFrames/speed - 1)/fps  — full retimed extent, seconds
+ *   kf0 = (0,0); kf1 = (XMax, XMax*speed); linear (zero handles, interp 0)
+ *
+ * @param {object} p
+ * @param {number} p.speed        - source/record ratio (0.5 = 50%). Forward only.
+ * @param {number} p.sourceFrames - full source frame count at p.fps.
+ * @param {number} [p.fps=24]
+ * @param {string} p.uniqueId     - fresh uuid (bare, no braces).
+ * @returns {Buffer}
+ */
+function buildConstantSpeedTimemapKeyed({ speed, sourceFrames, fps = 24, uniqueId }) {
+  if (!(speed > 0)) throw new RangeError('buildConstantSpeedTimemapKeyed: speed must be > 0 (reverse not supported here)');
+  if (!Number.isInteger(sourceFrames) || sourceFrames < 1) throw new TypeError('buildConstantSpeedTimemapKeyed: sourceFrames must be a positive integer');
+  const YMax = (sourceFrames - 1) / fps;
+  const XMax = (sourceFrames / speed - 1) / fps;
+  const kf = (X, Y) => encodeKeyedDict({ hdr: 1, entries: [
+    { key: 'interp', type: 0x02, subType: 0, value: 0 },
+    { key: 'YOut', type: T_DOUBLE, subType: 0, value: 0 },
+    { key: 'YIn', type: T_DOUBLE, subType: 0, value: 0 },
+    { key: 'Y', type: T_DOUBLE, subType: 0, value: Y },
+    { key: 'XOut', type: T_DOUBLE, subType: 0, value: 0 },
+    { key: 'XIn', type: T_DOUBLE, subType: 0, value: 0 },
+    { key: 'X', type: T_DOUBLE, subType: 0, value: X },
+  ] }).toString('hex');
+  const keyframes = encodeKeyedDict({ hdr: 1, entries: [
+    { key: '1', type: T_BYTES, subType: 0, value: kf(XMax, XMax * speed) },
+    { key: '0', type: T_BYTES, subType: 0, value: kf(0, 0) },
+  ] }).toString('hex');
+  return encodeKeyedDict({ hdr: 1, entries: [
+    { key: 'YMax', type: T_DOUBLE, subType: 0, value: YMax },
+    { key: 'XMax', type: T_DOUBLE, subType: 0, value: XMax },
+    { key: 'UniqueId', type: T_STRING, subType: 0, value: uniqueId },
+    { key: 'LastValidYOffset', type: T_DOUBLE, subType: 0, value: YMax },
+    { key: 'KeyframesBA', type: T_BYTES, subType: 0, value: keyframes },
+    { key: 'DbType', type: T_STRING, subType: 0, value: 'Sm2TimeMap' },
+  ] });
+}
+
 module.exports = {
   decodeTimemap, encodeTimemap, encodeRetimedTimemap,
-  identityTimemap, buildConstantSpeedTimemap, buildTimemap, decodeProtobuf,
+  identityTimemap, buildConstantSpeedTimemap, buildConstantSpeedTimemapKeyed,
+  buildTimemap, decodeProtobuf,
   TYPE_LINEAR,
 };

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.111.0"
+VERSION = "2.113.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.111.0"
+VERSION = "2.113.0"
 
 import base64
 import os

package/src/utils/api_truth.py

@@ -1914,6 +1914,28 @@ API_TRUTH: List[Dict[str, Any]] = [
                        "structural readback cannot see this class.",
         "tags": ["media-pool", "import", "render", "silent-failure", "readback"],
     },
+    {
+        "symbol": "MediaTimemapBA keyframes are generation-split; 19.x silently ignores the R21 protobuf form",
+        "object": "Sm2TimeMap (per-clip retime blob)",
+        "reality": "Resolve 21 encodes a retimed clip's KeyframesBA as "
+                   "protobuf points; Resolve 19.1.3 encodes it as a "
+                   "keyed-dict of keyed-dict keyframes ({interp, YOut, YIn, "
+                   "Y, XOut, XIn, X}). On import, 19 SILENTLY IGNORES the "
+                   "protobuf form — the clip reads back and plays at 100% "
+                   "with no warning (measured: identical timelines, one per "
+                   "form; protobuf → source 0..96 over 96 frames, keyed → "
+                   "source 0..48 over 96 frames and a live 50% render). "
+                   "The map spans the WHOLE source stretched by 1/speed; "
+                   "the clip's <In>/<Duration> window into it in RECORD "
+                   "frames (srcIn converts by /speed).",
+        "recommended": "Author retimes for pre-21 hosts with the keyed "
+                       "form (drt.assemble cuts[].speed does this; encoder "
+                       "byte-exact against a live 19.1.3.7 harvest). Treat "
+                       "any cross-generation timemap as unverified until a "
+                       "readback shows the retimed source range.",
+        "tags": ["retime", "import", "silent-failure", "drt"],
+        "submit": "bug",
+    },
     {
         "symbol": "Imported Fusion comps render via byte-keyed disk cache on 19.x (offline comp edits render black)",
         "object": "Fusion / render engine",