davinci-resolve-mcp 2.138.0 → 2.140.0

package/CHANGELOG.md

@@ -2,6 +2,60 @@
 
 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.140.0 — the transition style registry
+
+### Added
+
+- **Five more transition styles authored offline** — `transitions[].type:
+  'dip' | 'additive' | 'fade-to-color' | 'smooth-cut' | 'non-additive'`
+  (joining `dissolve` and `wipe`). The registry cracked in one probe:
+  `PrettyType` is the style selector — swapped onto the render-verified
+  dissolve skeleton, every style renders, each with its own midpoint
+  fingerprint on 19.1.3.7 (dip bottoms at pure black 16, additive saturates
+  at 233.8, fade-to-color plateaus dark at 77, smooth-cut blends at 179.9,
+  non-additive holds the brighter side past the cut). Unknown styles refuse
+  (unvetted strings are the measured crasher class).
+- **XMEML `<transitionitem>` parsing** — dissolve-family effectids and wipe
+  names route to their styles automatically through
+  `assemble_from_interchange`; unrecognized effects fall back to a plain
+  dissolve rather than dropping (a blend at the right junction beats a hard
+  cut).
+
+### Measured and closed (new Resolve bug, filed in api-limitations)
+
+- **Resolve's own FCP7-XMEML importer writes video transitions that render
+  INERT** on 19.1.3: the transitionitem lands as a real element that reads
+  back through every API, but the outgoing clip plays through the window and
+  hard-cuts at its end — measured with both a plain Cross Dissolve and a Dip
+  to Color (E66, importSourceClips both ways). EDL-imported transitions
+  render fine; the defect is the XMEML path's element construction. Routing
+  the same XMEML through `assemble_from_interchange` authors transitions
+  that render (E69: the same dip turnover produced the exact 16.0 black
+  valley through our route). `docs/reference/api-limitations.md` carries the
+  new `bug` entry.
+
+## What's New in v2.139.0 — speed ramps, and the easing crash law
+
+### Added
+
+- **Variable-speed ramps authored offline** (`cuts[].ramp:
+  [{durationFrames, speed}, …]` — two or more linear segments from the cut
+  head, `srcIn` honored). No harvest was needed: the engine honors
+  intermediate keyframes in the same seconds-domain keyed `Sm2TimeMap` the
+  constant retimes use. E63/E64 proof on 19.1.3.7: a 50%→100% knee read back
+  the exact source window AND rendered the predicted frame cadence (11/23
+  doubled frames in the half-speed window, none at full speed; the 2×
+  segment moved at 4.3× the 0.5× segment's per-frame motion), with `srcIn`
+  landing on the right source frame by luma.
+
+### Measured and closed
+
+- **Eased ramps are a crasher, not a boundary.** A keyframe with
+  `interp = 2` crashed Resolve outright on import (E65 — app death, headless
+  recovery per doctrine). The builders hardcode `interp = 0`, the test suite
+  asserts it, and the guide records the law: linear segments are the
+  authorable envelope on 19.1.3.
+
 ## What's New in v2.138.0 — wipes join the conform
 
 ### Added

package/README.md

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

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

@@ -43,10 +43,12 @@ window. `render.verify_output` covers the container-level checks.
 | Multi-track video (V2+ stacking) | `cuts[].track` (video-only above V1) | v2.112 |
 | Cross-dissolves | `transitions: [{track, atFrame, durationFrames}]` | v2.111 |
 | Wipes (EDL `W`-codes) | `transitions[].type: 'wipe'` (single soft-edge style — host-importer parity) | v2.138 |
+| Transition styles | `transitions[].type: 'dip' \| 'additive' \| 'fade-to-color' \| 'smooth-cut' \| 'non-additive'` (XMEML effectids route automatically) | v2.140 |
 | Audio cross-fades | `transitions[].trackType: 'audio'` | v2.116 |
 | Constant retimes, forward | `cuts[].speed` (e.g. `0.5`) | v2.113 |
 | Constant retimes, reverse | `cuts[].reverse` | v2.114 |
 | Freeze frames | `cuts[].freeze` (holds source frame `srcIn`) | v2.134 |
+| Speed ramps | `cuts[].ramp: [{durationFrames, speed}, …]` (linear segments only) | v2.139 |
 | Audio placements, A1–A8 | `cuts[].audioOnly + track` | v2.115 |
 | Built-in generators | `elements: [{type:'generator', generatorName}]` | v2.110 |
 | Custom start timecode | `spec.startFrame` / `preserveStartTimecode` | v2.117 |
@@ -96,6 +98,14 @@ the clip's `<In>`/`<Duration>` window into it in record-domain frames.
 Reverse is the same map with the Y endpoints swapped, and `In` then measures
 from the source end.
 
+**Ramps are just more keyframes — but easing is a crasher.** The engine
+honors intermediate keyframes in the same seconds-domain map (E63/E64:
+a synthesized 50%→100% knee read back AND rendered with the exact predicted
+frame cadence, srcIn baked into the first keyframe's Y, clip `In` at the cut
+head). `cuts[].ramp` authors piecewise-constant segments. The keyframes'
+`interp` field must stay **0**: an `interp=2` keyframe crashed Resolve
+19.1.3 outright on import (app death, E65) — eased ramps are not authorable.
+
 **Freezes are a third shape, not a flat retime.** A flat line in the retime's
 frame domain reads back frozen but *renders moving* — the one divergence that
 runs in the "working" direction. The real freeze (harvested from a live EDL
@@ -109,6 +119,18 @@ and zero-speed warps route to it through `assemble_from_interchange`.
 (01:00:00:00 @ 24fps). Clips placed before the origin are silently dropped
 by Resolve on import — `startFrame` is timeline-absolute.
 
+**Transition styles live in PrettyType — and the host XMEML importer is
+inert.** Swapping `PrettyType` on the working dissolve skeleton renders the
+named style (midpoint fingerprints: dip bottoms at pure black 16, additive
+saturates at 233.8, fade-to-color plateaus dark at 77, smooth-cut blends at
+179.9, non-additive holds the brighter side). Within `Cross Dissolve`, the
+FieldsBlob style-id distinguishes dissolve from wipe. Resolve's OWN FCP7-XMEML
+importer writes video `<transitionitem>`s that read back but render INERT on
+19.1.3 (measured: both a plain Cross Dissolve and a Dip to Color played the
+outgoing clip through the window) — so routing an XMEML turnover through
+`assemble_from_interchange` produces transitions that render where the host
+importer's do not.
+
 **Dissolve geometry.** A transition is authored only when the predecessor
 ends exactly at the cut and both sides have handle media for the centered
 span (incoming `srcIn ≥ dur/2`; outgoing `srcIn + dur + dur/2 ≤ frameCount`).

package/docs/reference/api-limitations.md

@@ -12,7 +12,7 @@ that none exists).
 
 **Verified on:** DaVinci Resolve Studio 21.0.2
 
-**Totals:** 35 missing capabilities, 45 bugs / unreliable behaviors.
+**Totals:** 35 missing capabilities, 46 bugs / unreliable behaviors.
 
 The authoritative source is the runtime-queryable `api_truth` ledger
 (`resolve_control api_truth "<query>"`); this document is generated from
@@ -663,3 +663,11 @@ values, or automation-hostile modal prompts.
 - **Behavior:** Deleting or closing a project while its render job is still running orphans the render and wedges the whole render pipeline: the output file stops growing and Resolve idles at 0% CPU, IsRenderingInProgress on the NEXT current project reports True indefinitely, StopRendering does not clear it, NEW render jobs sit at 0% forever (then StartRendering starts returning False), and Resolve.Quit() is refused because the app believes a render is running — even project creation can start returning None behind the quit-confirm dialog (reproduced live on Studio 19.1.3.7, 2026-08-29).
 - **Workaround / current handling:** Never close or delete a project while IsRenderingInProgress is True — StopRendering first, wait for False, then close. Once wedged, only a manual quit (confirming the dialog) or force-quit clears it; treat a True that persists at 0% CPU with a static output file as stuck rather than rendering. Poll GetRenderJobStatus for completion instead of IsRenderingInProgress, which this failure poisons.
 - **Tags:** render, silent-failure, unreliable-return
+
+### MediaPool.ImportTimelineFromFile (FCP7 XMEML video transitions render inert)
+
+- **Object:** `MediaPool`
+- **Signature:** `(filePath, {importOptions}) -> Timeline`
+- **Behavior:** Video <transitionitem>s imported from an FCP7 XMEML land as real Sm2TiTransition elements that READ BACK through the item APIs but render INERT: the outgoing clip plays through the transition window and hard-cuts at its end. Measured on Studio 19.1.3.7 with both a plain Cross Dissolve and a Dip to Color Dissolve (midpoint frames byte-matched the outgoing clip; no blend, no dip). The same transition elements authored offline with a correct FieldsBlob render perfectly, and EDL-imported dissolves/wipes also render — the defect is specific to the XMEML import path's element construction.
+- **Workaround / current handling:** Do not trust an XMEML-imported timeline's transitions without a render probe at a junction midpoint. To conform an XMEML turnover with working transitions, route it through drt.assemble_from_interchange (format 'xml'), which authors render-verified dissolves, wipes, and the dissolve-family styles from the same <transitionitem> data.
+- **Tags:** timeline, import, xmeml, transition, readback, silent-failure

package/install.py

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

@@ -425,12 +425,20 @@ export function eventsToAssembleSpec(events, opts = {}) {
       });
       continue;
     }
