davinci-resolve-mcp 2.166.0 → 2.168.0

package/CHANGELOG.md

@@ -2,6 +2,59 @@
 
 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.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
+MobSlots. The AAF walker labelled every flat slot `A` (only `NestedScope`
+layers were numbered), so a dialog lane and a music bed collided on A1 and
+the bridge refused the whole turnover ("audio events overlap on audio track
+1 — one track cannot hold both"). The sound `Transition` between the dialog
+clips parsed fine; the lane collapse was the block.
+
+### Fixed
+
+- **Flat AAF slots number per media kind in slot order** (`A`, `A2`, `A3` …
+  / `V`, `V2` …). The first slot of a kind keeps the bare letter; `NestedScope`
+  layers keep their own layer numbering. Render-measured on 19.1.3.7: an AAF
+  with a dialog lane (−21 dBFS tone → 24f `MonoAudioDissolve` → −41 dBFS
+  tone) over a quiet music bed on its own slot conforms, imports, and renders
+  the cross-fade −26.0 → −29.3 → −32.5 → −37.5 → −41.6 dBFS across exactly its
+  window, with the second lane audibly present (−41.6 vs −47.1 for one lane).
+- **Channel legs still place once.** Resolve's own AAF export writes one slot
+  per audio channel with identical legs; the bridge's merge (and
+  `verify_roundtrip`'s dedupe) now key on source/range rather than the lane,
+  so channel legs of one clip merge while a different bed on its own lane
+  never does.
+
 ## What's New in v2.166.0 — E108: XMEML audio cross-fades conform and render
 
 The XMEML walker only looked at `<transitionitem>`s on VIDEO tracks, so an

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.166.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.168.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.166.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.168.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.166.0 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
+> 本翻译对应 v2.168.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.
+- **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.166.0"
+VERSION = "2.168.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.166.0",
+  "version": "2.168.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;
@@ -201,8 +202,11 @@ plausible-looking short event list. Three limits are deliberate:
 - **Effect-only layers produce no events.** A layer wrapping `ScopeReference` (subtitle burns, blends,
   mattes) applies to what shows through from below and references no media of its own. OTIO materializes
   such layers as tracks of gaps, so its track count can exceed the number of layers with media.
-- **Only `NestedScope` layers are numbered.** Non-nested slots keep the flat `V`/`A` label, which is what
-  `editorial.mjs`'s `/^A\d*$/` audio-follows-video heuristic reads (`A`, `A2`, … all count as audio).
+- **Flat slots number per media kind in slot order** (`A`, `A2`, `A3` … / `V`, `V2` …): an Avid
+  turnover carries dialog, music and effects as SEPARATE flat sound MobSlots, and labelling them all
+  `A` stacked every bed onto one lane where the bridge refuses the overlap (measured, E109). The first
+  slot of a kind keeps the bare letter; `NestedScope` layers keep their own layer numbering. This is
+  what `editorial.mjs`'s `/^A\d*$/` audio-follows-video heuristic reads (`A`, `A2`, … all count as audio).
 
 ## Provenance & license
 Vendored libraries are clean offline format-interop and deterministic compute code: no secrets, no

package/resolve-advanced/server/aaf_probe.py

@@ -1248,7 +1248,8 @@ def _walk_slot(segment, *, prefix, fps, state):
 
     A NestedScope slot is a multi-layer track: each layer gets its own numbered label
     (V1..Vn / A1..An) and restarts at record 0, because layers are parallel, not
-    sequential. A plain (single-layer) slot keeps the flat "V"/"A" label.
+    sequential. A plain (single-layer) slot keeps the label the caller numbered it
+    with (first of its kind bare "V"/"A", then "A2", "A3" … per slot order — E109).
     """
     if type(segment).__name__ == "NestedScope":
         for n, layer in enumerate(_nested_layers(segment), start=1):
@@ -1456,6 +1457,13 @@ def probe(path):
             # `idx` is monotonic across the WHOLE mob, every slot and every nested layer.
             state = {"idx": 1, "events": [], "unhandled": {}, "effectsWithoutEvents": {}}
             edit_fps = None
+            # FLAT slots number per media kind in slot order (A, A2, A3 … / V, V2 …):
+            # an Avid turnover carries dialog, music and effects as SEPARATE flat
+            # sound MobSlots, and labelling them all "A" stacked every bed onto one
+            # lane where the bridge refuses the overlap (measured, E109). The first
+            # slot of a kind keeps the bare letter (compat with every reader that
+            # matches /^A$/); NestedScope layers keep their own layer numbering.
+            kind_ordinal = {"A": 0, "V": 0}
             for slot in getattr(mob, "slots", []) or []:
                 seg = getattr(slot, "segment", None)
                 if seg is None:
@@ -1467,7 +1475,11 @@ def probe(path):
                 fps = _fps_from_edit_rate(getattr(slot, "edit_rate", None))
                 if edit_fps is None:
                     edit_fps = fps  # picks the timecode slot to trust — see above
-                _walk_slot(seg, prefix=_media_kind_to_track(slot), fps=fps, state=state)
+                letter = _media_kind_to_track(slot)
+                kind_ordinal[letter] += 1
+                is_nested = getattr(seg, "class_name", "") == "NestedScope" or type(seg).__name__ == "NestedScope"
+                label = letter if (kind_ordinal[letter] == 1 or is_nested) else f"{letter}{kind_ordinal[letter]}"
+                _walk_slot(seg, prefix=label, fps=fps, state=state)
             events = state["events"]
             sequences.append(
                 {

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

@@ -254,15 +254,19 @@ export function eventsToAssembleSpec(events, opts = {}) {
   const isMarker = (t) => t === 'MARKER';
   const vids = events.filter((e) => !isAudio(e.track) && !isMarker(e.track) && e.recIn != null && e.recOut != null);
   // AAF exports one event per audio CHANNEL — a stereo/dual-mono clip arrives
-  // as identical A-track legs (measured on a Resolve 19 rich export: every
-  // audio event duplicated). Merge exact duplicates (same track/source/range)
-  // so they place once instead of refusing as a same-track overlap.
+  // as identical legs, one per channel slot (measured on a Resolve 19 rich
+  // export: every audio event duplicated). Merge exact duplicates (same
+  // source/range/srcIn) so they place once instead of refusing as a
+  // same-track overlap. The key deliberately ignores the LANE: since E109
+  // flat slots number A, A2, A3 …, so channel legs of one clip arrive on
+  // different lanes — still one clip, placed once — while a different bed on
+  // its own lane (dialog A, music A2) keeps its lane and never merges.
   const audsRaw = events.filter((e) => isAudio(e.track) && e.recIn != null && e.recOut != null);
   const seenAud = new Set();
   const auds = [];
   let audioChannelLegsMerged = 0;
   for (const e of audsRaw) {
-    const k = `${e.track}|${e.source}|${e.recIn}|${e.recOut}|${e.srcIn}`;
+    const k = `${e.source}|${e.recIn}|${e.recOut}|${e.srcIn}|${e.speed ?? 100}|${e.reverse ? 1 : 0}`;
     if (seenAud.has(k)) { audioChannelLegsMerged += 1; continue; }
     seenAud.add(k);
     auds.push(e);
@@ -320,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);
@@ -976,12 +983,13 @@ export function verifyRoundtrip(inputEvents, exportedEvents, opts = {}) {
   // AUDIO (E97): compared only when the INPUT declares audio events — a
   // video-only turnover legitimately re-exports with audio (the A1
   // convenience mirror), which is reported informationally, never failed.
-  // AAF channel legs dedupe (same track/source/range arrives once per
-  // channel); BL/silence legs merge out like video black.
+  // AAF channel legs dedupe (the same source/range arrives once per channel
+  // slot — on numbered lanes since E109, so the key ignores the lane the way
+  // the bridge's placement merge does); BL/silence legs merge out like black.
   const dedupeAud = (list) => {
     const seen = new Set();
     return list.filter((e) => {
-      const k = `${e.track}|${e.source}|${e.recIn}|${e.recOut}|${e.srcIn}`;
+      const k = `${e.source}|${e.recIn}|${e.recOut}|${e.srcIn}`;
       if (seen.has(k)) return false;
       seen.add(k);
       return true;

package/resolve-advanced/server/editorial.mjs

@@ -289,6 +289,24 @@ 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) {
+    const pid = String(pm.parameterid || pm.name || '').trim().toLowerCase();
+    if (pid !== 'fillcolor' || !pm.value || typeof pm.value !== 'object') 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 +384,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 +453,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 + 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; 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.166.0"
+VERSION = "2.168.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.166.0"
+VERSION = "2.168.0"
 
 import base64
 import os

package/src/utils/api_truth.py

@@ -2794,6 +2794,36 @@ 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.",
+        "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",