davinci-resolve-mcp 4.18.0 → 4.18.1

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 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 v4.18.1 — Names with `$` or `\` are written as typed
+
+### Fixed
+
+- **`drt assemble_project` no longer rewrites a merged timeline's name when it
+  contains `$`** (#332, thanks @Dev-next-gen). The name was inserted with a
+  replacement string, and JavaScript expands `$&`, `$'` and `$$` in one. A
+  second timeline named `R2 $& $'` wrote an `MpFolder.xml` that no longer
+  parsed, and `Spot $$ 30s` came out as `Spot $ 30s`, so a `folder` move then
+  failed to find the timeline.
+- **The same fix in 53 more places in the offline `.drp`/`.drt` writers.**
+  Caption text in `placeSubtitles`, generator, title and compound clip names,
+  media pool clip names and file paths, and every other value inserted into
+  the XML now goes in with a replacer function, so `$`-sequences stay literal.
+  A new guard test fails the advanced suite if a `replace()` call passes an
+  interpolated template as a string.
+- **The audio-only fallback clone in `cut-media` now XML-escapes the source
+  file name and path.** A source path containing `&`, such as
+  `Smith & Jones/clip.mov`, wrote invalid XML.
+- **Re-running media analysis on a clip no longer fails when the new analysis
+  text contains a backslash.** The managed block in the clip's metadata was
+  replaced with `re.sub` using the text as a replacement string, so a Windows
+  path raised `bad escape \F` and `\t` turned into a tab. The text is now
+  inserted as-is.
+
+### Validation
+
+- Advanced Node suite on Node 20 with a fresh `npm ci`: 1,224 tests, 0 failed.
+  With the fixes reverted, the guard and the caption, generator and title tests
+  fail.
+- Python suite: the new metadata test fails with `bad escape \F` without the
+  fix and passes with it.
+- Offline file writers only. No Resolve API behaviour changed.
+
 ## What's New in v4.18.0 — Edit captions with Resolve open
 
 ### Added

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-4.18.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-4.18.1-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-37%20(390%20full)-blue.svg)](#server-modes)

package/README.zh-CN.md

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

package/install.py

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

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

@@ -467,7 +467,7 @@ export const drtTool = {
           } catch { return whole; }
         });
         // pool clip: uuid remap + keyed SeqRef patch + fresh numeric IDs