-    // EDL W-codes author as a WIPE (Resolve's own EDL importer maps every
-    // W-code to its single soft-edge wipe style — W001/W002/W005 measured
-    // identical — so one style is host-importer parity; render-verified
-    // spatial split at the midpoint). Everything else is a dissolve.
-    const kind = /^W/i.test(String(c.type || '')) ? 'wipe' : 'dissolve';
-    transitions.push({ track: c.track, atFrame: c.atFrame, durationFrames: c.durationFrames, ...(kind === 'wipe' ? { type: 'wipe' } : {}) });
+    // Style mapping (all render-verified E61/E67/E68, midpoint-fingerprinted):
+    // EDL W-codes and XMEML wipe effectids → the single wipe style Resolve's
+    // own EDL importer maps every W-code to; XMEML dissolve-family effectids
+    // → their PrettyType styles; anything unrecognized → plain dissolve
+    // (never dropped — a blend at the right junction beats a hard cut).
+    const raw = String(c.type || '');
+    let kind = 'dissolve';
+    if (/^W\d*/i.test(raw) || /wipe/i.test(raw)) kind = 'wipe';
+    else if (/dip to color/i.test(raw)) kind = 'dip';
+    else if (/non-additive/i.test(raw)) kind = 'non-additive';
+    else if (/additive/i.test(raw)) kind = 'additive';
+    else if (/fade to color/i.test(raw)) kind = 'fade-to-color';
+    else if (/smooth cut/i.test(raw)) kind = 'smooth-cut';
+    transitions.push({ track: c.track, atFrame: c.atFrame, durationFrames: c.durationFrames, ...(kind === 'dissolve' ? {} : { type: kind }) });
   }
   // Audio cross-fades, same geometry rules (render-verified on 19.1.3.7 via
   // the harvested cross-fade template: the highpass RMS ramps, not steps).

