davinci-resolve-mcp 2.57.4 → 2.58.0

package/resolve-advanced/vendor/conform-qc/test/metrics-fast.test.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * Fixture-free checks for the fast (coarse→fine) search paths in compare/metrics:
+ *  - findOffset's pyramid path returns the SAME peak as an exhaustive brute force,
+ *  - coarseToFinePeak finds a 1D peak with far fewer evaluations than a linear scan.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const Mx = require('../compare/metrics');
+
+const W = 160;
+const H = 120;
+
+// A textured image (not separable, so shifts are unambiguous): mixed frequencies.
+function texture(w, h) {
+  const d = new Float64Array(w * h);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      d[y * w + x] = 0.5 +
+        0.25 * Math.sin(x * 0.21 + y * 0.07) +
+        0.15 * Math.cos(x * 0.05 - y * 0.17) +
+        0.08 * Math.sin((x + y) * 0.33);
+    }
+  }
+  return d;
+}
+
+// Shift src by (sx, sy) into a w×h buffer (out-of-bounds -> 0).
+function shifted(src, w, h, sx, sy) {
+  const d = new Float64Array(w * h);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const ox = x - sx;
+      const oy = y - sy;
+      d[y * w + x] = ox >= 0 && ox < w && oy >= 0 && oy < h ? src[oy * w + ox] : 0;
+    }
+  }
+  return d;
+}
+
+test('findOffset pyramid path equals exhaustive brute force', () => {
+  const a = texture(W, H);
+  for (const [sx, sy] of [[20, -14], [-31, 25], [0, 0], [44, 7]]) {
+    const b = shifted(a, W, H, sx, sy);
+    const maxShift = 50; // > 16 -> exercises the pyramid path
+    // Reference: exhaustive window search at full res.
+    const brute = Mx.searchShiftWindow(a, b, null, W, H, -maxShift, maxShift, -maxShift, maxShift);
+    const fast = Mx.findOffset(a, b, null, W, H, maxShift);
+    assert.equal(fast.dx, brute.dx, `dx mismatch for shift (${sx},${sy})`);
+    assert.equal(fast.dy, brute.dy, `dy mismatch for shift (${sx},${sy})`);
+    // structureAtShift re-aligns b by (dx,dy), so b = a shifted by (sx,sy) peaks at (-sx,-sy).
+    assert.equal(fast.dx, -sx || 0); // || 0 normalizes the -0 case
+    assert.equal(fast.dy, -sy || 0);
+  }
+});
+
+test('small maxShift stays exact brute force (unchanged behaviour)', () => {
+  const a = texture(W, H);
+  const b = shifted(a, W, H, 5, -3);
+  const fast = Mx.findOffset(a, b, null, W, H, 12);
+  const brute = Mx.searchShiftWindow(a, b, null, W, H, -12, 12, -12, 12);
+  assert.equal(fast.dx, brute.dx);
+  assert.equal(fast.dy, brute.dy);
+  assert.equal(fast.dx, -5);
+  assert.equal(fast.dy, 3);
+});
+
+test('coarseToFinePeak finds the peak with fewer evals than a linear scan', async () => {
+  const lo = 0;
+  const hi = 300;
+  const peak = 211;
+  let calls = 0;
+  const scoreAt = (x) => { calls += 1; return -Math.abs(x - peak); }; // unimodal
+  const r = await Mx.coarseToFinePeak(scoreAt, lo, hi, 8);
+  assert.equal(r.x, peak);
+  assert.ok(r.evals < hi - lo, `expected sub-linear evals, got ${r.evals}`);
+  assert.ok(calls <= 70, `expected ~50 evals, got ${calls}`);
+});
+
+test('downsample averages and halves/quarters dimensions', () => {
+  const a = texture(W, H);
+  const d = Mx.downsample(a, W, H, 4);
+  assert.equal(d.width, 40);
+  assert.equal(d.height, 30);
+  // A flat region averages to itself.
+  const flat = new Float64Array(16).fill(0.5);
+  const df = Mx.downsample(flat, 4, 4, 2);
+  for (const v of df.data) assert.ok(Math.abs(v - 0.5) < 1e-9);
+});

