davinci-resolve-mcp 2.167.0 → 2.169.0

package/CHANGELOG.md

@@ -2,6 +2,65 @@
 
 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.169.0 — E112: round-trip QC is colour-aware
+
+`verify_roundtrip` merged every generator leg out of the compare as "black",
+so a fade-to-white that came back black — or a colour matte that lost its
+colour — passed QC on geometry alone.
+
+### Added
+
+- **`verify_roundtrip` compares generator colours.** An input leg carrying a
+  fill colour must come back on the same track over its span with the same
+  colour (±1/255), else `generator-colour` fails; `generatorColours` reports
+  the compare. Black-only turnovers compare nothing and stay silent.
+
+### Fixed
+
+- **Resolve's own re-export of an authored colour reads back.** The FCP7
+  writer emits a Solid Color's colour as the FxPlug parameter `input_1`
+  (not Premiere's `fillcolor`); the walker now reads any RGB-valued
+  generator parameter. Live loop closed on 19.1.3.7: the E110 fade-to-white
+  turnover conformed, imported, rendered, re-exported, and verified
+  `pass: true` with both colours (white, and 128/64/191) compared — the
+  writer echoing the authored `EffectFiltersBA` is a second witness to the
+  blob layout. A black-for-white export fails as `generator-colour`.
+
+### Measured (filed in api-limitations)
+
+- The XML importer ignores a `Dip to Color Dissolve`'s colour parameter:
+  white and red imported as byte-identical default blobs and rendered inert.
+  The dip colour stays GUI-only on 19.1.3.7 (E111).
+
+## What's New in v2.168.0 — E110: Solid Color has a colour — fade-to-white and colour mattes author
+
+The one thing the black-leg machinery could not do was be anything but
+black: the Solid Color generator's colour lives in an `EffectFiltersBA` blob
+nobody had ground truth for, and Resolve 19 exposes the colour only in its
+UI. Resolve's own FCP7 XML importer turned out to be the capture route.
+
+### Added
+
+- **`drt.assemble` generator elements take `color`** (`{r,g,b[,a]}` as 0..1
+  floats or 0..255 ints): `placeGenerator` authors the 55-byte
+  `EffectFiltersBA` byte-for-byte as Resolve's writer emits it (header, fixed
+  prefix, flag, big-endian uint16 ARGB, pad, a second black record).
+  `solidColorEffectBlob` / `decodeSolidColorEffectBlob` are exported.
+- **XMEML generatoritem `fillcolor` carries through** `parse_interchange`
+  (Premiere Color Matte and Resolve's own export alike) as `color` on the BL
+  leg, and the bridge authors the coloured generator — so a turnover's
+  fade-to-white or colour matte conforms instead of turning black.
+
+### Measured (filed in api-limitations)
+
+- Resolve's FCP7 importer honours `fillcolor`: red and blue generators
+  rendered Y81 U90 V240 and Y41 U240 V110 (BT.601 limited-range exact) and
+  `EXPORT_FCP_7_XML` writes the colour back. Render-verified end to end from
+  an offline-authored `.drt`: a clip → white fade climbs 124 → 154 → 182 →
+  209 → 232 → 234 across its 24-frame window, the white plateau reads
+  234/128/128, and a custom (128, 64, 191) matte lands at Y100 U174 V147
+  against a BT.601 expectation of 99.8 / 174.3 / 147.0.
+
 ## What's New in v2.167.0 — E109: flat AAF sound slots keep their lanes; AAF audio cross-fades render
 
 An Avid turnover carries dialog, music and effects as SEPARATE flat sound

package/README.md

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

package/docs/reference/api-limitations.md

@@ -12,7 +12,7 @@ that none exists).
 
 **Verified on:** DaVinci Resolve Studio 21.0.2
 
-**Totals:** 38 missing capabilities, 50 bugs / unreliable behaviors.
+**Totals:** 39 missing capabilities, 50 bugs / unreliable behaviors.
 
 The authoritative source is the runtime-queryable `api_truth` ledger
 (`resolve_control api_truth "<query>"`); this document is generated from
@@ -309,6 +309,14 @@ equivalent, blocking full automation.
 - **Workaround / current handling:** For round-trip QC prefer EXPORT_OTIO (carries audio, retimes as LinearTimeWarp/FreezeFrame, exact spans). When an EDL is the required deliverable, expect no audio (editorial.verify_roundtrip reports audioNotInExport) and resolve AX reels through the clip-name comments (parseEDL does). Use EXPORT_EDL — there is no EXPORT_CMX_3600 constant, and an unknown name reaches Export as a string that returns a bare False (timeline.export_timeline_checked now refuses it loudly).
 - **Tags:** timeline, export, edl, audio, silent-failure
 