package/resolve-advanced/server/editorial.mjs

@@ -240,7 +240,26 @@ 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]) : [];
-    vtracks.forEach((t, vi) => { if (t.clipitem) walk(t.clipitem, vi === 0 ? 'V' : `V${vi + 1}`); });
+    vtracks.forEach((t, vi) => {
+      const label = vi === 0 ? 'V' : `V${vi + 1}`;
+      const before = events.length;
+      if (t.clipitem) walk(t.clipitem, label);
+      // <transitionitem> siblings: attach each to the INCOMING clip event —
+      // the one whose record-in falls inside the transition's span. Resolve's
+      // OWN XMEML importer writes these as elements that render INERT on
+      // 19.1.3 (measured E66: dip AND plain cross dissolve both played the
+      // outgoing clip through the window, hard cut at the end), so routing
+      // the turnover through assemble_from_interchange authors transitions
+      // that actually render where the host importer's do not.
+      const titems = t.transitionitem ? (Array.isArray(t.transitionitem) ? t.transitionitem : [t.transitionitem]) : [];
+      for (const tr of titems) {
+        const s = Number(tr.start), e2 = Number(tr.end);
+        if (!Number.isFinite(s) || !Number.isFinite(e2)) continue;
+        const effectId = (tr.effect && (tr.effect.effectid || tr.effect.name)) || 'Cross Dissolve';
+        const incoming = events.slice(before).find((ev) => ev.track === label && ev.recIn > s - 1 && ev.recIn <= e2);
+        if (incoming) incoming.transition = { type: String(effectId), duration: e2 - s };
+      }
+    });
     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');
   }

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

