davinci-resolve-mcp 2.195.0 → 2.197.0

package/CHANGELOG.md

@@ -2,6 +2,58 @@
 
 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.197.0 — E145: a named generator is a black leg or a named hole
+
+### Fixed
+
+- **A named generator no longer refuses the whole reel.** Once E141 named
+  Premiere's synthetic items by their title, a Universal Counting Leader
+  arrived at the bridge as an event with no file and no source-map entry,
+  and `eventsToAssembleSpec` refused the entire 228-cut reel as an "unmapped
+  source reel". Now a black generator (Black Video, black, slug) authors as
+  the BL leg it is — a Solid Color that renders black — and any other named
+  generator with no Resolve equivalent is dropped with a reason in
+  `report.unresolvedGenerators` (name, track, record window), a hole the
+  ledger names, the way unresolved compounds already are. A source map that
+  maps the generator's name to a rendered file places it like media. An
+  unmapped real reel still refuses.
+
+On the real turnover: reels 02, 03 and 04 now conform offline through the
+bridge — 226 / 147 / 257 video cuts, every dissolve and retime authored,
+two leaders per reel reported as holes, black authored as black.
+
+## What's New in v2.196.0 — E144: Resolve's own retimes decode; a flat map is a freeze
+
+### Fixed
+
+- **Resolve's own retimes decode.** Every retime Resolve 19.1.3.7 makes
+  itself — an XMEML import, a UI speed change, an EDL `M2` freeze, a speed
+  ramp — writes `KeyframesBA` in the keyed-dict form (keyframes
+  `{interp,YOut,YIn,Y,XOut,XIn,X}` under keys `0`, `1`, …), which the DRP
+  time-map reader rejected ("unsupported wire type 7"), so E140 called them
+  unknown. The reader now decodes both forms; keyframe 0 at X=0 is the
+  origin and its Y the source second the map starts on (4.0 s on a real ramp
+  harvest). Verbatim harvest blobs: a 50% constant reads 50, a ramp reads
+  its two segments (0.5 then 2.0) with the right source window, both freezes
+  read the second they hold.
+- **A source window is the map, evaluated.** A DRT event's `srcIn`/`srcOut`
+  now come from evaluating the piecewise-linear map at `In` and `In +
+  duration` (origin included), which makes ramps, reverses and rebased maps
+  come out right without special cases.
+- **A flat map over the 60000 sentinel is a freeze even with a source-in.**
+  The E66 harvest (an XMEML import of a plain 100% clip) came back with a
+  flat map at Y=0 and `In` 24, and its render is static at the source's frame
+  0: inter-frame change 0.02 against 0.42 in the source. Resolve's XMEML
+  importer froze the clip silently; the event now says frozen at frame 0 and
+  keeps the ignored `In` as `recordDomainIn`. (The first draft of this fix
+  called that map a harmless identity because it fit the prose; the render
+  said otherwise.)
+
+### Measured (filed in api-limitations)
+
+- The keyed-dict keyframe form on Resolve-made retimes, and the freeze
+  law with a present `<In>`.
+
 ## What's New in v2.195.0 — E143: a retimed DRT clip's source-in is record-domain
 
 ### Fixed

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.195.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.197.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.195.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.197.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.195.0 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
+> 本翻译对应 v2.197.0 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
 
 一个 Model Context Protocol (MCP) 服务器，让 AI 助手通过官方脚本 API 控制 DaVinci Resolve Studio（达芬奇）。它提供完整的 API 覆盖，外加带护栏的工作流助手，涵盖剪辑、媒体池整理、渲染设置、审阅标记、调色、Fusion、Fairlight、项目生命周期任务、扩展开发，以及不碰源媒体的媒体分析。
 

package/docs/reference/api-limitations.md

@@ -305,7 +305,7 @@ equivalent, blocking full automation.
 
 - **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 Sm2TimeMap opening 00000001… on a retimed clip and on generators — its KeyframesBA is the protobuf point form (NOT the keyed-dict form a 19.1.3.7 XMEML retime import writes) and decodes with the DRP library's decodeTimemap: the keyframe slope is the speed (0.79999 on all four retimed clips of a real reel = Premiere's 80 for the same cuts, srcOut = In + round(Duration × 0.8) matching Premiere's frame for frame), XMax 60000 with a zero slope is the freeze sentinel (a Black Video generator), a negative slope is a reverse (a reversed tail leader). On a retimed clip <In> is RECORD-domain (E143): the map spans the whole source stretched by 1/speed and the clip windows into that, so the first source frame shown is In × speed — two timelines of the same reel carried the same 80% map with In 52682 (bridge-authored: source 42145, Premiere's frame) and In 42145 (hand conform: source 33716, 8,429 frames early). 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.