-        let tlNew = applyBlobs(apply(tlEl)).replace(/<ID>\d+<\/ID>/g, `<ID>${nextPoolId}<\/ID>`.replace('<\/ID>', '</ID>'));
+        let tlNew = applyBlobs(apply(tlEl)).replace(/<ID>\d+<\/ID>/g, () => `<ID>${nextPoolId}<\/ID>`.replace('<\/ID>', '</ID>'));
         nextPoolId += 1;
         const fbM = tlNew.match(/(<Sm2Sequence DbId="[^"]+">\s*<FieldsBlob>)([0-9a-fA-F]+)(<\/FieldsBlob>)/);
         if (fbM) {
@@ -486,14 +486,14 @@ export const drtTool = {
         // Children live INSIDE <MediaVec> — an element appended after its
         // close parses fine and is silently invisible (measured: the whole
         // REEL_02 subtree vanished while every id chain checked out).
-        mpXml = mpXml.replace('</MediaVec>', `${tlNew}\n</MediaVec>`);
+        mpXml = mpXml.replace('</MediaVec>', () => `${tlNew}\n</MediaVec>`);
         for (const el of mediaEls) {
           const id = el.match(/DbId="([^"]+)"/)[1];
-          if (!mpXml.includes(`DbId="${id}"`)) mpXml = mpXml.replace('</MediaVec>', `${el}\n</MediaVec>`);
+          if (!mpXml.includes(`DbId="${id}"`)) mpXml = mpXml.replace('</MediaVec>', () => `${el}\n</MediaVec>`);
         }
         const pj2 = await zip.file('project.xml').async('string');
         for (const blob of pj2.match(/<Element>\s*<Sm2(?:Sequence|TiItem)LockableBlob DbId="[^"]+">[\s\S]*?<\/Sm2(?:Sequence|TiItem)LockableBlob>\s*<\/Element>/g) || []) {
-          pjXml = pjXml.replace('</LocableBlobSet>', `${apply(blob)}</LocableBlobSet>`);
+          pjXml = pjXml.replace('</LocableBlobSet>', () => `${apply(blob)}</LocableBlobSet>`);
         }
         // THE timeline registry (found the hard way — two invisible merges):
         // project.xml's <TimelineHandleVec> lists each pool clip's embedded
@@ -503,7 +503,7 @@ export const drtTool = {
         const vec2 = pj2.match(/<TimelineHandleVec>([\s\S]*?)<\/TimelineHandleVec>/);
         if (vec2) {
           for (const h of vec2[1].match(/<Element>[^<]*<\/Element>/g) || []) {
-            pjXml = pjXml.replace('</TimelineHandleVec>', ` ${apply(h)}\n </TimelineHandleVec>`);
+            pjXml = pjXml.replace('</TimelineHandleVec>', () => ` ${apply(h)}\n </TimelineHandleVec>`);
           }
         }
         // future merges must not collide with THIS timeline's fresh ids either
@@ -534,7 +534,7 @@ export const drtTool = {
           const hit = mpXml.match(tlRe);
           if (!hit) throw new Error(`assemble_project: could not locate pool clip for timeline ${names[i]} to move into folder ${folder}`);
           mpXml = mpXml.replace(hit[0], '');
-          bin.clips.push(hit[0].replace(/<MpFolder>[^<]*<\/MpFolder>/, `<MpFolder>${bin.id}</MpFolder>`));
+          bin.clips.push(hit[0].replace(/<MpFolder>[^<]*<\/MpFolder>/, () => `<MpFolder>${bin.id}</MpFolder>`));
         }
         // Register the bins in Master's FieldsBlob — the parent folder blob
         // is the SUBFOLDER registry (measured: with it blanked, a bin's

package/resolve-advanced/vendor/audio/format-converter.js

@@ -213,7 +213,7 @@ async function convert(inputPath, outputPath, options = {}) {
   // Auto-generate output path if not provided
   if (!outputPath) {
     const ext = CONTAINER_EXTENSIONS[preset.container] || '.wav';
-    outputPath = inputPath.replace(/\.[^.]+$/, `_${presetName}${ext}`);
+    outputPath = inputPath.replace(/\.[^.]+$/, () => `_${presetName}${ext}`);
   }
 
   onProgress(10);

package/resolve-advanced/vendor/drp-format/__tests__/literal-replacement.test.js

@@ -0,0 +1,95 @@
+// A string passed as the replacement to String.prototype.replace expands `$&`,
+// `$'`, `` $` `` and `$$`, so a name or caption carrying them is rewritten on its
+// way into the XML (#332: `R2 $& $'` as a timeline name made MpFolder.xml
+// unparseable; `Spot $$ 30s` came out as `Spot $ 30s`). Interpolated
+// replacements are therefore passed as functions, which insert their result
+// literally. This file guards that rule and checks the writers that carry user
+// text.
+
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const path = require('node:path');
+const JSZip = require('jszip');
+const { escapeXml } = require('../xml-builder');
+const { createEmptyProject } = require('../author-project');
+const { placeSubtitles } = require('../place-subtitles');
+const { placeGenerator } = require('../place-generator');
+const { placeFusionTitle } = require('../place-fusion-title');
+
+const ROOT = path.resolve(__dirname, '..', '..', '..');
+const TRICKY = "Spot $$ 30s $& $' $` end";
+
+function sourceFiles(dir) {
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name === 'node_modules' || entry.name === '__tests__') continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...sourceFiles(full));
+    else if (/\.(m?js)$/.test(entry.name)) out.push(full);
+  }
+  return out;
+}
+
+// `.replace(<string or regex literal>, `...${...}...`)` on one line. A template
+// that uses a $-backreference ($1, $&, $<name>) needs the string form and is allowed.
+const STRING_REPLACEMENT = /\.replace\(\s*(?:'(?:[^'\\\n]|\\.)*'|"(?:[^"\\\n]|\\.)*"|\/(?:[^/\\\n]|\\.)+\/[a-z]*)\s*,\s*`((?:[^`\\]|\\.)*)`/g;
+const BACKREF = /\$(?:[0-9&'`]|<[A-Za-z_]\w*>)/;
+
+function offenders(text) {
+  const found = [];
+  for (const m of text.matchAll(STRING_REPLACEMENT)) {
+    const template = m[1];
+    if (!template.includes('${')) continue;
+    if (BACKREF.test(template.replace(/\$\{[^}]*\}/g, ''))) continue;
+    found.push(m[0].slice(0, 120));
+  }
+  return found;
+}
+
+test('no interpolated replace() replacement is passed as a string', () => {
+  const files = [...sourceFiles(path.join(ROOT, 'server')), ...sourceFiles(path.join(ROOT, 'vendor'))];
+  assert.ok(files.length > 50, `scanned ${files.length} files`);
+  const bad = [];
+  for (const file of files) {
+    for (const hit of offenders(fs.readFileSync(file, 'utf8'))) bad.push(`${path.relative(ROOT, file)}: ${hit}`);
+  }
+  assert.deepStrictEqual(bad, [], 'pass the replacement as () => `...` so $-sequences stay literal');
+});
+
+test('the guard catches the #332 form and allows the safe ones', () => {
+  assert.strictEqual(offenders("x.replace('</MediaVec>', `${el}\\n</MediaVec>`)").length, 1);
+  assert.strictEqual(offenders('x.replace(/<Name>[^<]*<\\/Name>/, `<Name>${n}</Name>`)').length, 1);
+  assert.strictEqual(offenders("x.replace('</MediaVec>', () => `${el}\\n</MediaVec>`)").length, 0);
+  assert.strictEqual(offenders('x.replace(/(<a>)<b\\/>/, `$1<b>${hex}</b>`)').length, 0);
+  assert.strictEqual(offenders("x.replace('a', 'b')").length, 0);
+});
+
+async function sequenceXml(buffer) {
+  const zip = await JSZip.loadAsync(buffer);
+  const parts = [];
+  for (const name of Object.keys(zip.files)) {
+    if (/SeqContainer\/[^/]+\.xml$|SeqContainer\d*\.xml$/.test(name)) parts.push(await zip.files[name].async('string'));
+  }
+  return parts.join('\n');
+}
+
+test('placeSubtitles keeps $-sequences in caption text', async () => {
+  const { buffer, startFrame } = await createEmptyProject({ timelineName: 'Subs' });
+  const res = await placeSubtitles(buffer, { subtitles: [{ startFrame, durationFrames: 48, text: TRICKY }] });
+  assert.ok((await sequenceXml(res.buffer)).includes(`<Name>${escapeXml(TRICKY)}</Name>`));
+});
+
+test('placeGenerator keeps $-sequences in the generator name', async () => {
+  const { buffer, startFrame } = await createEmptyProject({ timelineName: 'Gen' });
+  const res = await placeGenerator(buffer, { generatorName: TRICKY, trackIndex: 2, startFrame, durationFrames: 24 });
+  const xml = await sequenceXml(res.buffer);
+  assert.ok(xml.includes(`<PrettyType>${escapeXml(TRICKY)}</PrettyType>`));
+  assert.ok(xml.includes(`<Name>${escapeXml(TRICKY)}</Name>`));
+});
+
+test('placeFusionTitle keeps $-sequences in the clip name', async () => {
+  const { buffer, startFrame } = await createEmptyProject({ timelineName: 'Title' });
+  const res = await placeFusionTitle(buffer, { trackIndex: 2, startFrame, durationFrames: 24, name: TRICKY });
+  assert.ok((await sequenceXml(res.buffer)).includes(`<Name>${escapeXml(TRICKY)}</Name>`));
+});

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

@@ -247,7 +247,7 @@ async function assembleTimeline(spec = {}) {
         if (!hit) throw new Error(`assembleTimeline: item markers — no ${kind} clip starting at ${cut.startFrame} on track ${cut.track ?? 1}`);
         const blob = encodeTimelineMarkersBlob(cut.markers);
         const el = `<Element>\n     <Sm2TiItemLockableBlob DbId="${randomUUID()}">\n      <FieldsBlob>${blob.toString('hex')}</FieldsBlob>\n      <BlobOwner>${hit[1]}</BlobOwner>\n      <DbSavedTime>0</DbSavedTime>\n     </Sm2TiItemLockableBlob>\n    </Element>\n   `;
-        pj = pj.replace('</LocableBlobSet>', `${el}</LocableBlobSet>`);
+        pj = pj.replace('</LocableBlobSet>', () => `${el}</LocableBlobSet>`);
       }
       zipIM.file('project.xml', pj);
       buffer = await zipIM.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' });
@@ -417,7 +417,7 @@ async function assembleTimeline(spec = {}) {
     const setM = pjX.match(/<LocableBlobSet>[\s\S]*?<\/LocableBlobSet>/);
     if (!setM) throw new Error('assembleTimeline: project.xml has no LocableBlobSet to hold markers');
     const el = `<Element>\n     <Sm2SequenceLockableBlob DbId="${randomUUID()}">\n      <FieldsBlob>${blob.toString('hex')}</FieldsBlob>\n      <BlobOwner>${seqIdM}</BlobOwner>\n      <DbSavedTime>0</DbSavedTime>\n     </Sm2SequenceLockableBlob>\n    </Element>\n   `;
-    pjX = pjX.replace('</LocableBlobSet>', `${el}</LocableBlobSet>`);
+    pjX = pjX.replace('</LocableBlobSet>', () => `${el}</LocableBlobSet>`);
     zipM.file('project.xml', pjX);
     buffer = await zipM.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' });
   }

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

@@ -27,6 +27,7 @@ const {
   emptyTrackClone,
 } = require('./seq-surgery');
 const { clipDbId, setClipStart, setClipDuration, setClipIn, setClipInEmpty } = require('./splice-clips');
+const { escapeXml } = require('./xml-builder');
 
 /**
  * @param {Buffer|string} drpInput
@@ -96,7 +97,7 @@ async function cutSourceIntoClips(drpInput, opts = {}) {
     if (cut.mediaRef) {
       // Multi-source: point this cut at ITS source's transplanted pool
       // element instead of the donor's.
-      c = c.replace(/<MediaRef>[0-9a-f-]{36}<\/MediaRef>/, `<MediaRef>${cut.mediaRef}</MediaRef>`);
+      c = c.replace(/<MediaRef>[0-9a-f-]{36}<\/MediaRef>/, () => `<MediaRef>${cut.mediaRef}</MediaRef>`);
     }
     if (cut.srcMeta && !native && cut.audioOnly) {
       // Every clone must carry ITS OWN source identity — a donor clone
@@ -106,15 +107,15 @@ async function cutSourceIntoClips(drpInput, opts = {}) {
       // A1 (measured, E15), and a TC-bearing video source fails the whole
       // render with "Full resolution media not found" (measured, E31).
       const { name, mediaFilePath, fps, frameCount } = cut.srcMeta;
-      c = c.replace(/<Name>[\s\S]*?<\/Name>/, `<Name>${name}</Name>`);
-      c = c.replace(/<MediaFilePath>[\s\S]*?<\/MediaFilePath>/, `<MediaFilePath>${mediaFilePath}</MediaFilePath>`);
+      c = c.replace(/<Name>[\s\S]*?<\/Name>/, () => `<Name>${escapeXml(name)}</Name>`);
+      c = c.replace(/<MediaFilePath>[\s\S]*?<\/MediaFilePath>/, () => `<MediaFilePath>${escapeXml(mediaFilePath)}</MediaFilePath>`);
       const rate = Buffer.alloc(16);
       rate.writeDoubleLE(fps, 0);
-      c = c.replace(/<MediaFrameRate>[0-9a-fA-F]*<\/MediaFrameRate>/, `<MediaFrameRate>${rate.toString('hex')}</MediaFrameRate>`);
+      c = c.replace(/<MediaFrameRate>[0-9a-fA-F]*<\/MediaFrameRate>/, () => `<MediaFrameRate>${rate.toString('hex')}</MediaFrameRate>`);
       const idm = Buffer.alloc(9);
       idm.writeUInt8(0x02, 0);
       idm.writeDoubleBE((frameCount - 1) / fps, 1);
-      c = c.replace(/<MediaTimemapBA>[0-9a-fA-F]*<\/MediaTimemapBA>/, `<MediaTimemapBA>${idm.toString('hex')}</MediaTimemapBA>`);
+      c = c.replace(/<MediaTimemapBA>[0-9a-fA-F]*<\/MediaTimemapBA>/, () => `<MediaTimemapBA>${idm.toString('hex')}</MediaTimemapBA>`);
       if (cut.audioOnly) {
         // Generic audio-clip FieldsBlob, verbatim from the live A2 harvest.
         // (Video clones keep their blob — repointClipBlobsInXml owns it.)
@@ -125,13 +126,13 @@ async function cutSourceIntoClips(drpInput, opts = {}) {
       // Embedded source timecode base, in SECONDS (harvested with the media
       // template). Donor default 0 makes Resolve seek the wrong TC and fail
       // the render with "Full resolution media not found at <TC>".
-      c = c.replace(/<MediaStartTime>[\s\S]*?<\/MediaStartTime>/, `<MediaStartTime>${cut.mediaStartTime}</MediaStartTime>`);
+      c = c.replace(/<MediaStartTime>[\s\S]*?<\/MediaStartTime>/, () => `<MediaStartTime>${cut.mediaStartTime}</MediaStartTime>`);
     }
     if (cut.timemap) {
       // Constant-speed retime: swap the identity MediaTimemapBA for the
       // caller-built Sm2TimeMap (r19 keyed form render/readback-verified;
       // the clip's <In>/<Duration> are RECORD-domain, measured live).
-      c = c.replace(/<MediaTimemapBA>[0-9a-fA-F]*<\/MediaTimemapBA>/, `<MediaTimemapBA>${cut.timemap}</MediaTimemapBA>`);
+      c = c.replace(/<MediaTimemapBA>[0-9a-fA-F]*<\/MediaTimemapBA>/, () => `<MediaTimemapBA>${cut.timemap}</MediaTimemapBA>`);
     }
     return c;
   };

package/resolve-advanced/vendor/drp-format/media-template-cache.js

@@ -59,11 +59,11 @@ function transplantMediaElement(mpXml, seqXmls, { poolElement, mediaRef }) {
   const folderId = (mpXml.slice(start, end).match(/<MpFolder>([0-9a-f-]{36})<\/MpFolder>/) || [])[1];
   let element = poolElement;
   if (folderId) {
-    element = element.replace(/<MpFolder>[0-9a-f-]{36}<\/MpFolder>/, `<MpFolder>${folderId}</MpFolder>`);
+    element = element.replace(/<MpFolder>[0-9a-f-]{36}<\/MpFolder>/, () => `<MpFolder>${folderId}</MpFolder>`);
   }
   const outMp = mpXml.slice(0, start) + element + mpXml.slice(end);
   const outSeqs = seqXmls.map((seq) =>
-    seq.replace(/<MediaRef>[0-9a-f-]{36}<\/MediaRef>/g, `<MediaRef>${mediaRef}</MediaRef>`),
+    seq.replace(/<MediaRef>[0-9a-f-]{36}<\/MediaRef>/g, () => `<MediaRef>${mediaRef}</MediaRef>`),
   );
   return { mpXml: outMp, seqXmls: outSeqs };
 }
@@ -75,7 +75,7 @@ function insertMediaElement(mpXml, poolElement) {
   const folderId = (mpXml.match(/<Sm2MpVideoClip[^>]*>[\s\S]*?<MpFolder>([0-9a-f-]{36})<\/MpFolder>/) || [])[1];
   let element = poolElement;
   if (folderId) {
-    element = element.replace(/<MpFolder>[0-9a-f-]{36}<\/MpFolder>/, `<MpFolder>${folderId}</MpFolder>`);
+    element = element.replace(/<MpFolder>[0-9a-f-]{36}<\/MpFolder>/, () => `<MpFolder>${folderId}</MpFolder>`);
   }
   return mpXml.slice(0, close) + element + mpXml.slice(close);
 }

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

@@ -72,22 +72,22 @@ async function placeCompound(drpInput, opts = {}) {
   //    the cuts machinery, 0-based frames).
   let inner = fs.readFileSync(T('compound-inner-r19.xml'), 'utf8');
   inner = freshDbIds(inner);
-  inner = inner.replace(/<Sm2SequenceContainer DbId="[^"]+"/, `<Sm2SequenceContainer DbId="${innerContainerId}"`);
-  inner = inner.replace(/<Sequence>[0-9a-f-]{36}<\/Sequence>/g, `<Sequence>${innerSequenceId}</Sequence>`);
+  inner = inner.replace(/<Sm2SequenceContainer DbId="[^"]+"/, () => `<Sm2SequenceContainer DbId="${innerContainerId}"`);
+  inner = inner.replace(/<Sequence>[0-9a-f-]{36}<\/Sequence>/g, () => `<Sequence>${innerSequenceId}</Sequence>`);
   inner = inner.replace(/<Items>[\s\S]*?<\/Items>/g, '<Items/>');
   zip.file(`SeqContainer/${innerContainerId}.xml`, inner);
 
   // 2) Pool compound element: fresh identities + blob SeqRef patch.
   let pool = fs.readFileSync(T('compound-pool-r19.xml'), 'utf8');
-  pool = pool.replace(/<Sm2MpCompoundClip DbId="[^"]+"/, `<Sm2MpCompoundClip DbId="${compoundId}"`);
-  pool = pool.replace(/<Sm2Sequence DbId="[^"]+"/, `<Sm2Sequence DbId="${innerSequenceId}"`);
-  pool = pool.replace(/<UniqueSequenceId>[^<]*<\/UniqueSequenceId>/, `<UniqueSequenceId>${crypto.randomUUID()}</UniqueSequenceId>`);
-  pool = pool.replace(/<UniqueMediaPoolItemId>[^<]*<\/UniqueMediaPoolItemId>/, `<UniqueMediaPoolItemId>${crypto.randomUUID()}</UniqueMediaPoolItemId>`);
-  pool = pool.replace(/<SmPTZRPreset DbId="[^"]+"/, `<SmPTZRPreset DbId="${crypto.randomUUID()}"`);
+  pool = pool.replace(/<Sm2MpCompoundClip DbId="[^"]+"/, () => `<Sm2MpCompoundClip DbId="${compoundId}"`);
+  pool = pool.replace(/<Sm2Sequence DbId="[^"]+"/, () => `<Sm2Sequence DbId="${innerSequenceId}"`);
+  pool = pool.replace(/<UniqueSequenceId>[^<]*<\/UniqueSequenceId>/, () => `<UniqueSequenceId>${crypto.randomUUID()}</UniqueSequenceId>`);
+  pool = pool.replace(/<UniqueMediaPoolItemId>[^<]*<\/UniqueMediaPoolItemId>/, () => `<UniqueMediaPoolItemId>${crypto.randomUUID()}</UniqueMediaPoolItemId>`);
+  pool = pool.replace(/<SmPTZRPreset DbId="[^"]+"/, () => `<SmPTZRPreset DbId="${crypto.randomUUID()}"`);
   // The embedded sequence's <Parent> points BACK at the compound's own id —
   // the reference sweep found it as the one un-rewired link (a dangling
   // Parent is presumably as fatal as the dangling MpFolder/SeqRef were).
-  pool = pool.replace(/<Parent>[0-9a-f-]{36}<\/Parent>/, `<Parent>${compoundId}</Parent>`);
+  pool = pool.replace(/<Parent>[0-9a-f-]{36}<\/Parent>/, () => `<Parent>${compoundId}</Parent>`);
   {
     const fbM = pool.match(/(<Sm2Sequence DbId="[^"]+">\s*<FieldsBlob>)([0-9a-fA-F]+)(<\/FieldsBlob>)/);
     if (!fbM) throw new Error('placeCompound: embedded Sm2Sequence FieldsBlob not found');
@@ -98,12 +98,12 @@ async function placeCompound(drpInput, opts = {}) {
     const patched = encodeKeyedDict({ hdr: dict.hdr, entries: dict.entries }).toString('hex');
     pool = pool.replace(fbM[0], `${fbM[1]}${patched}${fbM[3]}`);
   }
-  pool = pool.replace(/<Name>[^<]*<\/Name>/, `<Name>${escapeXml(name)}</Name>`);
+  pool = pool.replace(/<Name>[^<]*<\/Name>/, () => `<Name>${escapeXml(name)}</Name>`);
   // MediaExtents = [startSec, durationSec] LE doubles; inner starts at 0.
   const me = Buffer.alloc(16);
   me.writeDoubleLE(0, 0);
   me.writeDoubleLE(durationFrames / fps, 8);
-  pool = pool.replace(/<MediaExtents>[0-9a-fA-F]*<\/MediaExtents>/, `<MediaExtents>${me.toString('hex')}</MediaExtents>`);
+  pool = pool.replace(/<MediaExtents>[0-9a-fA-F]*<\/MediaExtents>/, () => `<MediaExtents>${me.toString('hex')}</MediaExtents>`);
   // Attach to the primary MediaPool folder — and point the element's
   // <MpFolder> at THAT folder's DbId (the template's value references the
   // harvest project's folder; a dangling folder ref CRASHES Resolve on
@@ -112,22 +112,22 @@ async function placeCompound(drpInput, opts = {}) {
   let mpXml = await zip.file(mpPath).async('string');
   const folderId = (mpXml.match(/<Sm2MpFolder DbId="([^"]+)"/) || [])[1];
   if (!folderId) throw new Error('placeCompound: target MpFolder has no Sm2MpFolder DbId');
-  pool = pool.replace(/<MpFolder>[0-9a-f-]{36}<\/MpFolder>/, `<MpFolder>${folderId}</MpFolder>`);
-  mpXml = mpXml.replace('</MediaVec>', `${pool}\n  </MediaVec>`);
+  pool = pool.replace(/<MpFolder>[0-9a-f-]{36}<\/MpFolder>/, () => `<MpFolder>${folderId}</MpFolder>`);
+  mpXml = mpXml.replace('</MediaVec>', () => `${pool}\n  </MediaVec>`);
   zip.file(mpPath, mpXml);
 
   // 3) Parent item: template clone → fresh id, name, placement, MediaRef,
   //    identity timemap over the inner content ((frames − 0.5)/fps, measured).
   let item = fs.readFileSync(T('compound-item-r19.xml'), 'utf8').trim();
   item = freshDbIds(item);
-  item = item.replace(/<Name>[^<]*<\/Name>/, `<Name>${escapeXml(name)}</Name>`);
-  item = item.replace(/<Start>\d+<\/Start>/, `<Start>${startFrame}</Start>`);
-  item = item.replace(/<Duration>\d+<\/Duration>/, `<Duration>${durationFrames}</Duration>`);
-  item = item.replace(/<MediaRef>[0-9a-f-]{36}<\/MediaRef>/, `<MediaRef>${compoundId}</MediaRef>`);
+  item = item.replace(/<Name>[^<]*<\/Name>/, () => `<Name>${escapeXml(name)}</Name>`);
+  item = item.replace(/<Start>\d+<\/Start>/, () => `<Start>${startFrame}</Start>`);
+  item = item.replace(/<Duration>\d+<\/Duration>/, () => `<Duration>${durationFrames}</Duration>`);
+  item = item.replace(/<MediaRef>[0-9a-f-]{36}<\/MediaRef>/, () => `<MediaRef>${compoundId}</MediaRef>`);
   const tm = Buffer.alloc(9);
   tm.writeUInt8(0x02, 0);
   tm.writeDoubleBE((durationFrames - 0.5) / fps, 1);
-  item = item.replace(/<MediaTimemapBA>[0-9a-fA-F]*<\/MediaTimemapBA>/, `<MediaTimemapBA>${tm.toString('hex')}</MediaTimemapBA>`);
+  item = item.replace(/<MediaTimemapBA>[0-9a-fA-F]*<\/MediaTimemapBA>/, () => `<MediaTimemapBA>${tm.toString('hex')}</MediaTimemapBA>`);
 
   const { match: vec, tracks } = getTrackVec(parentXml, 'video');
   if (track > tracks.length) throw new Error(`placeCompound: parent video track ${track} does not exist (${tracks.length})`);

package/resolve-advanced/vendor/drp-format/place-fusion-title.js

@@ -96,9 +96,9 @@ async function placeFusionTitle(drpInput, opts = {}) {
     throw new Error('placeFusionTitle: template is not a Fusion Title clip');
   }
   clip = freshDbIds(clip);
-  clip = clip.replace(/<Start>\d+<\/Start>/, `<Start>${startFrame}</Start>`);
-  clip = clip.replace(/<Duration>\d+<\/Duration>/, `<Duration>${durationFrames}</Duration>`);
-  if (name) clip = clip.replace(/<Name>[\s\S]*?<\/Name>/, `<Name>${escapeXml(name)}</Name>`);
+  clip = clip.replace(/<Start>\d+<\/Start>/, () => `<Start>${startFrame}</Start>`);
+  clip = clip.replace(/<Duration>\d+<\/Duration>/, () => `<Duration>${durationFrames}</Duration>`);
+  if (name) clip = clip.replace(/<Name>[\s\S]*?<\/Name>/, () => `<Name>${escapeXml(name)}</Name>`);
   const titleInputs = { text, font, style, size, vJustify, hJustify, color };
   if (Object.values(titleInputs).some((v) => v !== undefined && v !== null)) {
     const m = clip.match(/<CompositionBA>([0-9a-fA-F]*)<\/CompositionBA>/);

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

@@ -75,17 +75,17 @@ async function placeGenerator(drpInput, opts = {}) {
 
   let gen = fs.readFileSync(snippetPathFor(templateVersion), 'utf8').trim();
   gen = freshDbIds(gen);
-  gen = gen.replace(/<PrettyType>[\s\S]*?<\/PrettyType>/, `<PrettyType>${escapeXml(generatorName)}</PrettyType>`);
-  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>`);
+  gen = gen.replace(/<PrettyType>[\s\S]*?<\/PrettyType>/, () => `<PrettyType>${escapeXml(generatorName)}</PrettyType>`);
+  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>`);
+    gen = gen.replace(/<EffectFiltersBA\s*\/>|<EffectFiltersBA>\s*<\/EffectFiltersBA>/, () => `<EffectFiltersBA>${blob}</EffectFiltersBA>`);
   }
 
   const { match: vtv, tracks } = getTrackVec(seqXml, 'video');

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

@@ -94,9 +94,9 @@ async function placeSubtitles(drpInput, opts = {}) {
     '    <UserDefinedName/>\n    <LayersVec/>\n   </Sm2TiTrack>\n  </Element>\n ';
   let xml;
   if (/<SubtitleTrackVec\/>/.test(seqXml)) {
-    xml = seqXml.replace('<SubtitleTrackVec/>', `<SubtitleTrackVec>${track}</SubtitleTrackVec>`);
+    xml = seqXml.replace('<SubtitleTrackVec/>', () => `<SubtitleTrackVec>${track}</SubtitleTrackVec>`);
   } else if (/<SubtitleTrackVec>/.test(seqXml)) {
-    xml = seqXml.replace('</SubtitleTrackVec>', `${track}</SubtitleTrackVec>`);
+    xml = seqXml.replace('</SubtitleTrackVec>', () => `${track}</SubtitleTrackVec>`);
   } else {
     throw new Error('placeSubtitles: timeline has no SubtitleTrackVec');
   }

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

@@ -115,9 +115,9 @@ async function placeTransition(drpInput, opts = {}) {
   let trans = fs.readFileSync(trackType === 'audio' ? AUDIO_TEMPLATE_PATH : TEMPLATE_PATH, 'utf8').trim();
   trans = freshDbIds(trans);
   if (type === 'wipe') {
-    trans = trans.replace(/<FieldsBlob>[0-9a-fA-F]*<\/FieldsBlob>/, `<FieldsBlob>${WIPE_FIELDS_BLOB}</FieldsBlob>`);
+    trans = trans.replace(/<FieldsBlob>[0-9a-fA-F]*<\/FieldsBlob>/, () => `<FieldsBlob>${WIPE_FIELDS_BLOB}</FieldsBlob>`);
   } else if (STYLE_PRETTY_TYPES[type]) {
-    trans = trans.replace(/<PrettyType>Cross Dissolve<\/PrettyType>/, `<PrettyType>${STYLE_PRETTY_TYPES[type]}</PrettyType>`);
+    trans = trans.replace(/<PrettyType>Cross Dissolve<\/PrettyType>/, () => `<PrettyType>${STYLE_PRETTY_TYPES[type]}</PrettyType>`);
   }
   // Span geometry follows <Start>/<Duration>, NOT AlignmentType (the E61
   // harvest of Resolve's own EDL import carries AlignmentType 2 with the
@@ -132,8 +132,8 @@ async function placeTransition(drpInput, opts = {}) {
     }
   }
   const start = spanStart !== undefined ? spanStart : atFrame - Math.floor(durationFrames / 2);
-  trans = trans.replace(/<Start>\d+<\/Start>/, `<Start>${start}</Start>`);
-  trans = trans.replace(/<Duration>\d+<\/Duration>/, `<Duration>${durationFrames}</Duration>`);
+  trans = trans.replace(/<Start>\d+<\/Start>/, () => `<Start>${start}</Start>`);
+  trans = trans.replace(/<Duration>\d+<\/Duration>/, () => `<Duration>${durationFrames}</Duration>`);
   const transitionDbId = (trans.match(/<Sm2TiTransition DbId="([^"]+)"/) || [])[1] || null;
 
   // Insert the transition <Element> immediately after the left clip's <Element> in <Items>.

package/resolve-advanced/vendor/drp-format/seq-surgery.js

@@ -89,7 +89,7 @@ function getItemsInner(trackElement) {
 function setItemsInner(trackElement, inner) {
   const body = inner && inner.trim() ? inner : null;
   if (/<Items\s*\/>/.test(trackElement)) {
-    return body ? trackElement.replace(/<Items\s*\/>/, `<Items>${body}</Items>`) : trackElement;
+    return body ? trackElement.replace(/<Items\s*\/>/, () => `<Items>${body}</Items>`) : trackElement;
   }
   return trackElement.replace(/<Items>[\s\S]*?<\/Items>/, body ? `<Items>${body}</Items>` : '<Items/>');
 }

package/resolve-advanced/vendor/drp-format/splice-clips.js

@@ -37,10 +37,10 @@ function clipDuration(clipXml) {
   return m ? parseInt(m[1], 10) : null;
 }
 function setClipStart(clipXml, v) {
-  return clipXml.replace(/<Start>\d+<\/Start>/, `<Start>${v}</Start>`);
+  return clipXml.replace(/<Start>\d+<\/Start>/, () => `<Start>${v}</Start>`);
 }
 function setClipDuration(clipXml, v) {
-  return clipXml.replace(/<Duration>\d+<\/Duration>/, `<Duration>${v}</Duration>`);
+  return clipXml.replace(/<Duration>\d+<\/Duration>/, () => `<Duration>${v}</Duration>`);
 }
 // The source IN-point lives in <In> as `<framePos>|<LE-double of framePos*0.001>`, where framePos
 // is in TIMELINE frames (verified live: Resolve appended a clip with source-in 600 media-frames @29.97
@@ -143,7 +143,7 @@ async function moveClip(drpInput, opts = {}) {
   // Optionally retime.
   if (toStart !== undefined && toStart !== null) {
     if (!Number.isInteger(toStart)) throw new TypeError('moveClip: toStart must be an integer');
-    clip = clip.replace(/<Start>\d+<\/Start>/, `<Start>${toStart}</Start>`);
+    clip = clip.replace(/<Start>\d+<\/Start>/, () => `<Start>${toStart}</Start>`);
   }
 
   // Grow to the destination track with empty clones, then insert.

package/src/granular/common.py

@@ -92,7 +92,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "4.18.0"
+VERSION = "4.18.1"
 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 377-tool granular server instead
 """
 
-VERSION = "4.18.0"
+VERSION = "4.18.1"
 
 import base64
 import os
@@ -13357,7 +13357,9 @@ def _media_analysis_replace_owned_block(existing: Any, body: Any) -> str:
         + re.escape(_MCP_METADATA_BLOCK_END)
     )
     if re.search(pattern, existing_text, flags=re.DOTALL):
-        return re.sub(pattern, block, existing_text, flags=re.DOTALL).strip()
+        # A function replacement inserts the block literally: as a string, a
+        # backslash in the analysis text (a Windows path) is read as an escape.
+        return re.sub(pattern, lambda _match: block, existing_text, flags=re.DOTALL).strip()
     return f"{existing_text}\n\n{block}".strip() if existing_text else block