@@ -51,7 +51,7 @@ const assembleSchema = z.object({
   spec: z
     .object({})
     .passthrough()
-    .describe("assembleTimeline spec: { timelineName?, startFrame? (timeline start frame @24, default 86400=01:00:00:00 — sets the start TIMECODE, render-verified on 19), media?: {mediaFilePath, spec:{width,height,frameCount,fps}, cuts:[{startFrame,durationFrames,srcIn?,track? (1-based video track; >1 = video-only, render-verified stacking),speed?/reverse? (constant retime, e.g. 0.5, forward or backwards; video-only; readback+render-verified on 19),freeze? (true = hold source frame srcIn for the whole cut; video-only; render-proven frozen on 19 via freezedetect),audioOnly?+track? (explicit AUDIO placement on audio track 1-8; presence suppresses the A1 mirror; render-verified on 19)}]} | [same, ...] (multi-source needs media_pool.capture_media_template run once per file), transitions?: [{track, atFrame, durationFrames?, trackType? ('video' | 'audio' cross-fade), type? ('dissolve' default | 'wipe' — the single soft-edge wipe style Resolve's own EDL importer maps every W-code to; all render-verified on 19)}], markers?: [{frame (timeline-absolute), color? (16 names), name?, note?, duration?, customData?}] (readback-verified on 19), compounds?: [{name, startFrame (parent, absolute), durationFrames, track?, cuts:[{mediaFilePath, startFrame (INNER, 0-based), durationFrames, srcIn?}], compounds?: [same, nested — frames inner-relative]}] (multiple PARALLEL compounds compose AND compounds NEST recursively — depth-2 AND depth-3 playback render-verified on 19 (the old depth-2 black was a missing SequenceSetup key, fixed); inner cuts need captured templates w/ native clips), subtitles?: [{startFrame (timeline-absolute), durationFrames, text}] + subtitlesSrt? (raw SRT, cues anchor at the origin; readback-verified on 19; angle-bracket runs read as SRT markup), elements?: [{type:'title'|'generator', track, startFrame, durationFrames?, text?, generatorName? ('Solid Color'|'SMPTE Color Bar'|'Grey Scale' render-verified on 19), ...}] }. startFrame is timeline-absolute (origin 86400)."),
+    .describe("assembleTimeline spec: { timelineName?, startFrame? (timeline start frame @24, default 86400=01:00:00:00 — sets the start TIMECODE, render-verified on 19), media?: {mediaFilePath, spec:{width,height,frameCount,fps}, cuts:[{startFrame,durationFrames,srcIn?,track? (1-based video track; >1 = video-only, render-verified stacking),speed?/reverse? (constant retime, e.g. 0.5, forward or backwards; video-only; readback+render-verified on 19),freeze? (true = hold source frame srcIn for the whole cut; video-only; render-proven frozen on 19 via freezedetect),ramp? ([{durationFrames,speed},...] >=2 LINEAR segments from the cut head, srcIn honored; video-only; render-proven cadence on 19 — eased/curved ramps are NOT authorable, an interp!=0 keyframe crashes Resolve on import (measured)),audioOnly?+track? (explicit AUDIO placement on audio track 1-8; presence suppresses the A1 mirror; render-verified on 19)}]} | [same, ...] (multi-source needs media_pool.capture_media_template run once per file), transitions?: [{track, atFrame, durationFrames?, trackType? ('video' | 'audio' cross-fade), type? ('dissolve' default | 'wipe' | 'dip' | 'additive' | 'fade-to-color' | 'smooth-cut' | 'non-additive' — all render-verified on 19 w/ midpoint fingerprints; XMEML/EDL transition codes route automatically, and NOTE Resolve's own XMEML importer writes transitions that render INERT, so this route beats it)}], markers?: [{frame (timeline-absolute), color? (16 names), name?, note?, duration?, customData?}] (readback-verified on 19), compounds?: [{name, startFrame (parent, absolute), durationFrames, track?, cuts:[{mediaFilePath, startFrame (INNER, 0-based), durationFrames, srcIn?}], compounds?: [same, nested — frames inner-relative]}] (multiple PARALLEL compounds compose AND compounds NEST recursively — depth-2 AND depth-3 playback render-verified on 19 (the old depth-2 black was a missing SequenceSetup key, fixed); inner cuts need captured templates w/ native clips), subtitles?: [{startFrame (timeline-absolute), durationFrames, text}] + subtitlesSrt? (raw SRT, cues anchor at the origin; readback-verified on 19; angle-bracket runs read as SRT markup), elements?: [{type:'title'|'generator', track, startFrame, durationFrames?, text?, generatorName? ('Solid Color'|'SMPTE Color Bar'|'Grey Scale' render-verified on 19), ...}] }. 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,7 +25,7 @@ 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, buildFreezeTimemapKeyed } = require('./media-timemap');
+const { buildConstantSpeedTimemapKeyed, buildFreezeTimemapKeyed, buildRampTimemapKeyed } = require('./media-timemap');
 const { encodeTimelineMarkersBlob } = require('./timeline-markers-blob');
 const { placeSubtitles, parseSrt } = require('./place-subtitles');
 const { placeCompound } = require('./place-compound');
@@ -78,7 +78,9 @@ async function assembleTimeline(spec = {}) {
           // srcIn/duration are TIMELINE frames (24fps template); the media's
           // extent converts: frameCount / mediaFps × 24.
           const maxTimelineFrames = Math.floor((mediaSpec.frameCount / mediaSpec.fps) * 24);
-          if ((cut.srcIn ?? 0) + cut.durationFrames > maxTimelineFrames) {
+          // Ramps consume sum(duration × speed) source, not durationFrames —
+          // the ramp builder enforces its own source-extent bound.
+          if (!Array.isArray(cut.ramp) && (cut.srcIn ?? 0) + cut.durationFrames > maxTimelineFrames) {
             throw new RangeError(
               `assembleTimeline: ${label}.cuts[${i}] reads past the media's end — (srcIn ?? 0) + durationFrames exceeds ${maxTimelineFrames} timeline frames (media ${mediaSpec.frameCount} frames @ ${mediaSpec.fps} fps on the 24fps template timeline)`,
             );
@@ -137,7 +139,26 @@ async function assembleTimeline(spec = {}) {
         // 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.freeze || cut.speed === 0) {
+        if (Array.isArray(cut.ramp)) {
+          // VARIABLE-SPEED RAMP (E63, render-verified): piecewise-constant
+          // segments as one multi-keyframe Sm2TimeMap. Record domain starts
+          // at the cut head (In stays 0); srcIn bakes into the map's first
+          // keyframe. Video-only, like every retime.
+          if (cut.freeze || cut.reverse || (cut.speed !== undefined && cut.speed !== 1)) {
+            throw new RangeError('assembleTimeline: cut.ramp cannot combine with speed/reverse/freeze');
+          }
+          const fpsR = Math.round(src.spec.fps || 24);
+          const total = cut.ramp.reduce((s, seg) => s + (seg && seg.durationFrames || 0), 0);
+          if (total !== cut.durationFrames) {
+            throw new RangeError(`assembleTimeline: ramp segments sum to ${total} frames but the cut is ${cut.durationFrames}`);
+          }
+          out.timemap = buildRampTimemapKeyed({
+            segments: cut.ramp, srcIn: cut.srcIn ?? 0,
+            sourceFrames: src.spec.frameCount, fps: fpsR, uniqueId: randomUUID(),
+          }).toString('hex');
+          out.srcIn = 0; // record-domain In is the cut head; the map carries srcIn
+          delete out.ramp;
+        } else if (cut.freeze || cut.speed === 0) {
           // FREEZE frame (r19 keyed map harvested from a live EDL M2 000.0
           // import, E55; render-proven frozen). Holds source frame srcIn for
           // the whole cut. The frozen clip's <In> stays EMPTY; the position

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

@@ -304,10 +304,62 @@ function buildFreezeTimemapKeyed({ freezeFrame, sourceFrames, fps = 24, uniqueId
   ] });
 }
 
+/**
+ * VARIABLE-SPEED RAMP — piecewise-constant speed segments as a multi-keyframe
+ * r19 keyed Sm2TimeMap. E63 (2026-08-31): the engine honors intermediate
+ * keyframes with the SAME seconds-domain conventions as the constant maps —
+ * a synthesized 3-keyframe 50%→100% ramp read back source 0..36 over 48
+ * record frames AND rendered with exactly the predicted cadence (11/23
+ * doubled frames in the 50% window, 0/24 at 100%). Record domain starts at
+ * the cut head (clip In stays 0); srcIn bakes into the first keyframe's Y.
+ *
+ * @param {Array<{durationFrames:number, speed:number}>} segments - record-domain
+ *   pieces, in order from the cut head; speeds are source/record multipliers.
+ */
+function buildRampTimemapKeyed({ segments, srcIn = 0, sourceFrames, fps = 24, uniqueId }) {
+  if (!Array.isArray(segments) || segments.length < 2) throw new TypeError('buildRampTimemapKeyed: segments must be an array of >= 2 {durationFrames, speed} pieces (use speed/freeze for a single one)');
+  if (!Number.isInteger(sourceFrames) || sourceFrames < 1) throw new TypeError('buildRampTimemapKeyed: sourceFrames must be a positive integer');
+  if (!Number.isInteger(srcIn) || srcIn < 0) throw new TypeError('buildRampTimemapKeyed: srcIn must be a non-negative integer');
+  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');
+  let x = 0;
+  let y = srcIn / fps;
+  const points = [[x, y]];
+  for (const [i, seg] of segments.entries()) {
+    if (!Number.isInteger(seg.durationFrames) || seg.durationFrames < 1) throw new TypeError(`buildRampTimemapKeyed: segments[${i}].durationFrames must be a positive integer`);
+    if (!(seg.speed > 0)) throw new RangeError(`buildRampTimemapKeyed: segments[${i}].speed must be > 0 (freeze/reverse segments are not authorable in a ramp)`);
+    x += seg.durationFrames / fps;
+    y += (seg.durationFrames * seg.speed) / fps;
+    points.push([x, y]);
+  }
+  const sourceEnd = y * fps;
+  if (sourceEnd > sourceFrames) {
+    throw new RangeError(`buildRampTimemapKeyed: ramp consumes source frame ${Math.ceil(sourceEnd)} but the media has ${sourceFrames}`);
+  }
+  const entries = points.map(([X, Y], i) => ({ key: String(i), type: T_BYTES, subType: 0, value: kf(X, Y) })).reverse();
+  const keyframes = encodeKeyedDict({ hdr: 1, entries }).toString('hex');
+  const [XMax, YMax] = points[points.length - 1];
+  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: (sourceFrames - 1) / fps },
+    { 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, buildConstantSpeedTimemapKeyed,
-  buildFreezeTimemapKeyed,
+  buildFreezeTimemapKeyed, buildRampTimemapKeyed,
   buildTimemap, decodeProtobuf,
   TYPE_LINEAR,
 };

package/resolve-advanced/vendor/drp-format/place-transition.js

@@ -66,10 +66,28 @@ const clipDuration = (c) => { const m = c.match(/<Duration>(\d+)<\/Duration>/);
 // wipe style, so one style is full parity with the host importer.
 const WIPE_FIELDS_BLOB = '00000002000000158012120000002c789c636660642016000000da0005';
 
+// PrettyType is the STYLE SELECTOR (measured E67/E68): swapping it on the
+// working dissolve skeleton renders the named style, midpoint-fingerprinted
+// on 19.1.3.7 — dip bottoms at pure black (16), additive saturates bright
+// (233.8), fade-to-color holds a dark plateau (77), smooth-cut blends
+// (179.9), non-additive holds the brighter side (234 past mid). Meanwhile
+// Resolve's OWN XMEML importer writes these same elements in a form that
+// renders INERT — so authoring through this path beats the host importer.
+// Unknown PrettyTypes are refused, not probed: unvetted strings are exactly
+// the class that crashed the app elsewhere (interp!=0, dangling ids).
+const STYLE_PRETTY_TYPES = {
+  dip: 'Dip To Color Dissolve',
+  additive: 'Additive Dissolve',
+  'fade-to-color': 'Fade To Color',
+  'smooth-cut': 'Smooth Cut',
+  'non-additive': 'Non-Additive Dissolve',
+};
+const TRANSITION_TYPES = ['dissolve', 'wipe', ...Object.keys(STYLE_PRETTY_TYPES)];
+
 async function placeTransition(drpInput, opts = {}) {
   const { track, atFrame, durationFrames = 24, trackType = 'video', type = 'dissolve', timelineUuid } = opts;
-  if (type !== 'dissolve' && type !== 'wipe') throw new Error("placeTransition: type must be 'dissolve' or 'wipe'");
-  if (type === 'wipe' && trackType === 'audio') throw new Error('placeTransition: wipes are video-only (audio junctions cross-fade)');
+  if (!TRANSITION_TYPES.includes(type)) throw new Error(`placeTransition: type must be one of ${TRANSITION_TYPES.join(', ')}`);
+  if (type !== 'dissolve' && trackType === 'audio') throw new Error('placeTransition: styled transitions are video-only (audio junctions cross-fade)');
   if (!Number.isInteger(track) || track < 1) throw new TypeError('placeTransition: track must be a positive integer');
   if (!Number.isInteger(atFrame)) throw new TypeError('placeTransition: atFrame must be an integer');
   if (!Number.isInteger(durationFrames) || durationFrames < 2) throw new TypeError('placeTransition: durationFrames must be an integer >= 2');
@@ -93,6 +111,8 @@ async function placeTransition(drpInput, opts = {}) {
   trans = freshDbIds(trans);
   if (type === 'wipe') {
     trans = trans.replace(/<FieldsBlob>[0-9a-fA-F]*<\/FieldsBlob>/, `<FieldsBlob>${WIPE_FIELDS_BLOB}</FieldsBlob>`);
+  } else if (STYLE_PRETTY_TYPES[type]) {
+    trans = trans.replace(/<PrettyType>Cross Dissolve<\/PrettyType>/, `<PrettyType>${STYLE_PRETTY_TYPES[type]}</PrettyType>`);
   }
   const start = atFrame - Math.floor(durationFrames / 2); // centered (AlignmentType 2)
   trans = trans.replace(/<Start>\d+<\/Start>/, `<Start>${start}</Start>`);

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.138.0"
+VERSION = "2.140.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.138.0"
+VERSION = "2.140.0"
 
 import base64
 import os

package/src/utils/api_truth.py

@@ -2668,6 +2668,32 @@ API_TRUTH: List[Dict[str, Any]] = [
         "submit": "missing",
         "mitigation": ["_cdl_node_preflight", "_cdl_failure_diagnosis"],
     },
+    {
+        "symbol": "MediaPool.ImportTimelineFromFile (FCP7 XMEML video transitions render inert)",
+        "object": "MediaPool",
+        "signature": "(filePath, {importOptions}) -> Timeline",
+        "reality": "Video <transitionitem>s imported from an FCP7 XMEML land as "
+                   "real Sm2TiTransition elements that READ BACK through the "
+                   "item APIs but render INERT: the outgoing clip plays through "
+                   "the transition window and hard-cuts at its end. Measured on "
+                   "Studio 19.1.3.7 with both a plain Cross Dissolve and a Dip "
+                   "to Color Dissolve (midpoint frames byte-matched the "
+                   "outgoing clip; no blend, no dip). The same transition "
+                   "elements authored offline with a correct FieldsBlob render "
+                   "perfectly, and EDL-imported dissolves/wipes also render — "
+                   "the defect is specific to the XMEML import path's element "
+                   "construction.",
+        "recommended": "Do not trust an XMEML-imported timeline's transitions "
+                       "without a render probe at a junction midpoint. To "
+                       "conform an XMEML turnover with working transitions, "
+                       "route it through drt.assemble_from_interchange "
+                       "(format 'xml'), which authors render-verified "
+                       "dissolves, wipes, and the dissolve-family styles from "
+                       "the same <transitionitem> data.",
+        "tags": ["timeline", "import", "xmeml", "transition", "readback", "silent-failure"],
+        "submit": "bug",
+        "mitigation": ["drt.assemble_from_interchange"],
+    },
 ]