+- **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 Sm2TimeMap opening 00000001… on a retimed clip and on generators — its KeyframesBA is the protobuf point form on that hand-conformed export, while every retime Resolve 19.1.3.7 MAKES itself (XMEML import, UI speed change, EDL M2 freeze, speed ramp) writes the KEYED-DICT form (E144: keyframes {interp,YOut,YIn,Y,XOut,XIn,X} under keys '0','1',…; keyframe 0 at X=0 is the origin and its Y the source second the map starts on — 4.0 on a real ramp); both decode with the DRP library's decodeTimemap: the keyframe slope is the speed (0.79999 on all four retimed clips of a real reel = Premiere's 80 for the same cuts, srcOut = In + round(Duration × 0.8) matching Premiere's frame for frame), XMax 60000 with a zero slope is the freeze sentinel — a FREEZE at the source second the flat map holds, even when <In> is present: an XMEML import of a 100% clip came back with that flat map at Y=0 and In 24, and its render is static at the source's frame 0 (E144, inter-frame change 0.02 vs 0.42 in the source) — Resolve's XMEML importer froze the clip silently; a negative slope is a reverse (a reversed tail leader). On a retimed clip <In> is RECORD-domain (E143): the map spans the whole source stretched by 1/speed and the clip windows into that, so the first source frame shown is In × speed — two timelines of the same reel carried the same 80% map with In 52682 (bridge-authored: source 42145, Premiere's frame) and In 42145 (hand conform: source 33716, 8,429 frames early). 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)); decode a keyed timemap to its speed (E140) and report a map the decoder cannot read as 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
 

package/install.py

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

@@ -296,6 +296,27 @@ export function eventsToAssembleSpec(events, opts = {}) {
       }
     }
   }