package/resolve-advanced/vendor/conform-qc/test/oracle-reverse.test.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+ * Reversed-clip source-frame derivation — fixture-free (synthetic inputs only),
+ * so it runs on any machine without the golden answer key.
+ *
+ * The rule under test: a reversed clip anchors its range at the END of its
+ * available source media and mirrors in/out about that end, rather than growing
+ * downward from the start. This is fully derivable from the XML (in/out,
+ * endoffset) plus the source media's frame count — no reference render needed.
+ *
+ *   forward subclip:  source_start = startoffset + in
+ *   reversed subclip: source_start = (masterFrames - 1 - endoffset) - in
+ *
+ * The forward path used to be applied to reversed clips too, landing the frame at
+ * the wrong (mirrored) position. Values below are validated against a live
+ * Resolve readback (get_source_start/end_frame).
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const resolve = require('../oracle/resolve');
+
+const TPF = 254016000000 / 24; // ticks/frame @24
+
+test('reversed subclip end-anchors its range', () => {
+  const ctx = { ticksPerFrame: TPF, masterFrames: 47849 };
+  const rev = {
+    xml_in: 589,
+    xml_out: 604,
+    pproTicksIn: 589 * TPF,
+    is_subclip: true,
+    subclip_startoffset: 34727,
+    subclip_endoffset: 11832,
+    reverse: true,
+  };
+  // source_start = (masterFrames - 1 - endoffset) - in = 47849 - 1 - 11832 - 589
+  // = 35427 (Resolve's get_source_start_frame), NOT the forward start-anchor
+  // 34727 + 589 = 35316, nor the out-anchored/off-by-one 35413.
+  assert.equal(resolve.deriveSourceFrame(rev, ctx), 35427);
+  assert.equal(resolve.deriveSampleFrame(rev, ctx), 35427);
+});
+
+test('forward subclip with identical offsets still start-anchors', () => {
+  const ctx = { ticksPerFrame: TPF, masterFrames: 47849 };
+  const fwd = {
+    xml_in: 589,
+    xml_out: 604,
+    pproTicksIn: 589 * TPF,
+    is_subclip: true,
+    subclip_startoffset: 34727,
+    subclip_endoffset: 11832,
+    reverse: false,
+  };
+  assert.equal(resolve.deriveSourceFrame(fwd, ctx), 34727 + 589); // 35316
+});
+
+test('full-master reverse (no subclip): (masterFrames - 1) - in', () => {
+  const fullRev = {
+    xml_in: 100,
+    xml_out: 250,
+    pproTicksIn: 100 * TPF,
+    is_subclip: false,
+    reverse: true,
+    master_frames: 1000, // per-source override (clip-level) when ctx has none
+  };
+  // (1000 - 1 - 0) - 100 = 899
+  assert.equal(resolve.deriveSourceFrame(fullRev, { ticksPerFrame: TPF }), 899);
+});
+
+test('reverse without any frame count fails loudly (no silent start-anchor)', () => {
+  const rev = {
+    xml_in: 589,
+    xml_out: 604,
+    pproTicksIn: 589 * TPF,
+    is_subclip: true,
+    subclip_startoffset: 34727,
+    subclip_endoffset: 11832,
+    reverse: true,
+  };
+  assert.throws(
+    () => resolve.deriveSourceFrame(rev, { ticksPerFrame: TPF }),
+    /needs a source frame count/,
+  );
+});

package/resolve-advanced/vendor/conform-qc/test/oracle.test.js