+### ImportTimelineFromFile FCP7 XML generatoritem fillcolor (honoured; EXPORT_DRT blob layout)
+
+- **Object:** `MediaPool`
+- **Signature:** `(filePath.xml) -> Timeline`
+- **Behavior:** Resolve's FCP7 XML importer HONOURS a generatoritem's `fillcolor` parameter (measured on Studio 19.1.3.7, E110): a Premiere-shaped Color Matte (effectid Color, category Matte) and a Solid Color generatoritem, both with <red>/<green>/<blue>/<alpha> 0..255 values, imported as Solid Color items and rendered Y81 U90 V240 (red) and Y41 U240 V110 (blue) — exact BT.601 limited-range values for a 640x360 timeline. EXPORT_FCP_7_XML writes the fillcolor back (same 0..255 channels). EXPORT_DRT carries the colour as a 55-byte <EffectFiltersBA> on the Sm2TiGenerator: 8-byte header (version 2, length 47), a fixed 20-byte prefix, a flag byte, then big-endian uint16 A R G B (0xffff = full) plus a pad word, then a second, black colour record; only the ARGB words differed between the red and blue captures. The default generator has an EMPTY EffectFiltersBA. The same importer does NOT carry a TRANSITION's parameters: a `Dip to Color Dissolve` transitionitem with a white and with a red `color` parameter imported as `Dip To Color Dissolve` elements whose 37-byte EffectFiltersBA were byte-identical (defaults), and the transition rendered inert (luma flat through its window, the E66 law) — the dip colour stays GUI-only on 19.1.3.7 (measured, E111). The writer emits a Solid Color's colour as the FxPlug parameter `input_1` (effectid FxPlugWrapper:C18E8B62_…), not `fillcolor` — an authored EffectFiltersBA colour came back exactly (white, 128/64/191; E112).
+- **Workaround / current handling:** Author fade-to-white / colour mattes by placing a Solid Color generator with that blob (drp-format placeGenerator `color`, drt.assemble elements[].color) — or carry an XMEML generatoritem fillcolor through editorial.parse_interchange; the bridge authors the coloured leg.
+- **Tags:** xml, import, generator, colour, export, drt
+
 ### ProjectManager.CreateProject (discards an unsaved current project)
 
 - **Object:** `ProjectManager`

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.167.0"
+VERSION = "2.169.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.167.0",
+  "version": "2.169.0",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/resolve-advanced/README.md