+  // NAMED GENERATORS (E145): a Premiere Universal Counting Leader / Black
+  // Video (E141 names them by their Media <Title>) or a DRT generator clip
+  // arrives as an event with generatorName and no file. Black authors as the
+  // BL leg it is (a Solid Color that renders black); anything else has no
+  // Resolve equivalent the bridge can place, so it is DROPPED with a reason
+  // in unresolvedGenerators — a hole the ledger names — instead of refusing
+  // the whole reel as an unmapped source (a real 228-cut reel refused over
+  // its counting leader).
+  const unresolvedGenerators = [];
+  const isBlackGenerator = (name) => /^(black|black video|black matte|slug)$/i.test(String(name || '').trim());
+  for (const list of [vids, auds]) {
+    for (let i = list.length - 1; i >= 0; i -= 1) {
+      const e = list[i];
+      if (sourceMap[e.source] || isBL(e.source)) continue;
+      const gen = e.generatorName || (isBlackGenerator(e.source) ? e.source : null);
+      if (!gen) continue;
+      if (isBlackGenerator(gen)) { list[i] = { ...e, source: 'BL', generatorName: gen }; continue; }
+      unresolvedGenerators.push({ name: gen, track: e.track, recIn: e.recIn, recOut: e.recOut, reason: 'a named generator with no media and no Resolve equivalent the bridge can author — map its name to a rendered file in sourceMap, or accept the hole' });
+      list.splice(i, 1);
+    }
+  }
   const unmapped = [...new Set([...vids, ...auds].map((e) => e.source).filter((srcName) => !isBL(srcName) && !sourceMap[srcName]))];
   if (unmapped.length) {
     throw new Error(
@@ -737,6 +758,7 @@ export function eventsToAssembleSpec(events, opts = {}) {
       flattenedCompounds: [...new Set(events.filter((e) => e.fromCompound).map((e) => e.fromCompound))],
       flattenedCompoundEvents: events.filter((e) => e.fromCompound).length,
       unresolvedCompounds,
+      unresolvedGenerators,
       authoredAudioEvents: audioPlacements.length,
       audioRetimesSkipped,
       audioLanesBeyondCeiling,

package/resolve-advanced/server/editorial.mjs

@@ -672,15 +672,29 @@ export function drtEventsFromParsed(parsed, opts = {}) {
         // Reverse: the map descends from the source tail, In measures from
         // the END — source start = sourceFrames − In×speed − duration×speed.
         let speed = 100, srcOut = srcIn + c.duration, unknown = false, srcStart = srcIn;
-        if (kind === 'freeze') { speed = 0; srcOut = srcIn; }
+        if (kind === 'freeze') {
+          // A real freeze holds the source second in its flat map (E144); the
+          // clip's <In> is empty. Zero-speed in==out event on that frame.
+          speed = 0; srcStart = tm && tm.freezeSec != null ? Math.round(tm.freezeSec * fps) : srcIn; srcOut = srcStart;
+
+        }
         else if (kind === 'constant' || kind === 'variable') {
+          // E143/E144: <In> is RECORD-domain — evaluate the map (piecewise
+          // linear in seconds, origin included) at In and In + duration; the
+          // source window is the min/max of the two, which also makes a
+          // reversed map (descending line) come out the right way round.
           speed = Math.round(tm.speed * 10000) / 100;
-          const span = Math.round(c.duration * tm.speed);
-          if (tm.reverse && tm.sourceDurationSec != null) {
-            const sourceFrames = Math.round(tm.sourceDurationSec * fps) + 1;
-            srcStart = Math.max(0, sourceFrames - Math.round(srcIn * tm.speed) - span);
-          } else srcStart = Math.round(srcIn * tm.speed);
-          srcOut = srcStart + span;
+          const pts = tm.points && tm.points.length >= 2 ? tm.points : null;
+          const mapAt = (recFrames) => {
+            const x = recFrames / fps;
+            if (!pts) return x * tm.speed * (tm.reverse ? -1 : 1);
+            let i = 1; while (i < pts.length - 1 && x > pts[i].recordSec) i++;
+            const a = pts[i - 1], b = pts[i];
+            const slope = b.recordSec === a.recordSec ? 0 : (b.sourceSec - a.sourceSec) / (b.recordSec - a.recordSec);
+            return a.sourceSec + (x - a.recordSec) * slope;
+          };
+          const s0 = Math.round(mapAt(srcIn) * fps), s1 = Math.round(mapAt(srcIn + c.duration) * fps);
+          srcStart = Math.max(0, Math.min(s0, s1)); srcOut = Math.max(s0, s1);
         }
         else if (kind === 'unknown') { speed = null; srcOut = null; unknown = true; }
         const ev = {
@@ -689,7 +703,7 @@ export function drtEventsFromParsed(parsed, opts = {}) {
           speed, reverse: Boolean(tm && tm.reverse), transition: null, fps,
         };
         if (media) ev.sourcePath = media;
-        if (srcStart !== srcIn) ev.recordDomainIn = srcIn;
+        if (srcStart !== srcIn && c.in != null) ev.recordDomainIn = srcIn;
         if (c.in == null) ev.srcInAbsent = true;
         if (unknown) ev.retimeUnknown = true;
         if (kind === 'variable') { ev.variableSpeed = true; ev.retimeSegments = tm.segments; }

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

@@ -86,6 +86,27 @@ function _decodeKeyframePoint(buf) {
  */
 function _decodeKeyframes(hex) {
   if (hex == null) return { origin: { recordSec: 0, sourceSec: 0 }, keyframes: [] };
+  // r19 KEYED-DICT form (E144): Resolve 19.1.3.7 itself writes KeyframesBA
+  // as a keyed dict of keyed-dict keyframes ({interp,YOut,YIn,Y,XOut,XIn,X}
+  // under keys '0','1',…) on every retime it makes (XMEML import, UI speed
+  // change, EDL M2 freeze) — the same shape buildConstantSpeedTimemapKeyed
+  // emits — while an EXPORT_DRT of a hand-conformed reel carried protobuf
+  // points. The reader used to throw on the keyed form ("unsupported wire
+  // type 7"), so a Resolve-made retime read as unknown. Keyframe 0 at X=0 is
+  // the origin (its Y = the source second the map starts on: 4.0 on a real
+  // ramp harvest); the rest are the points.
+  const kh = String(hex).replace(/[^0-9a-fA-F]/g, '');
+  if (kh.startsWith('00000001')) {
+    const pts = [];
+    for (const e of decodeKeyedDict(Buffer.from(kh, 'hex')).entries) {
+      const inner = decodeKeyedDict(Buffer.from(String(e.value), 'hex')).entries;
+      const get = (k) => { const f = inner.find((x) => x.key === k); return f ? Number(f.value) : 0; };
+      pts.push({ recordSec: get('X'), sourceSec: get('Y') });
+    }
+    pts.sort((a, b) => a.recordSec - b.recordSec);
+    const origin = pts.length && pts[0].recordSec === 0 ? pts.shift() : { recordSec: 0, sourceSec: 0 };
+    return { origin, keyframes: pts, keyed: true };
+  }
   const fields = decodeProtobuf(hex);
   const originField = fields.find((f) => f.field === 2 && f.wire === 1);
   const originSource = originField
@@ -120,7 +141,7 @@ function decodeTimemap(input) {
     const get = (k) => { const e = entries.find((x) => x.key === k); return e ? e.value : undefined; };
     const recordDurationSec = get('XMax');
     const sourceDurationSec = get('LastValidYOffset');
-    const { origin, keyframes } = _decodeKeyframes(get('KeyframesBA'));
+    const { origin, keyframes, keyed } = _decodeKeyframes(get('KeyframesBA'));
     const segments = _segments(keyframes, origin);
     // The EXACT speed lives in the keyframe ratios (source/record per segment); XMax and
     // LastValidYOffset are frame-quantized. `speed` is the first segment's (whole clip if 1 kf);
@@ -128,7 +149,7 @@ function decodeTimemap(input) {
     const speed = segments.length ? segments[0].speed : sourceDurationSec / recordDurationSec;
     const variable = segments.length > 1;
     return {
-      form: 'retimed', variable, speed, segments, keyframes,
+      form: 'retimed', variable, speed, segments, keyframes, origin, keyframeForm: keyed ? 'keyed' : 'protobuf',
       sourceDurationSec, recordDurationSec, entries,
     };
   }

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

@@ -79,8 +79,17 @@ function decodeTimemapField(hex) {
   }
   if (!d || d.form !== 'retimed') return { form: 'retimed', kind: 'unknown', speed: null, reverse: false };
   const slope = d.segments && d.segments.length ? d.segments[0].speed : null;
-  const base = { form: 'retimed', recordDurationSec: d.recordDurationSec ?? null, sourceDurationSec: d.sourceDurationSec ?? null };
-  if (d.recordDurationSec === FREEZE_XMAX_SENTINEL && slope === 0) return { ...base, kind: 'freeze', speed: 0, reverse: false };
+  const points = [d.origin || { recordSec: 0, sourceSec: 0 }, ...(d.keyframes || [])];
+  const base = { form: 'retimed', recordDurationSec: d.recordDurationSec ?? null, sourceDurationSec: d.sourceDurationSec ?? null, keyframeForm: d.keyframeForm || null, points };
+  if (d.recordDurationSec === FREEZE_XMAX_SENTINEL && slope === 0) {
+    // A flat map over the 60000 sentinel is a FREEZE at the source second the
+    // map holds (Y) — with or without an <In> (E144, render-witnessed: the
+    // E66 harvest carries Y = 0 and In 24, and its render is static at the
+    // source's frame 0: inter-frame change 0.02 vs 0.42 in the source). The
+    // EDL M2 000.0 harvest holds Y = 1.0 with an empty <In>.
+    const y = points[0] ? points[0].sourceSec : 0;
+    return { ...base, kind: 'freeze', speed: 0, reverse: false, freezeSec: y };
+  }
   if (!Number.isFinite(slope) || slope === 0 || Math.abs(slope) > 100) return { ...base, kind: 'unknown', speed: null, reverse: false };
   return {
     ...base,

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.195.0"
+VERSION = "2.197.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.195.0"
+VERSION = "2.197.0"
 
 import base64
 import os

package/src/utils/api_truth.py

@@ -2744,14 +2744,24 @@ API_TRUTH: List[Dict[str, Any]] = [
                    "0000000000003840…), and <MediaTimemapBA>: tag byte 0x02 + "
                    "one double (the media length in seconds) on a 100% clip, a "
                    "keyed Sm2TimeMap opening 00000001… on a retimed clip and on "
-                   "generators — its KeyframesBA is the protobuf point form "
-                   "(NOT the keyed-dict form a 19.1.3.7 XMEML retime import "
-                   "writes) and decodes with the DRP library's decodeTimemap: "
+                   "generators — its KeyframesBA is the protobuf point form on "
+                   "that hand-conformed export, while every retime Resolve "
+                   "19.1.3.7 MAKES itself (XMEML import, UI speed change, EDL "
+                   "M2 freeze, speed ramp) writes the KEYED-DICT form (E144: "
+                   "keyframes {interp,YOut,YIn,Y,XOut,XIn,X} under keys "
+                   "'0','1',…; keyframe 0 at X=0 is the origin and its Y the "
+                   "source second the map starts on — 4.0 on a real ramp); "
+                   "both decode with the DRP library's decodeTimemap: "
                    "the keyframe slope is the speed (0.79999 on all four "
                    "retimed clips of a real reel = Premiere's 80 for the same "
                    "cuts, srcOut = In + round(Duration × 0.8) matching "
                    "Premiere's frame for frame), XMax 60000 with a zero slope "
-                   "is the freeze sentinel (a Black Video generator), a "
+                   "is the freeze sentinel — a FREEZE at the source second the "
+                   "flat map holds, even when <In> is present: an XMEML import "
+                   "of a 100% clip came back with that flat map at Y=0 and In "
+                   "24, and its render is static at the source's frame 0 "
+                   "(E144, inter-frame change 0.02 vs 0.42 in the source) — "
+                   "Resolve's XMEML importer froze the clip silently; a "
                    "negative slope is a reverse (a reversed tail leader). On a "
                    "retimed clip <In> is RECORD-domain (E143): the map spans the "
                    "whole source stretched by 1/speed and the clip windows into "