davinci-resolve-mcp 2.57.4 → 2.58.0

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

@@ -0,0 +1,133 @@
+'use strict';
+
+/** Package builder + emitters + delivery — client-free (round-trips through own parser). */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const pkgRoot = require('../index');
+const P = require('../packaging');
+const { toOtio, readOtioSourceFrames } = require('../packaging/otio');
+const { toFcp7Xml } = require('../packaging/emit-fcp7');
+const { toAafModel, readAafSourceFrames } = require('../packaging/emit-aaf');
+const { parseGeometry } = require('../parse');
+const oracle = require('../oracle');
+
+const GOLDEN = JSON.parse(fs.readFileSync(path.join(pkgRoot.reelFixtureDir(), 'golden_oracle.json'), 'utf8'));
+
+// A conformed timeline: each clip resolved to its source frame (= expected_source_start).
+const CONFORMED = {
+  sequence: GOLDEN.sequence,
+  ticksPerFrame: GOLDEN.ticksPerFrame,
+  clips: GOLDEN.clips.map((c) => ({
+    cutId: `seq${c.seqstart}`,
+    seqstart: c.seqstart,
+    seqend: c.seqend,
+    sourceFrame: c.expected_source_start,
+    sampleFrame: c.expected_sample_frame != null ? c.expected_sample_frame : c.expected_source_start,
+    scale: c.expected_scale_corrected,
+    source_basename: c.source_basename,
+    srcW: c.srcW,
+    srcH: c.srcH,
+    path: `/vol/online/${c.source_basename}`,
+  })),
+};
+const CTX = { ticksPerFrame: GOLDEN.ticksPerFrame, sequenceWidth: GOLDEN.sequence.width };
+
+test('package: OTIO canonical round-trips conformed source frames (all 327)', () => {
+  const otio = toOtio(CONFORMED);
+  const back = readOtioSourceFrames(otio);
+  assert.equal(back.length, 327);
+  for (let i = 0; i < back.length; i++) assert.equal(back[i].sourceFrame, CONFORMED.clips[i].sourceFrame);
+});
+
+test('package: FCP7 XML emit round-trips through the parser (in+ticks consistent, all 327)', () => {
+  const xml = toFcp7Xml(CONFORMED);
+  const parsed = parseGeometry(xml);
+  const bySeq = new Map(parsed.clips.map((c) => [c.seqstart, c]));
+  let checked = 0;
+  for (const c of CONFORMED.clips) {
+    const pc = bySeq.get(c.seqstart);
+    assert.ok(pc, `emitted clip @${c.seqstart} must re-parse`);
+    // The non-negotiable: <in> and <pproTicksIn> are consistent, so the Oracle
+    // re-derives the SAME source frame from the emitted XML.
+    assert.equal(oracle.derive(pc, CTX).derivedSourceFrame, c.sourceFrame, `@${c.seqstart} round-trip`);
+    checked += 1;
+  }
+  assert.equal(checked, 327);
+});
+
+test('package: AAF model round-trips source frames (binary serialization deferred)', () => {
+  const back = readAafSourceFrames(toAafModel(CONFORMED));
+  assert.equal(back.length, 327);
+  assert.equal(back[0].sourceFrame, CONFORMED.clips[0].sourceFrame);
+});
+
+test('package: builder matrix — subset of formats + relink media mode', () => {
+  const pkg = P.buildPackage(CONFORMED, { mediaMode: 'relink', formats: ['otio', 'fcp7Xml', 'aaf'] });
+  assert.ok(pkg.files.otio && pkg.files.fcp7Xml && pkg.files.aaf);
+  assert.equal(pkg.media.mode, 'relink');
+  assert.equal(pkg.media.copied, false);
+  assert.ok(pkg.media.references.length === 327);
+});
+
+test('package: full/consolidate media modes are BLOCKED (require volumes)', () => {
+  assert.equal(P.buildPackage(CONFORMED, { mediaMode: 'full' }).media.blocked, true);
+  assert.equal(P.buildPackage(CONFORMED, { mediaMode: 'consolidate' }).media.blocked, true);
+});
+
+test('package: V2 flag track + provenance manifest + ConformPackage record', () => {
+  const v2Flags = [{ cutId: 'seq2983', klass: 'wrong-source', note: 'flagged' }];
+  const repairByCut = { seq192: { strategy: 'add-subclip-startoffset', confidence: 1 } };
+  const pkg = P.buildPackage(CONFORMED, { formats: ['otio'], v2Flags, repairByCut });
+  assert.equal(pkg.v2FlagTrack.length, 1);
+  assert.equal(pkg.manifest.clips.length, 327);
+  const m192 = pkg.manifest.clips.find((c) => c.cutId === 'seq192');
+  assert.equal(m192.repairStrategy, 'add-subclip-startoffset');
+  assert.equal(pkg.record.type, 'ConformPackage');
+  assert.equal(pkg.record.v2FlagCount, 1);
+});
+
+test('package: gated auto-apply applies only auto-apply fixes + records undo', () => {
+  const small = { sequence: GOLDEN.sequence, ticksPerFrame: GOLDEN.ticksPerFrame, clips: [
+    { cutId: 'a', seqstart: 0, sourceFrame: 100, scale: 175 },
+    { cutId: 'b', seqstart: 48, sourceFrame: 200, scale: 175 },
+  ] };
+  const repairResults = [
+    { cutId: 'a', repair: { mode: 'auto-apply', strategy: 'normalize-scale', proposal: { fix: { scale: 100 } } } },
+    { cutId: 'b', repair: { mode: 'propose-only', strategy: 'find-true-source', proposal: { fix: { scale: 999 } } } },
+  ];
+  const out = P.applyGatedAutoApply(small, repairResults);
+  assert.equal(out.conformed.clips.find((c) => c.cutId === 'a').scale, 100); // auto-applied
+  assert.equal(out.conformed.clips.find((c) => c.cutId === 'b').scale, 175); // NOT applied (propose-only)
+  assert.equal(out.applied.length, 1);
+  assert.equal(out.undo[0].before.scale, 175); // undo records the prior value
+  assert.equal(out.deferred[0].cutId, 'b');
+});
+
+test('package: delivery to a local folder writes the files', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cqc-pkg-'));
+  try {
+    const pkg = P.buildPackage(CONFORMED, { formats: ['otio', 'fcp7Xml'], v2Flags: [{ cutId: 'x' }] });
+    const written = P.deliverToFolder(pkg, dir);
+    assert.ok(written.some((p) => p.endsWith('conform.otio.json')));
+    assert.ok(written.some((p) => p.endsWith('conform.xml')));
+    assert.ok(written.some((p) => p.endsWith('manifest.json')));
+    assert.ok(fs.existsSync(path.join(dir, 'v2-flags.json')));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('package: delivery to Download Center enqueues keys via injected sink (mock R2)', async () => {
+  const uploaded = {};
+  const enqueue = async (key, content) => { uploaded[key] = content; };
+  const pkg = P.buildPackage(CONFORMED, { formats: ['otio'] });
+  const keys = await P.deliverToDownloadCenter(pkg, { enqueue });
+  assert.ok(keys.includes('conform/otio'));
+  assert.ok(keys.includes('conform/manifest.json'));
+  assert.equal(Object.keys(uploaded).length, keys.length);
+});

package/resolve-advanced/vendor/conform-qc/test/parse-stubs.test.js

@@ -0,0 +1,28 @@
+'use strict';
+
+/**
+ * parse/ contract + format-stub tests. Client-free (no raw material needed).
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const parse = require('../parse');
+
+test('parse: captured-geometry contract is the shared shape (XMEML conforms)', () => {
+  assert.ok(Array.isArray(parse.CAPTURED_CLIP_FIELDS));
+  for (const f of ['seqstart', 'xml_in', 'pproTicksIn', 'is_subclip', 'subclip_startoffset', 'scale_premiere', 'srcW', 'srcH', 'source_basename']) {
+    assert.ok(parse.CAPTURED_CLIP_FIELDS.includes(f), `contract must include "${f}"`);
+  }
+  assert.equal(typeof parse.parseGeometry, 'function');
+});
+
+test('parse: AAF capture is a stub that throws (conforms to interface)', () => {
+  assert.equal(typeof parse.parseGeometryAAF, 'function');
+  assert.throws(() => parse.parseGeometryAAF('<aaf/>'), /AAF geometry capture not implemented/);
+});
+
+test('parse: OTIO capture is a stub that throws (conforms to interface)', () => {
+  assert.equal(typeof parse.parseGeometryOTIO, 'function');
+  assert.throws(() => parse.parseGeometryOTIO('{}'), /OTIO geometry capture not implemented/);
+});

package/resolve-advanced/vendor/conform-qc/test/repair-strategies.test.js

@@ -0,0 +1,128 @@
+'use strict';
+
+/** §9 propose-only strategies, media index, analysis, and P3 acceptance. */
+
+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 S = require('../repair/strategies');
+const { MediaIndex } = require('../repair/media-index');
+const { detectDupes, proposeTimeline } = require('../repair/analysis');
+const { makeRepairLadder } = require('../repair');
+
+const GOLDEN = JSON.parse(fs.readFileSync(path.join(pkg.reelFixtureDir(), 'golden_oracle.json'), 'utf8'));
+const CTX = { ticksPerFrame: GOLDEN.ticksPerFrame, sequenceWidth: GOLDEN.sequence.width, sequenceHeight: GOLDEN.sequence.height, sequenceRate: GOLDEN.sequence.fps };
+
+test('media-index: resolves by basename, reel+TC, and proxy↔original variant', () => {
+  const idx = new MediaIndex([
+    { path: '/vol/scan/Sample S16mm 12R 4K 0821 CR A01-A03.mp4', basename: 'Sample S16mm 12R 4K 0821 CR A01-A03.mp4', reel: 'A001', startTc: '01:00:00:00' },
+    { path: '/vol/other/Decoy.mov', basename: 'Decoy.mov' },
+  ]);
+  assert.equal(idx.byBasename('Decoy.mov'), '/vol/other/Decoy.mov');
+  assert.equal(idx.byReelTc('A001', '01:00:00:00'), '/vol/scan/Sample S16mm 12R 4K 0821 CR A01-A03.mp4');
+  // A proxy name with "4K-2K" resolves to the 4K scan (2k is variant-noise).
+  const found = idx.findTrueSource('Sample S16mm 12R 4K-2K 0821 CR A01-A03.mov');
+  assert.ok(found && found.basename.includes('A01-A03'), `proxy should resolve to the scan: ${JSON.stringify(found)}`);
+});
+
+test('repair: wrong-source uses identity + media index to propose the true source', () => {
+  const idx = new MediaIndex([
+    { path: '/vol/scan/Sample A01-A03.mp4', basename: 'Sample S16mm 12R 4K 0821 CR A01-A03.mp4' },
+    { path: '/vol/scan/Other.mp4', basename: 'Totally Different Clip.mp4' },
+  ]);
+  const cut = { cutId: 'seq2983', verdict: 'WRONG', burnInName: 'Sample S16mm 12R 4K 0821 CR A01-A03.mp4' };
+  assert.equal(S.wrongSource.detect(cut, { mediaIndex: idx }), true);
+  const p = S.wrongSource.propose(cut, { mediaIndex: idx });
+  assert.ok(p.fix && p.fix.source_basename.includes('A01-A03'));
+  assert.ok(p.confidence > 0.5);
+});
+
+test('repair: per-file offset estimated from samples + applied to that file only', () => {
+  const k = S.estimatePerFileOffset([{ derived: 100, matched: 211 }, { derived: 200, matched: 311 }, { derived: 50, matched: 161 }]);
+  assert.equal(k, 111); // constant +111 (the SAMPLE-style per-file offset)
+  const cut = { fileId: 'file-7' };
+  assert.equal(S.perFileOffset.detect(cut, { fileOffsets: { 'file-7': 111 } }), true);
+  assert.equal(S.perFileOffset.propose(cut, { fileOffsets: { 'file-7': 111 } }).fix.sourceFrameDelta, 111);
+  // A noisy sample set (no majority constant) => no offset.
+  assert.equal(S.estimatePerFileOffset([{ derived: 1, matched: 2 }, { derived: 1, matched: 9 }, { derived: 1, matched: 40 }]), null);
+});
+
+test('repair: measured residual patches ONLY measured clips (non-negotiable #4)', () => {
+  const cut = { cutId: 'c1', measuredOffset: { dx: 4, dy: -2 } };
+  assert.equal(S.measuredResidual.detect(cut), true);
+  assert.deepEqual(S.measuredResidual.propose(cut).fix.positionPatch, { dx: -4, dy: 2, ds: 0 });
+  // applyMeasuredPatches leaves unmeasured cuts untouched.
+  const out = S.applyMeasuredPatches([{ cutId: 'a' }, { cutId: 'b' }], { a: { dx: 3, dy: 0 } });
+  assert.equal(out.find((x) => x.cutId === 'a').patched, true);
+  assert.equal(out.find((x) => x.cutId === 'b').patched, false);
+});
+
+test('repair: aspect-variant, mixed-framerate, handle-shortfall, missing-media', () => {
+  // Aspect: a 4:3 source in a 16:9 sequence.
+  assert.equal(S.aspectVariant.detect({ srcW: 1440, srcH: 1080 }, CTX), true);
+  assert.equal(S.aspectVariant.detect({ srcW: 2048, srcH: 1306 }, CTX), false); // S16mm 1.568 vs 5:3 seq — fit by scale, not a reframe
+  // Mixed rate.
+  const mr = S.mixedFrameRate.propose({ sourceFrame: 100, clipRate: 48 }, { sequenceRate: 24 });
+  assert.equal(mr.fix.sourceFrame, 200);
+  // Handle shortfall near media end.
+  assert.equal(S.handleShortfall.detect({ mediaLength: 100, usedOut: 98, usedIn: 90, handles: 12 }), true);
+  assert.equal(S.handleShortfall.propose({ mediaLength: 100, usedOut: 98, usedIn: 90, handles: 12 }).fix.handlesTail, 2);
+  // Missing media: no index match, no burn-in.
+  assert.equal(S.missingMedia.detect({ pathMissing: true, source_basename: 'Gone.mov' }, {}), true);
+});
+
+test('repair: reel-name conform resolves reel+TC', () => {
+  const idx = new MediaIndex([{ path: '/vol/A001.mov', basename: 'A001.mov', reel: 'A001', startTc: '01:00:00:00' }]);
+  const cut = { reel: 'A001', sourceTc: '01:00:00:00' };
+  assert.equal(S.reelNameConform.detect(cut, { mediaIndex: idx }), true);
+  assert.equal(S.reelNameConform.propose(cut, { mediaIndex: idx }).fix.path, '/vol/A001.mov');
+});
+
+test('check: dupes — repeated-source clusters reported, uniques not flagged', () => {
+  const dupes = detectDupes(GOLDEN.clips);
+  assert.ok(dupes.length > 0, 'SAMPLE reel reuses sources');
+  for (const d of dupes) assert.ok(d.count > 1);
+  // A reel of all-unique sources reports nothing.
+  assert.deepEqual(detectDupes([{ cutId: 1, source_basename: 'a' }, { cutId: 2, source_basename: 'b' }]), []);
+});
+
+test('propose-timeline: auto-applied fixes vs V2 flag track (V1 gap per flag)', () => {
+  const results = [
+    { cutId: 'c1', seqstart: 0, repair: { mode: 'auto-apply', strategy: 'normalize-scale', proposal: { fix: { scale: 100 } } } },
+    { cutId: 'c2', seqstart: 48, repair: { mode: 'propose-only', klass: 'wrong-source', diagnosis: 'needs review', proposal: { fix: { path: '/x' } } } },
+    { cutId: 'c3', seqstart: 96, repair: { mode: 'flag-v2', klass: 'unrepairable', diagnosis: 'offline' } },
+  ];
+  const out = proposeTimeline(results);
+  assert.equal(out.summary.autoApplied, 1);
+  assert.equal(out.summary.flagged, 2);
+  assert.equal(out.correctedTimeline.find((c) => c.cutId === 'c1').v1Gap, false);
+  assert.equal(out.correctedTimeline.find((c) => c.cutId === 'c2').v1Gap, true);
+  assert.equal(out.v2Flags.length, 2);
+});
+
+test('P3 ACCEPTANCE: broken SAMPLE variant — correct fixes proposed, only irreducible flagged', async () => {
+  const ladder = makeRepairLadder({});
+  // The "broken variant": all 327 clips carry un-normalized scale (the v3 scale mistake).
+  const results = [];
+  for (const c of GOLDEN.clips) {
+    const rep = await ladder.repair({ ...c, cutId: `seq${c.seqstart}` }, CTX);
+    results.push({ cutId: `seq${c.seqstart}`, seqstart: c.seqstart, expected: c.expected_scale_corrected, repair: rep });
+  }
+  // Every scale-broken clip auto-applies to the correct normalized scale.
+  for (const r of results) {
+    assert.equal(r.repair.mode, 'auto-apply', `@${r.seqstart} should auto-apply`);
+    assert.ok(Math.abs(r.repair.proposal.fix.scale - r.expected) < 0.001);
+  }
+  // Add one genuinely-wrong, no-true-source cut: it must flag, not auto-fix.
+  const wrong = await ladder.repair({ cutId: 'seqWRONG', verdict: 'WRONG', pathMissing: true, source_basename: 'Lost.mov', is_subclip: false, xml_in: 0, pproTicksIn: 0, scale_premiere: 100, srcW: CTX.sequenceWidth }, CTX);
+  results.push({ cutId: 'seqWRONG', seqstart: -1, repair: wrong });
+  const proposed = proposeTimeline(results);
+  assert.equal(proposed.summary.autoApplied, 327);
+  assert.equal(proposed.summary.flagged, 1);
+  assert.equal(proposed.v2Flags[0].cutId, 'seqWRONG');
+  // eslint-disable-next-line no-console
+  console.log(`[P3] ACCEPTANCE: 327 auto-fixed (scale normalized) + 1 irreducible flagged to V2`);
+});

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

@@ -0,0 +1,84 @@
+'use strict';
+
+/** Repair ladder + §9 deterministic strategies — verified against golden_oracle. */
+
+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 { makeRepairLadder, strategies } = require('../repair');
+const { ConformKnowledge } = require('../knowledge');
+
+const GOLDEN = JSON.parse(fs.readFileSync(path.join(pkg.reelFixtureDir(), 'golden_oracle.json'), 'utf8'));
+const CTX = { ticksPerFrame: GOLDEN.ticksPerFrame, sequenceWidth: GOLDEN.sequence.width };
+
+test('repair: scale-double-count normalizes per source width for all 327 (== expected)', () => {
+  let checked = 0;
+  for (const c of GOLDEN.clips) {
+    assert.equal(strategies.scaleDoubleCount.detect(c, CTX), true, `@${c.seqstart} should detect double-count`);
+    const p = strategies.scaleDoubleCount.propose(c, CTX);
+    assert.ok(Math.abs(p.fix.scale - c.expected_scale_corrected) < 0.001, `@${c.seqstart} ${p.fix.scale} != ${c.expected_scale_corrected}`);
+    checked += 1;
+  }
+  assert.equal(checked, 327);
+});
+
+test('repair: subclip-offset reproduces source_start for subclip clips', () => {
+  const subs = GOLDEN.clips.filter((c) => c.is_subclip);
+  assert.ok(subs.length > 0);
+  for (const c of subs) {
+    assert.equal(strategies.subclipOffset.detect(c), true);
+    assert.equal(strategies.subclipOffset.propose(c).fix.sourceFrame, c.expected_source_start);
+  }
+});
+
+test('repair: ticks-retime detects only retimes and derives the ticks sample frame', () => {
+  const retimes = GOLDEN.clips.filter((c) => strategies.ticksRetime.detect(c, CTX));
+  assert.ok(retimes.length >= 1 && retimes.length < GOLDEN.clips.length, 'some but not all clips are retimes');
+  for (const c of retimes) {
+    const p = strategies.ticksRetime.propose(c, CTX);
+    assert.equal(p.fix.sampleFrame, Math.round(c.pproTicksIn / CTX.ticksPerFrame));
+    assert.notEqual(p.fix.sampleFrame, c.xml_in); // ticks != in for a retime
+  }
+});
+
+test('repair: stale-relink re-resolves by exact basename via the media index', () => {
+  const mediaIndex = { byBasename: (n) => (n === 'A.mov' ? '/vol/online/A.mov' : null) };
+  const cut = { source_basename: 'A.mov', pathMissing: true };
+  assert.equal(strategies.staleRelink.detect(cut, { mediaIndex }), true);
+  assert.equal(strategies.staleRelink.propose(cut, { mediaIndex }).fix.path, '/vol/online/A.mov');
+  // No match => no fix.
+  const miss = strategies.staleRelink.propose({ source_basename: 'Z.mov', pathMissing: true }, { mediaIndex });
+  assert.equal(miss.fix, null);
+});
+
+test('repair ladder: auto-applies a deterministic fix and records to ConformKnowledge', async () => {
+  const knowledge = new ConformKnowledge();
+  const ladder = makeRepairLadder({ knowledge });
+  // A subclip cut with scale already normalized (so subclip is the matching strategy).
+  const cut = { cutId: 'c1', is_subclip: true, subclip_startoffset: 5146, xml_in: 406, pproTicksIn: 406 * CTX.ticksPerFrame, scale_premiere: 100, srcW: CTX.sequenceWidth };
+  const res = await ladder.repair(cut, CTX);
+  assert.equal(res.klass, 'subclip-offset');
+  assert.equal(res.accepted, true);
+  assert.equal(res.mode, 'auto-apply');
+  assert.equal(res.proposal.fix.sourceFrame, 5552); // 5146 + 406
+  assert.ok(knowledge.query({ class: 'subclip-offset' }).confidence > 0.5);
+});
+
+test('repair ladder: an unmatched cut flags to V2', async () => {
+  const ladder = makeRepairLadder({});
+  const clean = { cutId: 'ok', is_subclip: false, xml_in: 1000, pproTicksIn: 1000 * CTX.ticksPerFrame, scale_premiere: 100, srcW: CTX.sequenceWidth };
+  const res = await ladder.repair(clean, CTX);
+  assert.equal(res.mode, 'flag-v2');
+  assert.equal(res.klass, 'unrepairable');
+});
+
+test('repair ladder: re-verify can reject a deterministic fix (propose -> auto-rejected)', async () => {
+  const ladder = makeRepairLadder({ reverify: async () => ({ ok: false, confidence: 0.2 }) });
+  const cut = { cutId: 'c', is_subclip: true, subclip_startoffset: 100, xml_in: 5, pproTicksIn: 5 * CTX.ticksPerFrame, scale_premiere: 100, srcW: CTX.sequenceWidth };
+  const res = await ladder.repair(cut, CTX);
+  assert.equal(res.accepted, false, 'a fix that fails re-verify must not auto-apply');
+  assert.equal(res.mode, 'auto-rejected');
+});

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

@@ -0,0 +1,52 @@
+'use strict';
+
+/** QC report model tests — client-free. */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { makeReport, addCut, badgeFor, toMetadataQc } = require('../report');
+
+test('report: summary tallies per-cut verdicts', () => {
+  const r = makeReport({ target: 'resolve', tier: 'B' });
+  addCut(r, { cutId: 'c1', status: 'MATCH', hasReference: true, refScore: 0.99 });
+  addCut(r, { cutId: 'c2', status: 'OFFSET', hasReference: true, refScore: 0.95, offset: { dx: 2, dy: 0, ds: 0 } });
+  addCut(r, { cutId: 'c3', status: 'WRONG', hasReference: true, refScore: 0.4 });
+  addCut(r, { cutId: 'c4', status: 'REVIEW', hasReference: true, escalated: true });
+  addCut(r, { cutId: 'c5', status: 'MATH-VERIFIED', hasReference: false, derivedSourceFrame: 1000 });
+  assert.deepEqual(r.summary, { matched: 1, offset: 1, wrong: 1, flagged: 2, review: 1, mathVerified: 1, unreadable: 0 });
+  assert.equal(r.perCut.length, 5);
+});
+
+test('report: BADGE RULE — no picture, no content-verified', () => {
+  // Tier C (no reference) can only be math-verified, never content-verified.
+  assert.equal(badgeFor({ status: 'MATH-VERIFIED', hasReference: false }), 'math-verified');
+  assert.equal(badgeFor({ status: 'MATCH', hasReference: false }), 'math-verified');
+  // With a reference + MATCH => content-verified.
+  assert.equal(badgeFor({ status: 'MATCH', hasReference: true }), 'content-verified');
+  // A reference that did NOT verify => no positive badge.
+  assert.equal(badgeFor({ status: 'WRONG', hasReference: true }), null);
+  assert.equal(badgeFor({ status: 'REVIEW', hasReference: true }), null);
+  // The guard hard-fails any attempt to mint content-verified without a picture.
+  const r = makeReport();
+  const entry = addCut(r, { cutId: 'x', status: 'MATH-VERIFIED', hasReference: false });
+  assert.equal(entry.badge, 'math-verified');
+});
+
+test('report: unknown status is rejected', () => {
+  const r = makeReport();
+  assert.throws(() => addCut(r, { cutId: 'bad', status: 'PROBABLY', hasReference: true }), /unknown status/);
+});
+
+test('report: serializes to the metadata.editorial.qc shape (§11)', () => {
+  const r = makeReport({ target: 'resolve', oracleVersion: '1', tier: 'C', runAt: '2026-06-16T00:00:00Z' });
+  addCut(r, { cutId: 'seq192', status: 'MATH-VERIFIED', hasReference: false, derivedSourceFrame: 47962, scale: 100 });
+  const m = toMetadataQc(r);
+  for (const k of ['runAt', 'target', 'oracleVersion', 'tier', 'summary', 'perCut', 'packageKeys']) {
+    assert.ok(k in m, `metadata.editorial.qc must have "${k}"`);
+  }
+  assert.equal(m.perCut[0].cutId, 'seq192');
+  assert.equal(m.perCut[0].derivedFrame, 47962);
+  assert.equal(m.perCut[0].badge, 'math-verified');
+  assert.equal(m.summary.mathVerified, 1);
+});

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

@@ -0,0 +1,71 @@
+'use strict';
+
+/**
+ * P2 — Resolve-in-the-loop, verified against the REAL tool (non-negotiable #1).
+ *
+ * Gated on a reachable headless Resolve AND the raw turnover.xml (git-ignored).
+ * Imports the SAMPLE turnover headless (media OFFLINE), reads back each clip's
+ * conformed source_start via GetLeftOffset, and asserts it equals the Oracle for
+ * all 327 — the calibration that PROVES the Oracle ruleset. Then exports a DRP
+ * and re-opens it.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const pkg = require('../index');
+const oracle = require('../oracle');
+const { isResolveDriver } = require('../adapters/resolve-driver');
+const { HeadlessResolveDriver } = require('../adapters/resolve-headless-driver');
+
+const SAMPLE = pkg.reelFixtureDir();
+const XML = path.join(SAMPLE, 'turnover.xml');
+const GOLDEN = JSON.parse(fs.readFileSync(path.join(SAMPLE, 'golden_oracle.json'), 'utf8'));
+const CTX = { ticksPerFrame: GOLDEN.ticksPerFrame, sequenceWidth: GOLDEN.sequence.width };
+
+const driver = new HeadlessResolveDriver();
+const resolveUp = !!driver.ping();
+const haveXml = fs.existsSync(XML);
+const SKIP = resolveUp && haveXml ? false : `Resolve ${resolveUp ? 'up' : 'unreachable'} / turnover ${haveXml ? 'present' : 'absent'} — skipping P2`;
+
+test('P2: HeadlessResolveDriver satisfies the ResolveDriver interface', () => {
+  assert.equal(isResolveDriver(driver), true);
+});
+
+test('P2 read-back + ACCEPTANCE: Resolve clip_where == Oracle for all 327 (offline import)', { skip: SKIP }, async () => {
+  await driver.importTimeline(XML);
+  const rows = await driver.clipWhere();
+  const bySeq = new Map(rows.map((r) => [r.seqstart, r]));
+
+  let checked = 0;
+  const mismatches = [];
+  for (const c of GOLDEN.clips) {
+    const row = bySeq.get(c.seqstart);
+    assert.ok(row, `Resolve read-back missing clip @seq${c.seqstart}`);
+    const oracleSrc = oracle.derive(c, CTX).derivedSourceFrame;
+    // The real tool == the golden == the Oracle.
+    if (row.source_start !== c.expected_source_start || oracleSrc !== row.source_start) {
+      mismatches.push({ seq: c.seqstart, resolve: row.source_start, golden: c.expected_source_start, oracle: oracleSrc });
+    }
+    checked += 1;
+  }
+  assert.equal(checked, 327);
+  assert.deepEqual(mismatches, [], `Oracle-vs-Resolve mismatches: ${JSON.stringify(mismatches.slice(0, 5))}`);
+  // eslint-disable-next-line no-console
+  console.log(`[P2] CALIBRATION: Resolve clip_where == Oracle for 327/327 (headless, media offline)`);
+}, { timeout: 180000 });
+
+test('P2 DRP export: import -> export .drp -> re-open clean', { skip: SKIP }, async () => {
+  const out = path.join(os.tmpdir(), `conformqc_${process.pid}.drp`);
+  try {
+    const res = await driver.authorDrp(XML, out);
+    assert.ok(res.drpPath, 'a .drp path is returned');
+    assert.equal(res.validArchive, true, 'the exported .drp is a well-formed archive');
+    assert.ok(res.entryCount > 0 && res.size > 0, 'the .drp is non-trivial');
+  } finally {
+    fs.rmSync(out, { force: true });
+  }
+}, { timeout: 180000 });

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

@@ -0,0 +1,107 @@
+'use strict';
+
+/** P5 roles/§10 resolution + trigger model + agent toolset + geometry merge-dto. */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const R = require('../roles');
+const trigger = require('../ops/trigger');
+const toolset = require('../toolset');
+const { mergeGeometry } = require('../parse/merge-dto');
+
+test('roles: editorialRole enum + a version carries a role and serializes', () => {
+  assert.ok(R.EDITORIAL_ROLES.includes('finishing'));
+  assert.equal(R.isValidRole('proxy'), true);
+  assert.equal(R.isValidRole('bogus'), false);
+  const version = { id: 'v1', width: 4096, editorialRole: 'finishing' };
+  assert.equal(JSON.parse(JSON.stringify(version)).editorialRole, 'finishing');
+});
+
+test('roles: MediaRelationship (proxy↔scan, frameOffset) persists + is queryable', () => {
+  const store = new R.MediaRelationshipStore();
+  store.add({ fromAssetId: 'proxyA', toAssetId: 'scanA', kind: 'scan_of', frameOffset: 111, notes: 'SAMPLE proxy->scan' });
+  const got = store.forAsset('proxyA');
+  assert.equal(got.length, 1);
+  assert.equal(got[0].kind, 'scan_of');
+  assert.equal(got[0].frameOffset, 111);
+  assert.throws(() => R.makeMediaRelationship({ fromAssetId: 'a', toAssetId: 'b', kind: 'nope' }), /kind must be one of/);
+});
+
+test('roles: resolution order — relationship > override > role > naming > highest-res', () => {
+  const ref = {
+    assetId: 'proxyA',
+    versions: [
+      { name: 'X 4K-2K.mov', width: 2048, path: '/proxy.mov' },
+      { name: 'X 4K.mov', width: 4096, path: '/scan-named.mov', role: 'finishing' },
+    ],
+  };
+  const relStore = new R.MediaRelationshipStore([{ fromAssetId: 'proxyA', toAssetId: 'scanAsset', kind: 'scan_of', frameOffset: 111 }]);
+  const resolveAssetPath = (id) => (id === 'scanAsset' ? '/vol/scan/X.mov' : null);
+
+  // 1. relationship wins.
+  let r = R.resolveMedia(ref, { relationships: relStore, resolveAssetPath, projectOverride: { proxyA: '/override.mov' } });
+  assert.equal(r.via, 'relationship');
+  assert.equal(r.path, '/vol/scan/X.mov');
+  assert.equal(r.frameOffset, 111);
+  // 2. no relationship => project override wins.
+  r = R.resolveMedia(ref, { projectOverride: { proxyA: '/override.mov' } });
+  assert.equal(r.via, 'project-override');
+  // 3. no override => version role (finishing).
+  r = R.resolveMedia(ref, {});
+  assert.equal(r.via, 'role');
+  assert.equal(r.path, '/scan-named.mov');
+  // 4. no role => naming (4K not 4K-2K).
+  const noRole = { assetId: 'p', versions: [{ name: 'X 4K-2K.mov', width: 2048, path: '/p.mov' }, { name: 'X 4K.mov', width: 4096, path: '/s.mov' }] };
+  assert.equal(R.resolveMedia(noRole, {}).via, 'naming');
+  // 5. nothing distinctive => highest-res.
+  const plain = { assetId: 'p', versions: [{ name: 'a', width: 1920, path: '/a' }, { name: 'b', width: 3840, path: '/b' }] };
+  const top = R.resolveMedia(plain, {});
+  assert.equal(top.via, 'highest-res');
+  assert.equal(top.path, '/b');
+});
+
+test('roles: ingest heuristic seeds proxy role + proxy↔scan relationship', () => {
+  const seeded = R.ingestHeuristic({ id: 'proxyA', name: 'Sample 4K-2K 0508.mov', width: 2048 }, { finishingAssetId: 'scanA', frameOffset: 111 });
+  assert.equal(seeded.role, 'proxy');
+  assert.equal(seeded.relationship.kind, 'scan_of');
+  assert.equal(seeded.relationship.toAssetId, 'scanA');
+  assert.equal(R.ingestHeuristic({ id: 's', name: 'Sample 4K 0821.mp4', width: 4096 }).role, 'finishing');
+});
+
+test('trigger: auto Tier-C on sidecar upload vs full conform on-demand', () => {
+  const up = trigger.onSidecarUpload();
+  assert.equal(up.trigger, 'auto-on-upload');
+  assert.equal(up.tier, 'C');
+  assert.equal(up.badge, 'math-verified');
+  const conform = trigger.onConformAction({ surface: 'cloud' });
+  assert.equal(conform.trigger, 'on-demand');
+  assert.equal(conform.runsOn, 'render-node');
+  assert.equal(trigger.onConformAction({ surface: 'local' }).runsOn, 'post-assistant');
+});
+
+test('toolset: agent-callable tool schemas validate + dispatch round-trips to verify', async () => {
+  assert.ok(toolset.TOOLS.length >= 2);
+  for (const t of toolset.TOOLS) {
+    assert.ok(t.name && t.description && t.input_schema);
+    assert.match(t.description, /deterministic|advisory/i, 'tool desc must state verdicts are deterministic / vision advisory');
+  }
+  // dispatch round-trips to an injected verify (no real engine needed for the binding).
+  let got = null;
+  await toolset.dispatch('conform_qc_verify', { model: { sequence: {}, clips: [] } }, { verify: async (m) => { got = m; return { ok: true }; } });
+  assert.ok(got);
+  await assert.rejects(() => toolset.dispatch('nope', {}), /unknown tool/);
+});
+
+test('parse: geometry merge-dto is additive behind a flag (base unchanged when off)', () => {
+  const dto = [{ seqstart: 0, name: 'a' }, { seqstart: 48, name: 'b' }];
+  const geo = [{ seqstart: 0, pproTicksIn: 123, scale_premiere: 100 }];
+  // Flag off: returns the SAME array (untouched).
+  assert.equal(mergeGeometry(dto, geo, { attach: false }), dto);
+  // Flag on: geometry attached by seqstart; base fields intact.
+  const merged = mergeGeometry(dto, geo, { attach: true });
+  assert.notEqual(merged, dto);
+  assert.equal(merged[0].name, 'a');
+  assert.equal(merged[0].conformGeometry.pproTicksIn, 123);
+  assert.equal(merged[1].conformGeometry, undefined); // no geometry for seq48
+});

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

@@ -0,0 +1,30 @@
+'use strict';
+
+/** Operator runbook content check (P5-docs-runbook) — documents every closed decision. */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DOC = fs.readFileSync(path.join(__dirname, '..', 'docs', 'runbook.md'), 'utf8');
+
+test('runbook: documents both surfaces, tiers, package options, and the closed decisions', () => {
+  const must = [
+    /two surfaces/i,
+    /Cloud/, /Local/,
+    /A — burned reference/i, /B — clean ref/i, /C — no reference/i, /math-verified/,
+    /no picture, no `?content-verified/i,
+    /brightness/i,
+    /ADVISORY ONLY/i,
+    /never.*(clear a flag|flip a deterministic)/i,
+    /host-injected `?VisionValidator|supplied by the host/i, // optional vision seam, no bundled LLM
+    /SSIM ≥ 0\.90|PSNR ≥ 25/,
+    /VFX alignment \*\*never\*\* auto-applies|VFX alignment never/i,
+    /MediaRelationship.*→.*project override.*→.*editorialRole|resolution/i, // §10 order
+    /OTIO is the internal canonical/i,
+    /<in>.*<pproTicksIn>.*consistent|Resolve reads ticks/i,
+    /trigger model/i,
+  ];
+  for (const re of must) assert.match(DOC, re, `runbook must document: ${re}`);
+});