@@ -99,7 +99,8 @@ Each dispatches on an `action`. Highlights:
   (fps/codec/colorspace/TC + card gaps), `sync` (TC picture↔sound + drift/MOS), `relink_manifest`,
   `rename_plan` (refuses camera originals) / `reel_normalize`, `turnover_package`, `project_hygiene`.
 - **`editorial`** — editorial integrity: `parse_interchange` (EDL/OTIO/XMEML natively — XMEML audio
-  cross-fades and numbered audio lanes included — AAF via pyaaf2,
+  cross-fades, numbered audio lanes and generatoritem `fillcolor` (fade-to-white / colour
+  mattes) included — AAF via pyaaf2,
   **.prproj via gunzip+XML** — pass the file PATH for the binary ones), `list_sequences` (one picker entry
   point across xml/edl/otio/drt/drp/aaf/prproj), `convert_to_interchange` (author OTIO/EDL/DRT that Resolve
   imports, from events or a parsed source — **the .prproj→Resolve conform bridge**, no Premiere needed;

package/resolve-advanced/server/author-interchange.mjs

@@ -324,6 +324,9 @@ export function eventsToAssembleSpec(events, opts = {}) {
       // only authorable shape.
       if (durationFrames < 0) continue;
       const el = { type: 'generator', generatorName: 'Solid Color', track: vTrackEarly, startFrame: recIn, durationFrames, srcIn: 0 };
+      // A coloured leg (XMEML fillcolor — fade-to-white, a colour matte) keeps
+      // its colour: the generator's EffectFiltersBA is authored from it (E110).
+      if (e.color && typeof e.color === 'object') el.color = { r: e.color.r, g: e.color.g, b: e.color.b, ...(e.color.a != null ? { a: e.color.a } : {}) };
       blackLegs.push(el);
       if (e.transition) {
         let d = Math.max(2, toTl(e.transition.duration || 0, e.fps) || 2);
@@ -902,7 +905,7 @@ export function verifyRoundtrip(inputEvents, exportedEvents, opts = {}) {
     if (!v.length) return [];
     const off = anchorOfSide(evts);
     return v
-      .map((e) => ({ track: canonTrack(e.track), source: mapSource(canonSource(e.source)), recIn: e.recIn - off, recOut: e.recOut - off, srcIn: e.srcIn ?? 0, speed: e.speed ?? 100, reverse: Boolean(e.reverse) }))
+      .map((e) => ({ track: canonTrack(e.track), source: mapSource(canonSource(e.source)), recIn: e.recIn - off, recOut: e.recOut - off, srcIn: e.srcIn ?? 0, speed: e.speed ?? 100, reverse: Boolean(e.reverse), color: e.color && typeof e.color === 'object' ? { r: Number(e.color.r) || 0, g: Number(e.color.g) || 0, b: Number(e.color.b) || 0 } : null }))
       .sort((a, b) => a.track.localeCompare(b.track) || a.recIn - b.recIn);
   };
   // FADES (E94): BL legs on the input side and the Solid Color generators a
@@ -972,6 +975,30 @@ export function verifyRoundtrip(inputEvents, exportedEvents, opts = {}) {
 
   const a0 = norm(inputEvents);
   const b0 = norm(exportedEvents);
+  // GENERATOR COLOUR (E112): a black leg is only "black" by default — an
+  // XMEML fillcolor rides on it (fade-to-white, colour mattes; E110), and
+  // Resolve's FCP7 writer emits the colour back. Black legs still merge out
+  // of the pairwise geometry compare (their extents follow the picture), but
+  // every input leg that CARRIES a colour must find an exported leg on the
+  // same track overlapping its span with the same colour — a white fade that
+  // came back black is a conform error geometry alone cannot see.
+  const generatorColours = { compared: 0, mismatches: [] };
+  const colourKey = (c) => (c ? [c.r, c.g, c.b].map((v) => Math.round(v * 255)).join(',') : '0,0,0');
+  const colourTol = 1 / 255 + 1e-9;
+  const sameColour = (x, y) => ['r', 'g', 'b'].every((k) => Math.abs((x ? x[k] : 0) - (y ? y[k] : 0)) <= colourTol);
+  {
+    const inLegs = a0.filter((e) => isBlackSeg(e) && e.color);
+    const exLegs = b0.filter((e) => isBlackSeg(e));
+    for (const leg of inLegs) {
+      const partner = exLegs.find((x) => x.track === leg.track && x.recIn < leg.recOut && x.recOut > leg.recIn);
+      generatorColours.compared += 1;
+      if (!partner) {
+        generatorColours.mismatches.push({ kind: 'generator-colour', track: leg.track, record: [leg.recIn, leg.recOut], input: colourKey(leg.color), exported: null });
+      } else if (!sameColour(leg.color, partner.color)) {
+        generatorColours.mismatches.push({ kind: 'generator-colour', track: leg.track, record: [leg.recIn, leg.recOut], input: colourKey(leg.color), exported: colourKey(partner.color) });
+      }
+    }
+  }
   const a = a0.filter((e) => !isBlackSeg(e));
   const b = b0.filter((e) => !isBlackSeg(e));
   const blackSegments = { input: a0.length - a.length, exported: b0.length - b.length };
@@ -1039,8 +1066,10 @@ export function verifyRoundtrip(inputEvents, exportedEvents, opts = {}) {
     }
     mismatches.push(...markers.mismatches);
   }
+  mismatches.push(...generatorColours.mismatches);
   return {
     pass: mismatches.length === 0, pairs: n, srcOffsets, mismatches, markers,
+    ...(generatorColours.compared ? { generatorColours } : {}),
     ...(markersNotInExport ? { markersNotInExport } : {}),
     ...(blackSegments.input || blackSegments.exported ? { blackSegments } : {}),
     ...(fadeReshapedBoundaries.length ? { fadeReshapedBoundaries } : {}),

package/resolve-advanced/server/editorial.mjs

@@ -289,6 +289,26 @@ export function parseOTIO(otio, opts = {}) {
 }
 
 // ── XMEML (FCP7 XML) — light clipitem parse ────────────────────────────
+/**
+ * A generatoritem's `fillcolor` parameter → {r,g,b,a} in 0..1, or null when
+ * absent/black (the default Solid Color). FCP7 XML writes 0..255 channels
+ * (Premiere Color Matte and Resolve's own export alike).
+ */
+function xmemlFillColor(g) {
+  const params = g && g.effect && g.effect.parameter ? (Array.isArray(g.effect.parameter) ? g.effect.parameter : [g.effect.parameter]) : [];
+  for (const pm of params) {
+    // Premiere writes the matte colour as `fillcolor`; Resolve's OWN writer
+    // emits a Solid Color's colour as the FxPlug input parameter `input_1`
+    // (measured E112) — any RGB-valued generator parameter is the colour.
+    if (!pm.value || typeof pm.value !== 'object' || pm.value.red == null || pm.value.green == null || pm.value.blue == null) continue;
+    const ch = (k) => { const v = Number(pm.value[k]); return Number.isFinite(v) ? Math.max(0, Math.min(255, v)) / 255 : 0; };
+    const c = { r: ch('red'), g: ch('green'), b: ch('blue'), a: pm.value.alpha != null ? ch('alpha') : 1 };
+    if (c.r === 0 && c.g === 0 && c.b === 0) return null; // black = the default leg
+    return c;
+  }
+  return null;
+}
+
 export function parseXMEMLEvents(xml, opts = {}) {
   const { XMLParser } = require('fast-xml-parser');
   const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: '@_' });
@@ -366,7 +386,7 @@ export function parseXMEMLEvents(xml, opts = {}) {
         const itemMarkers = mks
           .filter((mk) => Number.isFinite(Number(mk.in)))
           .map((mk) => ({ frame: Number(mk.in) - inF, name: mk.name != null ? String(mk.name) : undefined, note: mk.comment != null ? String(mk.comment) : undefined }));
-        events.push(evt({ index: idx++, track, source: name, srcIn: Number.isFinite(inF) ? inF + inAdj : inF, srcOut: Number.isFinite(outF) ? outF + inAdj : outF, recIn: start, recOut: end, speed, reverse, itemMarkers: itemMarkers.length ? itemMarkers : undefined, fps: seqRate }));
+        events.push(evt({ index: idx++, track, source: name, srcIn: Number.isFinite(inF) ? inF + inAdj : inF, srcOut: Number.isFinite(outF) ? outF + inAdj : outF, recIn: start, recOut: end, speed, reverse, itemMarkers: itemMarkers.length ? itemMarkers : undefined, color: it.__genColor || undefined, fps: seqRate }));
       }
     }
   };
@@ -435,12 +455,17 @@ export function parseXMEMLEvents(xml, opts = {}) {
         const frame = al === 'start-black' || al === 'start' ? s0 : al === 'end-black' || al === 'end' ? e0 : Math.round((s0 + e0) / 2);
         return { frame, start: s0, end: e0 };
       }).filter(Boolean);