@@ -0,0 +1,136 @@
+'use strict';
+
+/**
+ * Oracle tests — verified END-TO-END against the committed golden answer key
+ * (golden_oracle.json: 327 SAMPLE clips, each with input fields + the
+ * expected_source_start that Resolve's clip_where actually produced).
+ *
+ * No raw XML or frames needed — golden_oracle.json embeds the inputs, so these
+ * run client-free on any machine.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const pkg = require('../index');
+const oracle = require('../oracle');
+const resolveTarget = require('../oracle/resolve');
+
+const GOLDEN = JSON.parse(
+  fs.readFileSync(path.join(pkg.reelFixtureDir(), 'golden_oracle.json'), 'utf8'),
+);
+const COMPARE = JSON.parse(
+  fs.readFileSync(path.join(pkg.reelFixtureDir(), 'golden_compare.json'), 'utf8'),
+);
+const CTX = { ticksPerFrame: GOLDEN.ticksPerFrame, sequenceWidth: GOLDEN.sequence.width };
+
+test('Oracle (resolve): source_start for all PLAIN (non-subclip) clips', () => {
+  const plain = GOLDEN.clips.filter((c) => !c.is_subclip);
+  assert.ok(plain.length > 0, 'fixture must contain non-subclip clips');
+  let checked = 0;
+  for (const c of plain) {
+    const { derivedSourceFrame } = resolveTarget.derive(c, CTX);
+    assert.equal(
+      derivedSourceFrame,
+      c.expected_source_start,
+      `plain clip @seq${c.seqstart} (${c.source_basename}): derived ${derivedSourceFrame} != expected ${c.expected_source_start}`,
+    );
+    checked += 1;
+  }
+  // eslint-disable-next-line no-console
+  console.log(`[oracle] plain clips verified: ${checked}/${plain.length}`);
+});
+
+test('Oracle (resolve): source_start for all SUBCLIP clips (startoffset + in)', () => {
+  const subs = GOLDEN.clips.filter((c) => c.is_subclip);
+  assert.ok(subs.length > 0, 'fixture must contain subclip clips (pickups)');
+  for (const c of subs) {
+    const { derivedSourceFrame } = resolveTarget.derive(c, CTX);
+    assert.equal(
+      derivedSourceFrame,
+      c.expected_source_start,
+      `subclip @seq${c.seqstart} (${c.source_basename}): derived ${derivedSourceFrame} != expected ${c.expected_source_start} (startoffset ${c.subclip_startoffset} + in ${c.xml_in})`,
+    );
+    // The subclip offset must actually participate (don't rewrite <in>).
+    assert.equal(derivedSourceFrame, (c.subclip_startoffset || 0) + c.xml_in);
+  }
+  // eslint-disable-next-line no-console
+  console.log(`[oracle] subclip clips verified: ${subs.length}`);
+});
+
+test('Oracle (resolve): ACCEPTANCE — source_start for ALL 327 clips, zero mismatches', () => {
+  assert.equal(GOLDEN.clips.length, 327);
+  const mismatches = [];
+  for (const c of GOLDEN.clips) {
+    const { derivedSourceFrame } = resolveTarget.derive(c, CTX);
+    if (derivedSourceFrame !== c.expected_source_start) {
+      mismatches.push({ seq: c.seqstart, derived: derivedSourceFrame, expected: c.expected_source_start });
+    }
+  }
+  assert.deepEqual(mismatches, [], `expected 0 source_start mismatches, got ${mismatches.length}`);
+  // eslint-disable-next-line no-console
+  console.log(`[oracle] ACCEPTANCE: 327/327 source_start reproduced (0 mismatches)`);
+});
+
+test('Oracle (pluggable target): registry resolves "resolve" and errors on unknown', () => {
+  assert.equal(oracle.DEFAULT_TARGET, 'resolve');
+  assert.equal(oracle.getTarget('resolve').id, 'resolve');
+  assert.throws(() => oracle.getTarget('premiere'), /unknown target "premiere"/);
+  // Deriving via the registry must match the direct ruleset for all 327 clips.
+  for (const c of GOLDEN.clips) {
+    const viaRegistry = oracle.derive(c, CTX);
+    const direct = resolveTarget.derive(c, CTX);
+    assert.deepEqual(viaRegistry, direct, `registry vs direct mismatch @seq${c.seqstart}`);
+  }
+  // eslint-disable-next-line no-console
+  console.log('[oracle] pluggable target: registry == direct for 327/327');
+});
+
+test('Oracle (resolve): corrected scale (double-count fix) for ALL 327, ±0.001', () => {
+  const mismatches = [];
+  for (const c of GOLDEN.clips) {
+    const { derivedScaleCorrected } = resolveTarget.derive(c, CTX);
+    if (Math.abs(derivedScaleCorrected - c.expected_scale_corrected) > 0.001) {
+      mismatches.push({ seq: c.seqstart, derived: derivedScaleCorrected, expected: c.expected_scale_corrected });
+    }
+  }
+  assert.deepEqual(mismatches, [], `expected 0 scale mismatches (±0.001), got ${mismatches.length}: ${JSON.stringify(mismatches.slice(0, 5))}`);
+  // eslint-disable-next-line no-console
+  console.log(`[oracle] corrected scale: 327/327 within ±0.001`);
+});
+
+test('Oracle (resolve): slow-mo via ticks — sample frame ~2*in, readback = in', () => {
+  // The retimed clips: ticks/tpf diverges from <in> (50% slow-mo => ~2*in).
+  const retimes = GOLDEN.clips.filter((c) => resolveTarget.isRetimed(c, CTX));
+  assert.ok(retimes.length >= 1, 'fixture must contain at least one retimed clip');
+  for (const c of retimes) {
+    const out = resolveTarget.derive(c, CTX);
+    // Readback (golden_oracle): Resolve reports the speed-adjusted media-in (= in).
+    assert.equal(out.derivedSourceFrame, c.expected_source_start);
+    assert.equal(out.derivedSourceFrame, c.xml_in);
+    // Sample frame (the ticks path) is ~2x the in-frame for a 50% retime.
+    const ratio = out.derivedSampleFrame / c.xml_in;
+    assert.ok(ratio > 1.5 && ratio < 2.5, `retime @seq${c.seqstart} sample/in ratio ${ratio} not ~2`);
+  }
+
+  // Cross-check the named golden_compare slow-mo case (seqstart 7894): its
+  // documented derived_source_frame (the sampled frame) must match the Oracle's
+  // ticks-based sample frame within 1 frame (golden labels 2*in; ticks/tpf is
+  // exact and lands within a frame of it).
+  const sm = COMPARE.cases.find((x) => x.label === 'slowmo_via_ticks');
+  const clip = GOLDEN.clips.find((x) => x.seqstart === sm.seqstart);
+  assert.ok(clip, 'golden_oracle must contain the slowmo_via_ticks seqstart');
+  const out = resolveTarget.derive(clip, CTX);
+  assert.ok(
+    Math.abs(out.derivedSampleFrame - sm.derived_source_frame) <= 1,
+    `sample frame ${out.derivedSampleFrame} not within 1 of golden_compare ${sm.derived_source_frame}`,
+  );
+  assert.equal(out.retimed, true);
+  // eslint-disable-next-line no-console
+  console.log(
+    `[oracle] retimes verified: ${retimes.length}; slowmo seq${sm.seqstart} ` +
+      `sample=${out.derivedSampleFrame} (golden ${sm.derived_source_frame}), readback=${out.derivedSourceFrame}`,
+  );
+});

package/resolve-advanced/vendor/conform-qc/test/p0-acceptance.test.js

@@ -0,0 +1,60 @@
+'use strict';
+
+/**
+ * P0 ACCEPTANCE (spec §13 P0): on the SAMPLE reel, the Oracle reproduces Resolve's
+ * source_start for all 327 cuts AND the comparator classifies the known matches /
+ * the 1 genuine wrong correctly.
+ *
+ * The Oracle half runs client-free from golden_oracle.json (all 327). The
+ * comparator half runs on the 4 representative golden_compare pairs (incl. the
+ * 1 genuine WRONG = seq2983) and SKIPS-IF-ABSENT — the full-reel 326-match/1-wrong
+ * sweep needs every reference frame (Tier-2/volumes), out of scope for Tier 1.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const pkg = require('../index');
+const oracle = require('../oracle');
+const compare = require('../compare');
+
+const DIR = pkg.reelFixtureDir();
+const GOLDEN = JSON.parse(fs.readFileSync(path.join(DIR, 'golden_oracle.json'), 'utf8'));
+const COMPARE = JSON.parse(fs.readFileSync(path.join(DIR, 'golden_compare.json'), 'utf8'));
+const CTX = { ticksPerFrame: GOLDEN.ticksPerFrame, sequenceWidth: GOLDEN.sequence.width };
+
+const FRAMES = path.join(DIR, 'frames');
+const HAVE_FRAMES = fs.existsSync(FRAMES) && fs.readdirSync(FRAMES).some((f) => f.endsWith('.png'));
+
+test('P0 ACCEPTANCE (Oracle half): source_start + corrected scale for all 327', () => {
+  let srcMismatch = 0;
+  let scaleMismatch = 0;
+  for (const c of GOLDEN.clips) {
+    const out = oracle.derive(c, CTX);
+    if (out.derivedSourceFrame !== c.expected_source_start) srcMismatch += 1;
+    if (Math.abs(out.derivedScaleCorrected - c.expected_scale_corrected) > 0.001) scaleMismatch += 1;
+  }
+  assert.equal(srcMismatch, 0, `${srcMismatch} source_start mismatches`);
+  assert.equal(scaleMismatch, 0, `${scaleMismatch} scale mismatches`);
+  // eslint-disable-next-line no-console
+  console.log('[P0] ACCEPTANCE Oracle: 327/327 source_start + 327/327 scale');
+});
+
+test('P0 ACCEPTANCE (comparator half): the 1 genuine WRONG and the matches classify correctly', { skip: HAVE_FRAMES ? false : 'frames/ absent — skipping comparator half' }, async () => {
+  const verdicts = {};
+  for (const c of COMPARE.cases) {
+    const out = await compare.compareFrames(path.join(DIR, c.reference), path.join(DIR, c.derived));
+    verdicts[c.label] = out.verdict;
+    assert.equal(out.verdict, c.expected_verdict, `${c.label}: ${out.verdict} != ${c.expected_verdict}`);
+  }
+  // The genuine wrong (seq2983, 111 frames off) MUST be WRONG; the rest MATCH.
+  assert.equal(verdicts.genuine_wrong, 'WRONG');
+  const matches = Object.values(verdicts).filter((v) => v === 'MATCH').length;
+  const wrongs = Object.values(verdicts).filter((v) => v === 'WRONG').length;
+  assert.equal(matches, 3);
+  assert.equal(wrongs, 1);
+  // eslint-disable-next-line no-console
+  console.log(`[P0] ACCEPTANCE comparator: ${matches} MATCH / ${wrongs} WRONG (representative golden set)`);
+});

package/resolve-advanced/vendor/conform-qc/test/p1-acceptance.test.js

@@ -0,0 +1,75 @@
+'use strict';
+
+/**
+ * P1 ACCEPTANCE (spec §13 P1): run the verify pass on the SAMPLE reel and get a
+ * per-cut report matching the manual finding — the dark cut MATCHes, the slow-mo
+ * (via ticks) is correct, and the one genuine wrong is flagged.
+ *
+ * Runs on the 4 representative golden_compare cuts (the manual finding's
+ * exemplars) via the verify pipeline end-to-end. SKIPS-IF-ABSENT (frames are
+ * git-ignored). The full-reel 326/1 sweep needs every reference frame
+ * (Tier-2/volumes), out of Tier-1 scope.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const pkg = require('../index');
+const { verify } = require('../ops/verify');
+
+const SAMPLE = pkg.reelFixtureDir();
+const GOLDEN = JSON.parse(fs.readFileSync(path.join(SAMPLE, 'golden_oracle.json'), 'utf8'));
+const COMPARE = JSON.parse(fs.readFileSync(path.join(SAMPLE, 'golden_compare.json'), 'utf8'));
+const FRAMES = path.join(SAMPLE, 'frames');
+const HAVE_FRAMES = fs.existsSync(FRAMES) && fs.readdirSync(FRAMES).some((f) => f.endsWith('.png'));
+const SKIP = HAVE_FRAMES ? false : 'frames/ absent (git-ignored) — skipping P1 acceptance';
+
+const TPF = GOLDEN.ticksPerFrame;
+
+// Build a small "reel" model from the golden_compare exemplars. Oracle inputs are
+// synthesized consistently from each case's derived_source_frame so the pipeline
+// runs intact (the Oracle is separately verified on all 327 in oracle.test.js).
+function modelFromCompare() {
+  return {
+    sequence: GOLDEN.sequence,
+    ticksPerFrame: TPF,
+    clips: COMPARE.cases.map((c) => ({
+      seqstart: c.seqstart,
+      label: c.label,
+      xml_in: c.derived_source_frame,
+      pproTicksIn: c.derived_source_frame * TPF,
+      is_subclip: false,
+      subclip_startoffset: 0,
+      scale_premiere: 100,
+      srcW: GOLDEN.sequence.width,
+      srcH: GOLDEN.sequence.height,
+    })),
+  };
+}
+
+test('P1 ACCEPTANCE: verify report matches the manual finding on the golden reel', { skip: SKIP }, async () => {
+  const model = modelFromCompare();
+  const byLabel = Object.fromEntries(COMPARE.cases.map((c) => [c.seqstart, c]));
+  const referenceProvider = (clip) => {
+    const c = byLabel[clip.seqstart];
+    return { referencePath: path.join(SAMPLE, c.reference), derivedPath: path.join(SAMPLE, c.derived), tier: 'A', label: c.label };
+  };
+
+  const rep = await verify(model, { referenceProvider, target: 'resolve' });
+
+  const verdictBySeq = Object.fromEntries(rep.perCut.map((c) => [c.seqstart, c.status]));
+  for (const c of COMPARE.cases) {
+    assert.equal(verdictBySeq[c.seqstart], c.expected_verdict, `${c.label}: ${verdictBySeq[c.seqstart]} != ${c.expected_verdict}`);
+  }
+  // The manual finding, explicitly: dark grade MATCHes, slow-mo correct, 1 wrong.
+  assert.equal(rep.summary.matched, 3);
+  assert.equal(rep.summary.wrong, 1);
+  // Tier A with a MATCH => content-verified badge (we had a picture).
+  const dark = rep.perCut.find((c) => c.seqstart === 25748);
+  assert.equal(dark.status, 'MATCH');
+  assert.equal(dark.badge, 'content-verified');
+  // eslint-disable-next-line no-console
+  console.log(`[P1] ACCEPTANCE: ${rep.summary.matched} MATCH / ${rep.summary.wrong} WRONG (dark-grade MATCH, slow-mo correct)`);
+});

package/resolve-advanced/vendor/conform-qc/test/p45-patch-acceptance.test.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * P4.5 ACCEPTANCE (patch / re-cut half) — on the real SAMPLE reel: ingest a
+ * revised turnover that changes exactly two cuts (one source swap, one duration
+ * change) and assert the lifecycle re-conforms ONLY the changed cuts, leaves the
+ * other 325 untouched, re-derives the changed cuts correctly (Oracle), and
+ * ripples the downstream record positions by the duration delta.
+ *
+ * Pure (Oracle math + diff; no media), so it runs anywhere. The VFX/Topaz insert
+ * half of the umbrella P4.5-acceptance still needs real render artifacts.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const pkg = require('../index');
+const oracle = require('../oracle');
+const { diffTimelines, reverifyChanged, rippleUpdate } = require('../ops/patch');
+
+const GOLDEN = JSON.parse(fs.readFileSync(path.join(pkg.reelFixtureDir(), 'golden_oracle.json'), 'utf8'));
+const CTX = { ticksPerFrame: GOLDEN.ticksPerFrame, sequenceWidth: GOLDEN.sequence.width };
+
+// CURRENT online: the 327 conformed cuts (sourceFrame = the Oracle/clip_where frame).
+const sorted = [...GOLDEN.clips].sort((a, b) => a.seqstart - b.seqstart);
+const CURRENT = sorted.map((c) => ({ ...c, sourceFrame: c.expected_source_start }));
+
+test('P4.5 ACCEPTANCE (patch): a revised cut re-conforms ONLY changed cuts, ripples downstream', async () => {
+  // Pick two real cuts to edit: a duration change early in the reel (so it has
+  // downstream neighbours to ripple) and a source swap later.
+  const durIdx = 40;
+  const swapIdx = 120;
+  const durSeq = CURRENT[durIdx].seqstart;
+  const swapSeq = CURRENT[swapIdx].seqstart;
+  // A donor cut with a genuinely different source for the swap.
+  const donor = CURRENT.find((c) => c.source_basename !== CURRENT[swapIdx].source_basename);
+  assert.ok(donor, 'a donor with a different source exists');
+
+  const DELTA = 12;
+  const REVISED = CURRENT.map((c) => {
+    if (c.seqstart === durSeq) {
+      // Duration change only (same source) → changed + drives ripple.
+      return { ...c, seqend: c.seqend + DELTA };
+    }
+    if (c.seqstart === swapSeq) {
+      // Source swap: graft the donor's source + Oracle inputs onto this slot,
+      // keeping the original record position/duration (a content replacement).
+      return {
+        ...donor,
+        seqstart: c.seqstart,
+        seqend: c.seqend,
+        source_basename: donor.source_basename,
+        sourceFrame: donor.expected_source_start,
+      };
+    }
+    return c;
+  });
+
+  // 1) DIFF — exactly the two edited cuts are flagged; the rest are unchanged.
+  const d = diffTimelines(CURRENT, REVISED);
+  assert.equal(d.added.length, 0);
+  assert.equal(d.removed.length, 0);
+  assert.equal(d.changed.length, 2, `expected 2 changed, got ${d.changed.map((x) => x.seqstart)}`);
+  assert.equal(d.unchanged.length, 325);
+  const changedSeqs = d.changed.map((x) => x.seqstart).sort((a, b) => a - b);
+  assert.deepEqual(changedSeqs, [durSeq, swapSeq].sort((a, b) => a - b));
+
+  // 2) RE-VERIFY — only changed cuts are re-conformed; the 325 unchanged are skipped.
+  const reconformed = [];
+  const out = await reverifyChanged(d, async (cut) => {
+    const derived = oracle.derive(cut, CTX).derivedSourceFrame;
+    reconformed.push({ seqstart: cut.seqstart, derived });
+    return 'MATCH';
+  });
+  assert.equal(out.skipped, 325);
+  assert.equal(out.reverified.length, 2);
+  assert.deepEqual(reconformed.map((r) => r.seqstart).sort((a, b) => a - b), changedSeqs);
+  // The swapped cut re-derives to the DONOR's source frame (the re-conform is correct,
+  // not a stale carry-over of the old cut's frame).
+  const swapReconform = reconformed.find((r) => r.seqstart === swapSeq);
+  assert.equal(swapReconform.derived, donor.expected_source_start, 'swapped cut re-derived to the new source frame');
+
+  // 3) RIPPLE — the +DELTA duration shifts every downstream cut by DELTA; the
+  //    changed cut + its neighbour are marked touched.
+  const { rippled, touched, totalShift } = rippleUpdate(CURRENT, d);
+  assert.equal(totalShift, DELTA, `total downstream shift should equal the duration delta (${DELTA})`);
+  const durOrdinal = sorted.findIndex((c) => c.seqstart === durSeq);
+  // rippleUpdate preserves the sorted order; verify by ordinal: downstream shifts, upstream doesn't.
+  rippled.forEach((r, i) => {
+    if (i > durOrdinal) {
+      assert.equal(r.seqstart, sorted[i].seqstart + DELTA, `downstream cut #${i} must shift by ${DELTA}`);
+    } else if (i < durOrdinal) {
+      assert.equal(r.seqstart, sorted[i].seqstart, `upstream cut #${i} must not move`);
+    }
+  });
+  assert.ok(touched.includes(durSeq), 'the duration-changed cut is touched');
+
+  // eslint-disable-next-line no-console
+  console.log(`[P4.5] PATCH ACCEPTANCE: revised SAMPLE reel → 2/327 cuts re-conformed (swap@${swapSeq}, dur@${durSeq}), 325 skipped, downstream rippled +${DELTA}.`);
+});