-      // Solid Color generatoritems are BLACK legs (what Resolve writes for a
-      // fade's black side); they walk as BL events so fades round-trip.
+      // Solid Color / Color Matte generatoritems are GENERATOR legs: black by
+      // default (what Resolve writes for a fade's black side), or the
+      // `fillcolor` the item declares — Resolve's importer honours it and
+      // its writer emits it back (E110, render-measured). They walk as BL
+      // events carrying `color` so fades AND fade-to-colour round-trip.
       const gens = t.generatoritem ? (Array.isArray(t.generatoritem) ? t.generatoritem : [t.generatoritem]) : [];
       for (const g of gens) {
-        if (!/solid color|black/i.test(String(g.name || ''))) continue;
-        walk([{ ...g, name: 'BL', filter: undefined, marker: undefined }], label, false);
+        const gname = String(g.name || '');
+        const eid = String((g.effect && (g.effect.effectid || g.effect.name)) || '');
+        if (!(/solid color|black|colou?r matte/i.test(gname) || /^(solid color|color)$/i.test(eid))) continue;
+        walk([{ ...g, name: 'BL', filter: undefined, marker: undefined, __genColor: xmemlFillColor(g) }], label, false);
       }
       clipCursor = 0;
       if (t.clipitem) walk(t.clipitem, label);

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),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-16; presence suppresses the A1 mirror; A1-A8 and the raised A9-A16 ceiling render-verified on 19),markers? (ITEM markers/clip locators: [{frame ITEM-relative, color?, name?, note?, duration?, customData?}] — readback-verified on 19; NOTE Resolve's own EXPORT_DRT drops item markers, this authoring path is the only .drt carrier)}]} | [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' | '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 through depth-4 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-16; presence suppresses the A1 mirror; A1-A8 and the raised A9-A16 ceiling render-verified on 19),markers? (ITEM markers/clip locators: [{frame ITEM-relative, color?, name?, note?, duration?, customData?}] — readback-verified on 19; NOTE Resolve's own EXPORT_DRT drops item markers, this authoring path is the only .drt carrier)}]} | [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' | '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 through depth-4 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), color? ({r,g,b[,a]} 0..1 floats or 0..255 ints — a Solid Color FILL; authored as the EffectFiltersBA Resolve's own writer emits, render-verified E110: white 235, BT.601-exact colours), ...}] }. 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/server/tools/editorial.mjs

@@ -86,7 +86,7 @@ const markerSchema = z.object({
 export const editorialTool = {
   name: 'editorial',
   description:
-    'Editorial integrity (Cluster E) — turnover interchange → normalized events → changelist + conform manifest with TIMING silent-lie guards (flattened retime / dropped J/L-cut audio / framerate-pulldown slip / reverse dropped / transition-handle starvation → flag, skip-not-fake). Report-only (gate: review). Actions: parse_interchange (EDL/OTIO/XMEML natively — incl. Resolve-written FCP7 -1 junction edges (paired in record order) + Solid Color generators, XMEML audio-track transitionitems as audio cross-fades on numbered lanes A/A2/…, and CMX FROM/TO CLIP NAME comments over the generic AX reel — + AAF via pyaaf2 (flat sound/picture slots number A/A2/… and V/V2/… in slot order so separate beds keep their lanes; NestedScope layers keep layer numbering) + PRPROJ via gunzip+XML → normalized events incl. span-explicit transitions, BL fade legs, and freezes as zero-speed events (OTIO FreezeFrame, XMEML timeremap 0, PrProj in==out, AAF 0% motion effects); for AAF/PRPROJ pass the file PATH as content; AAF also returns per-sequence startTimecode/startFrame — build the timeline at THAT start, not the Resolve 01:00:00:00 default — and per-clip `geometry` for Avid transform effects), list_sequences (ONE offline picker entry point across xml/edl/otio/drt/drp/aaf/prproj → [{id,name,eventCount}], plus startTimecode/startFrame for AAF), convert_to_interchange (author OTIO/EDL/DRT Resolve CAN import from events or a parsed source; the EDL target writes CMX transition pairs incl. BL fades — the .prproj→Resolve conform bridge, no Premiere needed; editorial timing/transitions survive and per-clip effects/color do not. SPEED/REVERSE survive on the otio (LinearTimeWarp) and edl (M2) targets ONLY — this FLAT drt target flattens every retime to 100% forward and returns `flattened`/`flattenedCount` naming each event that lost one (`flattened` is always present on `drt`, empty when there were none); for a .drt that AUTHORS retimes/dissolves/multi-track/audio, use drt.assemble_from_interchange), turnover_changelist (diff old vs new → moved/retimed/trimmed/replaced/new/gone PLUS the junction diff: transition_added/transition_dropped/transition_changed with fade in/out or dissolve, outgoing/incoming, span and duration/type/pre-roll deltas — zero-length CMX carrier lines and the BL legs that carry fades fold into the junction diff instead of reading as gone/new sources; events pair by closest record position, consumed once, so a source cut twice at two speeds compares instance to instance; + timing flags incl. transition_dropped and dropped_split_audio on any A-track), conform_manifest (per-event assert: source resolved/handles/retime/reverse/TC-base; BL-aware — black legs need no source, fades no black-side handles, and a fade-out tail requirement lands on the picture source), marker_roundtrip (markers with provenance tags), verify_roundtrip (input events vs re-export events -> pass/mismatches + fitted per-source TC offsets + marker compare w/ markersNotInExport honesty flag; FADE-AWARE: BL/Solid-Color legs merge out as blackSegments and fade-window boundary reshapes are excused into fadeReshapedBoundaries instead of failing; RETIME-AWARE: speed/reverse compare pairwise — EXPORT_OTIO carries an authored Sm2TimeMap back as LinearTimeWarp (measured), so a flattened/lost retime fails as drift geometry alone cannot catch; AUDIO-AWARE: declared audio events compare (a video-only export such as EXPORT_EDL flags audioNotInExport instead of failing) (channel legs deduped, mismatches tagged trackType audio) while the mirrored-A1 export of a video-only turnover stays informational; the conform QC loop-closer). Offline (AAF needs pyaaf2; live AAF/DRP import is on the Python davinci-resolve MCP).',
+    'Editorial integrity (Cluster E) — turnover interchange → normalized events → changelist + conform manifest with TIMING silent-lie guards (flattened retime / dropped J/L-cut audio / framerate-pulldown slip / reverse dropped / transition-handle starvation → flag, skip-not-fake). Report-only (gate: review). Actions: parse_interchange (EDL/OTIO/XMEML natively — incl. Resolve-written FCP7 -1 junction edges (paired in record order) + Solid Color / Color Matte generators carrying their `fillcolor` (BL legs with `color` → fade-to-white and colour mattes author, E110), XMEML audio-track transitionitems as audio cross-fades on numbered lanes A/A2/…, and CMX FROM/TO CLIP NAME comments over the generic AX reel — + AAF via pyaaf2 (flat sound/picture slots number A/A2/… and V/V2/… in slot order so separate beds keep their lanes; NestedScope layers keep layer numbering) + PRPROJ via gunzip+XML → normalized events incl. span-explicit transitions, BL fade legs, and freezes as zero-speed events (OTIO FreezeFrame, XMEML timeremap 0, PrProj in==out, AAF 0% motion effects); for AAF/PRPROJ pass the file PATH as content; AAF also returns per-sequence startTimecode/startFrame — build the timeline at THAT start, not the Resolve 01:00:00:00 default — and per-clip `geometry` for Avid transform effects), list_sequences (ONE offline picker entry point across xml/edl/otio/drt/drp/aaf/prproj → [{id,name,eventCount}], plus startTimecode/startFrame for AAF), convert_to_interchange (author OTIO/EDL/DRT Resolve CAN import from events or a parsed source; the EDL target writes CMX transition pairs incl. BL fades — the .prproj→Resolve conform bridge, no Premiere needed; editorial timing/transitions survive and per-clip effects/color do not. SPEED/REVERSE survive on the otio (LinearTimeWarp) and edl (M2) targets ONLY — this FLAT drt target flattens every retime to 100% forward and returns `flattened`/`flattenedCount` naming each event that lost one (`flattened` is always present on `drt`, empty when there were none); for a .drt that AUTHORS retimes/dissolves/multi-track/audio, use drt.assemble_from_interchange), turnover_changelist (diff old vs new → moved/retimed/trimmed/replaced/new/gone PLUS the junction diff: transition_added/transition_dropped/transition_changed with fade in/out or dissolve, outgoing/incoming, span and duration/type/pre-roll deltas — zero-length CMX carrier lines and the BL legs that carry fades fold into the junction diff instead of reading as gone/new sources; events pair by closest record position, consumed once, so a source cut twice at two speeds compares instance to instance; + timing flags incl. transition_dropped and dropped_split_audio on any A-track), conform_manifest (per-event assert: source resolved/handles/retime/reverse/TC-base; BL-aware — black legs need no source, fades no black-side handles, and a fade-out tail requirement lands on the picture source), marker_roundtrip (markers with provenance tags), verify_roundtrip (input events vs re-export events -> pass/mismatches + fitted per-source TC offsets + marker compare w/ markersNotInExport honesty flag; FADE-AWARE: BL/Solid-Color legs merge out as blackSegments and fade-window boundary reshapes are excused into fadeReshapedBoundaries instead of failing; RETIME-AWARE: speed/reverse compare pairwise — EXPORT_OTIO carries an authored Sm2TimeMap back as LinearTimeWarp (measured), so a flattened/lost retime fails as drift geometry alone cannot catch; AUDIO-AWARE: declared audio events compare (a video-only export such as EXPORT_EDL flags audioNotInExport instead of failing) (channel legs deduped, mismatches tagged trackType audio) while the mirrored-A1 export of a video-only turnover stays informational; COLOUR-AWARE: an input generator leg carrying a fillcolor (fade-to-white, colour matte) must come back on the same track over its span with the same colour — Resolve\'s FCP7 writer emits it — else generator-colour fails (generatorColours reports the compare); the conform QC loop-closer). Offline (AAF needs pyaaf2; live AAF/DRP import is on the Python davinci-resolve MCP).',
   async handler({ action, args }) {
     if (action === 'parse_interchange') {
       const p = parseSchema.parse(args);

package/resolve-advanced/vendor/drp-format/__tests__/place-generator.test.js

@@ -38,3 +38,37 @@ test('placeGenerator honors generatorName + requires startFrame', async () => {
   assert.ok(/<PrettyType>Gray Scale<\/PrettyType>/.test(v1));
   await assert.rejects(() => placeGenerator(buffer, { trackIndex: 1 }), /startFrame/);
 });
+
+// E110: Solid Color fill colour. Ground truth is Resolve 19.1.3.7's OWN writer:
+// FCP7 generatoritem fillcolor red / blue imported, rendered Y81 U90 V240 and
+// Y41 U240 V110 (BT.601 limited-range exact), and EXPORT_DRT wrote these two
+// 55-byte EffectFiltersBA blobs — only the ARGB words differ.
+const { solidColorEffectBlob, decodeSolidColorEffectBlob } = require('../place-generator');
+const RED_BLOB = '000000020000002f800a2c080a18004a004a2408061a0f0a0d320b01ffffffff000000000000220f0a0d320b00ffff0000000000000000';
+const BLUE_BLOB = '000000020000002f800a2c080a18004a004a2408061a0f0a0d320b01ffff00000000ffff0000220f0a0d320b00ffff0000000000000000';
+
+test('solidColorEffectBlob reproduces Resolve-written red and blue byte-for-byte (E110)', () => {
+  assert.equal(solidColorEffectBlob({ r: 1, g: 0, b: 0 }), RED_BLOB);
+  assert.equal(solidColorEffectBlob({ r: 0, g: 0, b: 255 }), BLUE_BLOB); // 0..255 ints accepted
+  assert.deepEqual(decodeSolidColorEffectBlob(RED_BLOB), { a: 1, r: 1, g: 0, b: 0 });
+  assert.deepEqual(decodeSolidColorEffectBlob(BLUE_BLOB), { a: 1, r: 0, g: 0, b: 1 });
+  const mid = decodeSolidColorEffectBlob(solidColorEffectBlob({ r: 0.5, g: 0.25, b: 0.75 }));
+  assert.ok(Math.abs(mid.r - 0.5) < 1e-4 && Math.abs(mid.g - 0.25) < 1e-4 && Math.abs(mid.b - 0.75) < 1e-4);
+  // Null controls: not-that-shape decodes to null; out-of-range refuses.
+  assert.equal(decodeSolidColorEffectBlob(''), null);
+  assert.equal(decodeSolidColorEffectBlob('00' + RED_BLOB), null);
+  assert.throws(() => solidColorEffectBlob({ r: 300, g: 0, b: 0 }), /exceeds range|0\.\.255/);
+  assert.throws(() => solidColorEffectBlob({ r: -1, g: 0, b: 0 }), />= 0/);
+});
+
+test('placeGenerator writes the colour blob only when a colour is given (E110)', async () => {
+  const { buffer, startFrame } = await createEmptyProject({ timelineName: 'GenColour' });
+  const withColour = await placeGenerator(buffer, { startFrame, durationFrames: 48, trackIndex: 2, color: { r: 1, g: 1, b: 1 } });
+  const v2 = await genOnTrack(withColour.buffer, 2);
+  assert.ok(v2.includes(`<EffectFiltersBA>${solidColorEffectBlob({ r: 1, g: 1, b: 1 })}</EffectFiltersBA>`), 'white blob authored');
+  assert.deepEqual(withColour.color, { r: 1, g: 1, b: 1, a: 1 });
+  const plain = await placeGenerator(buffer, { startFrame, durationFrames: 48, trackIndex: 2 });
+  const v2plain = await genOnTrack(plain.buffer, 2);
+  assert.ok(/<EffectFiltersBA\s*\/>|<EffectFiltersBA>\s*<\/EffectFiltersBA>/.test(v2plain), 'default stays the empty blob');
+  assert.equal(plain.color, null);
+});

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

@@ -10,7 +10,7 @@
  *     elements?: [
  *       { type: 'title',     track, startFrame, durationFrames?, text?, font?, style?, size?,
  *                            color?, vJustify?, hJustify? },
- *       { type: 'generator', track, startFrame, durationFrames?, generatorName? },
+ *       { type: 'generator', track, startFrame, durationFrames?, generatorName?, color? ({r,g,b} 0..1 — Solid Color fill, E110) },
  *     ],
  *     transitions?: [ { track, atFrame, durationFrames? } ],  // need two abutting clips at atFrame
  *   }
@@ -266,6 +266,7 @@ async function assembleTimeline(spec = {}) {
       ({ buffer } = await placeGenerator(buffer, {
         generatorName: el.generatorName, trackIndex: el.track,
         startFrame: el.startFrame, durationFrames: el.durationFrames, templateVersion,
+        color: el.color,
       }));
     } else {
       throw new Error(`assembleTimeline: elements[${i}] unknown type "${el.type}" (title|generator)`);

package/resolve-advanced/vendor/drp-format/index.js

@@ -117,6 +117,8 @@ module.exports = {
 
   // Place a built-in generator (Solid Color, etc.) on a chosen video track.
   placeGenerator: require('./place-generator').placeGenerator,
+  solidColorEffectBlob: require('./place-generator').solidColorEffectBlob,
+  decodeSolidColorEffectBlob: require('./place-generator').decodeSolidColorEffectBlob,
 
   // Insert a cross-dissolve between two abutting clips (the one op the Resolve API can't do).
   placeTransition: require('./place-transition').placeTransition,

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

@@ -4,8 +4,18 @@
  *
  * Built-in generators are `<Sm2TiGenerator>` with a `<PrettyType>` naming the generator
  * (Solid Color, Gray Scale, …) — small, no Fusion-comp blob (unlike Text+, which is an
- * Sm2TiVideoClip). The default has an empty `<EffectFiltersBA>` (default params/color);
- * setting a custom color would populate that blob (separate ground-truth capture).
+ * Sm2TiVideoClip). The default has an empty `<EffectFiltersBA>` (default params/color).
+ *
+ * COLOR (E110, ground truth from Resolve's OWN writer, Studio 19.1.3.7): a Solid Color
+ * with a non-default color carries a 55-byte `<EffectFiltersBA>`. Resolve's FCP7 XML
+ * importer honours a generatoritem `fillcolor` (red rendered Y81 U90 V240, blue
+ * Y41 U240 V110 — exact BT.601 limited-range), EXPORT_DRT then wrote:
+ *   00000002 0000002f                      version 2, payload length 47
+ *   80 0a 2c 08 0a 18 00 4a 00 4a 24 08 06 1a 0f 0a 0d 32 0b   fixed prefix
+ *   01  AAAA RRRR GGGG BBBB 0000           flag + big-endian uint16 ARGB (+ pad)
+ *   22 0f 0a 0d 32 0b 00 ffff 0000 0000 0000 0000              second colour, black
+ * Only the ARGB words differed between the red and blue captures. `opts.color`
+ * ({r,g,b} in 0..1, or 0..255 ints) populates that blob; omitted = the empty default.
  *
  * Clone-based: carry the bundled Solid Color template and swap PrettyType/Name/Start/
  * Duration + a fresh DbId. The same Sm2TiGenerator shape serves the other simple built-in
@@ -50,11 +60,12 @@ function snippetPathFor(templateVersion) {
  * @param {number} opts.startFrame       - timeline start frame (required; must be >= timeline origin).
  * @param {number} [opts.durationFrames=120]
  * @param {string} [opts.timelineUuid]
+ * @param {{r:number,g:number,b:number,a?:number}} [opts.color] - Solid Color fill (0..1 floats, or 0..255 ints).
  * @returns {Promise<{buffer:Buffer, entry:string, timelineUuid:string, trackIndex:number,
- *   generatorName:string, videoTrackCount:number, createdTracks:number}>}
+ *   generatorName:string, videoTrackCount:number, createdTracks:number, color:object|null}>}
  */
 async function placeGenerator(drpInput, opts = {}) {
-  const { generatorName = 'Solid Color', trackIndex = 2, startFrame, durationFrames = 120, timelineUuid, templateVersion } = opts;
+  const { generatorName = 'Solid Color', trackIndex = 2, startFrame, durationFrames = 120, timelineUuid, templateVersion, color } = opts;
   if (!Number.isInteger(startFrame)) throw new TypeError('placeGenerator: startFrame (int) is required');
   if (!Number.isInteger(trackIndex) || trackIndex < 1) throw new TypeError('placeGenerator: trackIndex must be a positive integer');
   if (/[<>]/.test(generatorName)) throw new Error('placeGenerator: generatorName must not contain < or >');
@@ -68,6 +79,14 @@ async function placeGenerator(drpInput, opts = {}) {
   gen = gen.replace(/<Name>[\s\S]*?<\/Name>/, `<Name>${escapeXml(generatorName)}</Name>`);
   gen = gen.replace(/<Start>\d+<\/Start>/, `<Start>${startFrame}</Start>`);
   gen = gen.replace(/<Duration>\d+<\/Duration>/, `<Duration>${durationFrames}</Duration>`);
+  const colorNorm = color != null ? normalizeColor(color) : null;
+  if (colorNorm) {
+    const blob = solidColorEffectBlob(colorNorm);
+    if (!/<EffectFiltersBA\s*\/>|<EffectFiltersBA>\s*<\/EffectFiltersBA>/.test(gen)) {
+      throw new Error('placeGenerator: template carries no empty <EffectFiltersBA/> to populate with the colour');
+    }
+    gen = gen.replace(/<EffectFiltersBA\s*\/>|<EffectFiltersBA>\s*<\/EffectFiltersBA>/, `<EffectFiltersBA>${blob}</EffectFiltersBA>`);
+  }
 
   const { match: vtv, tracks } = getTrackVec(seqXml, 'video');
   if (tracks.length === 0) throw new Error('placeGenerator: no existing video track to clone from');
@@ -97,8 +116,43 @@ async function placeGenerator(drpInput, opts = {}) {
   const buffer = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' });
   return {
     buffer, entry, timelineUuid: seqId, trackIndex, generatorName,
-    videoTrackCount: tracks.length, createdTracks,
+    videoTrackCount: tracks.length, createdTracks, color: colorNorm,
   };
 }
 
-module.exports = { placeGenerator, TEMPLATE_PATH };
+// ── Solid Color effect blob (E110) ─────────────────────────────────────
+const BLOB_PREFIX = '000000020000002f800a2c080a18004a004a2408061a0f0a0d320b01';
+const BLOB_SUFFIX = '0000220f0a0d320b00ffff0000000000000000';
+
+/** {r,g,b[,a]} in 0..1 floats or 0..255 ints → 0..1 floats. Refuses NaN/out-of-range. */
+function normalizeColor(c) {
+  if (!c || typeof c !== 'object') throw new TypeError('placeGenerator: color must be {r,g,b[,a]}');
+  const vals = ['r', 'g', 'b'].map((k) => Number(c[k]));
+  if (vals.some((v) => !Number.isFinite(v) || v < 0)) throw new RangeError('placeGenerator: color r/g/b must be finite numbers >= 0');
+  const a = c.a == null ? null : Number(c.a);
+  if (a != null && (!Number.isFinite(a) || a < 0)) throw new RangeError('placeGenerator: color a must be a finite number >= 0');
+  const all = a == null ? vals : [...vals, a];
+  const eightBit = all.some((v) => v > 1);
+  const norm = (v) => (eightBit ? v / 255 : v);
+  const out = { r: norm(vals[0]), g: norm(vals[1]), b: norm(vals[2]), a: a == null ? 1 : norm(a) };
+  for (const k of ['r', 'g', 'b', 'a']) if (out[k] > 1) throw new RangeError(`placeGenerator: color ${k} exceeds range (0..1 floats or 0..255 ints)`);
+  return out;
+}
+
+/** Encode a normalized {r,g,b,a} (0..1) as the 55-byte Solid Color EffectFiltersBA hex. */
+function solidColorEffectBlob(color) {
+  const c = normalizeColor(color);
+  const w = (v) => Math.round(v * 65535).toString(16).padStart(4, '0');
+  return `${BLOB_PREFIX}${w(c.a)}${w(c.r)}${w(c.g)}${w(c.b)}${BLOB_SUFFIX}`;
+}
+
+/** Decode a Solid Color EffectFiltersBA hex → {r,g,b,a} in 0..1, or null when it is not that shape. */
+function decodeSolidColorEffectBlob(hex) {
+  const h = String(hex || '').toLowerCase();
+  if (h.length !== 110 || !h.startsWith(BLOB_PREFIX) || !h.endsWith(BLOB_SUFFIX)) return null;
+  const words = h.slice(BLOB_PREFIX.length, BLOB_PREFIX.length + 16);
+  const v = (i) => parseInt(words.slice(i * 4, i * 4 + 4), 16) / 65535;
+  return { a: v(0), r: v(1), g: v(2), b: v(3) };
+}
+
+module.exports = { placeGenerator, TEMPLATE_PATH, solidColorEffectBlob, decodeSolidColorEffectBlob, normalizeColor };

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.167.0"
+VERSION = "2.169.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.167.0"
+VERSION = "2.169.0"
 
 import base64
 import os

package/src/utils/api_truth.py

@@ -2794,6 +2794,47 @@ API_TRUTH: List[Dict[str, Any]] = [
         "submit": "missing",
         "mitigation": ["editorial.verify_roundtrip audioNotInExport", "timeline.export_timeline_checked"],
     },
+    {
+        "symbol": "ImportTimelineFromFile FCP7 XML generatoritem fillcolor (honoured; EXPORT_DRT blob layout)",
+        "object": "MediaPool",
+        "signature": "(filePath.xml) -> Timeline",
+        "reality": "Resolve's FCP7 XML importer HONOURS a generatoritem's "
+                   "`fillcolor` parameter (measured on Studio 19.1.3.7, E110): "
+                   "a Premiere-shaped Color Matte (effectid Color, category "
+                   "Matte) and a Solid Color generatoritem, both with "
+                   "<red>/<green>/<blue>/<alpha> 0..255 values, imported as "
+                   "Solid Color items and rendered Y81 U90 V240 (red) and "
+                   "Y41 U240 V110 (blue) — exact BT.601 limited-range values "
+                   "for a 640x360 timeline. EXPORT_FCP_7_XML writes the "
+                   "fillcolor back (same 0..255 channels). EXPORT_DRT carries "
+                   "the colour as a 55-byte <EffectFiltersBA> on the "
+                   "Sm2TiGenerator: 8-byte header (version 2, length 47), a "
+                   "fixed 20-byte prefix, a flag byte, then big-endian uint16 "
+                   "A R G B (0xffff = full) plus a pad word, then a second, "
+                   "black colour record; only the ARGB words differed between "
+                   "the red and blue captures. The default generator has an "
+                   "EMPTY EffectFiltersBA. The same importer does NOT carry a "
+                   "TRANSITION's parameters: a `Dip to Color Dissolve` "
+                   "transitionitem with a white and with a red `color` "
+                   "parameter imported as `Dip To Color Dissolve` elements "
+                   "whose 37-byte EffectFiltersBA were byte-identical "
+                   "(defaults), and the transition rendered inert (luma flat "
+                   "through its window, the E66 law) — the dip colour stays "
+                   "GUI-only on 19.1.3.7 (measured, E111). The writer emits "
+                   "a Solid Color's colour as the FxPlug parameter `input_1` "
+                   "(effectid FxPlugWrapper:C18E8B62_…), not `fillcolor` — an "
+                   "authored EffectFiltersBA colour came back exactly (white, "
+                   "128/64/191; E112).",
+        "recommended": "Author fade-to-white / colour mattes by placing a "
+                       "Solid Color generator with that blob "
+                       "(drp-format placeGenerator `color`, drt.assemble "
+                       "elements[].color) — or carry an XMEML generatoritem "
+                       "fillcolor through editorial.parse_interchange; the "
+                       "bridge authors the coloured leg.",
+        "tags": ["xml", "import", "generator", "colour", "export", "drt"],
+        "submit": "missing",
+        "mitigation": ["drp-format placeGenerator color", "editorial.parse_interchange fillcolor", "drt.assemble_from_interchange"],
+    },
     {
         "symbol": "ProjectManager.CreateProject (discards an unsaved current project)",
         "object": "ProjectManager",