primocode 10.17.1 → 10.19.0

package/vendor/motioncraft/scripts/lib/music.mjs

@@ -0,0 +1,162 @@
+// Music engine: arranges a calm-with-punch instrumental from a small JSON spec.
+import * as D from './dsp.mjs';
+import * as V from './voices.mjs';
+const { SR } = D;
+
+// Proven progressions grouped by mood. [scale degree semitones from key, chord quality]
+export const PROGRESSIONS = {
+  'warm-lift':   { mood: ['warm', 'optimistic'], chords: [[0, 'maj7'], [4, 'm7'], [5, 'maj7'], [7, 'sus']] },
+  'dreamy':      { mood: ['dreamy', 'calm'], chords: [[9, 'm7'], [5, 'maj7'], [0, 'add9'], [7, 'sus']] },
+  'soft-pop':    { mood: ['bright', 'friendly'], chords: [[0, 'add9'], [7, 'sus'], [9, 'm7'], [5, 'maj7']] },
+  'night-drive': { mood: ['cool', 'focused'], chords: [[9, 'm7'], [7, '7sus'], [5, 'maj7'], [4, 'm7']] },
+  'hopeful':     { mood: ['hopeful', 'cinematic'], chords: [[5, 'maj7'], [7, 'sus'], [9, 'm7'], [0, 'add9']] },
+  'lofi-desk':   { mood: ['lofi', 'cozy'], chords: [[2, 'm9'], [7, '9'], [0, 'maj9'], [9, 'm7']] },
+  'minimal-dark':{ mood: ['serious', 'dark'], chords: [[9, 'm9'], [5, 'maj7'], [2, 'm7'], [4, 'm7']] },
+  'tech-bright': { mood: ['tech', 'energetic'], chords: [[0, 'add9'], [9, 'm7'], [5, 'add9'], [7, 'sus']] },
+};
+const Q = { maj7: [0, 4, 7, 11], m7: [0, 3, 7, 10], sus: [0, 5, 7, 10], '7sus': [0, 5, 7, 10], '7': [0, 4, 7, 10], add9: [0, 4, 7, 14], m9: [0, 3, 7, 10, 14], maj9: [0, 4, 7, 11, 14], '9': [0, 4, 7, 10, 14], m: [0, 3, 7], maj: [0, 4, 7] };
+
+// Presets: every knob in one place. Guardrails live in validateSpec().
+export const PRESETS = {
+  'calm-punch':   { bpm: 102, key: 'F', progression: 'warm-lift', swing: 0.57, lead: 'marimba', comp: 'syncopated', drums: 'soft', brightness: 1.0, levels: {} },
+  'dreamy':       { bpm: 93, key: 'D', progression: 'dreamy', swing: 0.62, lead: 'marimba', comp: 'syncopated', drums: 'soft', brightness: 0.85, levels: { bell: -9, keys: -6, pad: -9, hats: -7 } },
+  'warm-major':   { bpm: 98, key: 'G', progression: 'soft-pop', swing: 0.55, lead: 'glock', comp: 'offbeat', drums: 'soft', brightness: 1.0, levels: {} },
+  'lofi-desk':    { bpm: 84, key: 'Eb', progression: 'lofi-desk', swing: 0.64, lead: 'pluck', comp: 'lazy', drums: 'lofi', brightness: 0.7, levels: { hats: -9 } },
+  'tech-bright':  { bpm: 112, key: 'A', progression: 'tech-bright', swing: 0.52, lead: 'pluck', comp: 'eighths', drums: 'tight', brightness: 1.15, levels: {} },
+  'dark-minimal': { bpm: 90, key: 'C', progression: 'minimal-dark', swing: 0.54, lead: 'glock', comp: 'sustain', drums: 'soft', brightness: 0.75, levels: { bell: -10 } },
+  'cinematic-soft': { bpm: 88, key: 'Bb', progression: 'hopeful', swing: 0.5, lead: 'glock', comp: 'sustain', drums: 'sparse', brightness: 0.9, levels: { pad: -7 } },
+};
+const MOOD_BPM = { calm: [80, 96], 'calm-punch': [90, 105], energetic: [105, 122] };
+
+const COMP = {
+  syncopated: [[0, 3], [3, 2], [6, 3], [10, 2], [12, 3]],
+  offbeat: [[2, 2], [6, 2], [10, 2], [14, 2]],
+  lazy: [[0, 5], [7, 3], [11, 5]],
+  eighths: [[0, 2], [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2], [14, 2]],
+  sustain: [[0, 16]],
+};
+const DRUMS = {
+  soft:   { kick: [0, 8], kickMain: [7], kickOdd: [10], hats: 2, snare: true, shaker: true },
+  tight:  { kick: [0, 8], kickMain: [6, 11], kickOdd: [10], hats: 1, snare: true, shaker: false },
+  lofi:   { kick: [0, 7], kickMain: [10], kickOdd: [], hats: 2, snare: true, shaker: false },
+  sparse: { kick: [0], kickMain: [8], kickOdd: [], hats: 4, snare: false, shaker: false },
+};
+
+export function resolveSpec(spec) {
+  const base = PRESETS[spec.preset || 'calm-punch'] || PRESETS['calm-punch'];
+  const s = { ...base, ...spec, levels: { ...base.levels, ...(spec.levels || {}) } };
+  if (!s.chords) s.chords = (PROGRESSIONS[s.progression] || PROGRESSIONS['warm-lift']).chords;
+  s.seed = s.seed ?? 7;
+  return s;
+}
+
+export function validateSpec(s) {
+  const issues = [];
+  if (s.bpm < 70 || s.bpm > 128) issues.push(`bpm ${s.bpm} is outside 70-128; calm-with-punch lives at 88-108`);
+  if (s.swing < 0.5 || s.swing > 0.68) issues.push(`swing ${s.swing} should be 0.50-0.68`);
+  if (D.NOTE[s.key] == null) issues.push(`unknown key ${s.key}`);
+  for (const [, q] of s.chords) if (!Q[q]) issues.push(`unknown chord quality ${q}`);
+  if (!COMP[s.comp]) issues.push(`comp must be one of ${Object.keys(COMP).join(', ')}`);
+  if (!DRUMS[s.drums]) issues.push(`drums must be one of ${Object.keys(DRUMS).join(', ')}`);
+  if (s.lead && !['marimba', 'glock', 'pluck', 'none'].includes(s.lead)) issues.push('lead must be marimba, glock, pluck or none');
+  return issues;
+}
+
+// Variety rule: a new track must differ from the last one on at least 2 of key, bpm (>=6), progression, lead.
+export function varietyCheck(s, last) {
+  if (!last) return { ok: true, diffs: 4 };
+  let d = 0; const why = [];
+  if (s.key !== last.key) d++; else why.push('same key');
+  if (Math.abs(s.bpm - last.bpm) >= 6) d++; else why.push('bpm within 6');
+  if (JSON.stringify(s.chords) !== JSON.stringify(last.chords)) d++; else why.push('same progression');
+  if (s.lead !== last.lead) d++; else why.push('same lead');
+  return { ok: d >= 2, diffs: d, why };
+}
+
+// Auto arrangement from duration + drop time
+export function autoSections(dur, drop, bpm, tail = 2.5) {
+  const bar = 240 / bpm; const total = Math.max(4, Math.round((dur - tail) / bar));
+  let dropBar = drop != null ? Math.round(drop / bar) : Math.min(4, Math.floor(total / 3));
+  dropBar = Math.max(1, Math.min(dropBar, total - 3));
+  const intro = Math.min(2, dropBar), groove = dropBar - intro, outro = Math.min(3, Math.max(1, Math.round(total * 0.12)));
+  const rest = total - dropBar - outro; const secs = [{ type: 'intro', bars: intro }];
+  if (groove) secs.push({ type: 'groove', bars: groove });
+  if (rest >= 9) { const m1 = Math.ceil((rest - 2) / 2); secs.push({ type: 'main', bars: m1 }, { type: 'breakdown', bars: 2 }, { type: 'main', bars: rest - 2 - m1 }); }
+  else secs.push({ type: 'main', bars: Math.max(1, rest) });
+  secs.push({ type: 'outro', bars: outro });
+  return secs.filter((x) => x.bars > 0);
+}
+
+export function renderMusic(input) {
+  const s = resolveSpec(input); D.setSeed(s.seed);
+  const key = D.NOTE[s.key], beat = 60 / s.bpm, bar = beat * 4, six = beat / 4, swing = s.swing;
+  const sections = s.sections || autoSections(s.duration || 60, s.drop, s.bpm, s.tail ?? 2.5);
+  const totalBars = sections.reduce((a, x) => a + x.bars, 0);
+  const dur = totalBars * bar + (s.tail ?? 2.5), n = Math.round(dur * SR);
+  const T = Object.fromEntries(['kick', 'bass', 'snare', 'hats', 'keys', 'pad', 'bell', 'fx'].map((k) => [k, D.stereo(n)]));
+  const swingT = (st) => Math.floor(st / 2) * (beat / 2) + (st % 2) * (beat / 2) * swing;
+  const K = { snap: V.snap(), clap: V.clap(), hat: V.hat(), hatO: V.hat(true), shaker: V.shaker() };
+  const dr = DRUMS[s.drums]; const kicks = []; const markers = []; let bar0 = 0;
+  const comp = COMP[s.comp];
+  sections.forEach((sec, si) => {
+    const name = sec.type; markers.push({ section: name, start_s: +(bar0 * bar).toFixed(4), bars: sec.bars });
+    for (let b = 0; b < sec.bars; b++) {
+      const t0 = (bar0 + b) * bar; const [r, q] = s.chords[(bar0 + b) % s.chords.length]; const pc = (key + r) % 12;
+      const voic = Q[q].map((iv) => { const m = 48 + pc + iv; return m >= 53 ? m : m + 12; });
+      const bassM = pc < 8 ? 36 + pc : 24 + pc; const drums = name === 'groove' || name === 'main'; const last = b === sec.bars - 1;
+      let pat = name === 'outro' ? [[0, 16]] : name === 'intro' ? [[0, 6], [6, 4], [10, 6]] : comp;
+      for (const [p, L] of pat) for (const m of voic) D.place(T.keys, V.epNote(m, L * six * 1.1, 0.55, s.brightness), t0 + swingT(p), 0.3);
+      D.place(T.pad, V.supersaw(voic, bar * 1.1, { bright: 1600 * s.brightness }), t0, 0.22);
+      if (['groove', 'main', 'breakdown'].includes(name)) {
+        const bl = name === 'breakdown' ? [[0, 16]] : [[0, 6], [6, 4], [10, 6]];
+        for (const [p, L] of bl) D.place(T.bass, V.roundBass(D.midiHz(bassM), L * six * 0.95), t0 + swingT(p), 0.7);
+        if (drums && b % 2 === 1) D.place(T.bass, V.roundBass(D.midiHz(bassM + 7), six * 1.8), t0 + swingT(14), 0.5);
+      }
+      if (drums) {
+        const kp = [...dr.kick, ...(name === 'main' ? dr.kickMain : []), ...(b % 2 ? dr.kickOdd : [])];
+        for (const p of kp) { D.place(T.kick, V.softKick(), t0 + swingT(p), 0.9); kicks.push(t0 + swingT(p)); }
+        if (dr.snare) for (const qn of [1, 3]) { D.place(T.snare, K.snap, t0 + qn * beat, 0.45); D.place(T.snare, K.clap, t0 + qn * beat + 0.006, 0.2); }
+        for (let p = 0; p < 16; p += dr.hats) D.place(T.hats, K.hat, t0 + swingT(p), p % 4 ? 0.16 : 0.22, 0.15);
+        if (name === 'main' && dr.shaker) for (let p = 1; p < 16; p += 2) D.place(T.hats, K.shaker, t0 + swingT(p), 0.07, -0.2);
+        if (last && si + 1 < sections.length) for (const p of [12, 13, 14, 15]) D.place(T.snare, K.snap, t0 + swingT(p), 0.12 + 0.05 * (p - 12));
+      }
+      if (name === 'main' && s.lead !== 'none') {
+        const mel = b % 2 === 0 ? [[0, 12], [3, 14], [6, 16], [10, 19]] : [[0, 17], [4, 16], [6, 14], [8, 12], [12, 11]];
+        for (const [p, iv] of mel) { const m = 60 + ((key + iv) % 24) + (key + iv < 12 ? 12 : 0);
+          const v = s.lead === 'glock' ? V.glock(m + 12, 1.0, 0.5) : s.lead === 'pluck' ? V.pluck(m, 0.7, 0.55) : V.marimba(m, 0.9);
+          D.place(T.bell, v, t0 + swingT(p), 0.35, (p % 3 - 1) * 0.25); }
+      }
+    }
+    const nxt = sections[si + 1]?.type; const endT = (bar0 + sec.bars) * bar;
+    if ((nxt === 'groove' || nxt === 'main') && (name === 'intro' || name === 'breakdown')) {
+      const [nr, nq] = s.chords[(bar0 + sec.bars) % s.chords.length]; const npc = (key + nr) % 12;
+      const sw = V.swell(bar * 0.9, Q[nq].map((iv) => (48 + npc + iv >= 53 ? 48 + npc + iv : 60 + npc + iv)));
+      D.place(T.fx, sw, endT - sw.L.length / SR, 0.25);
+      D.place(T.fx, D.filt(V.hat(true), 'lp', 7000), endT, 0.3);
+    }
+    bar0 += sec.bars;
+  });
+  const chain = {
+    kick: (x) => D.compress(D.filt(x, 'lowshelf', 70, 0.707, 2), -14, 3, 3, 80),
+    bass: (x) => D.compress(D.filt(x, 'lp', 1500), -16, 3, 8, 100),
+    snare: (x) => D.withReverb(D.compress(D.filt(x, 'hp', 300), -18, 2.5, 3, 100), 0.35, 0.6, 0.2, 0.85),
+    hats: (x) => D.filt(D.filt(x, 'hp', 6000), 'lp', 14000),
+    keys: (x) => D.withReverb(D.compress(D.chorus(D.filt(D.filt(x, 'hp', 150), 'lp', 6500 * s.brightness), 0.9, 3, 0.35), -18, 2, 10, 150), 0.45, 0.5, 0.18, 0.85),
+    pad: (x) => D.withReverb(D.filt(x, 'hp', 200), 0.8, 0.5, 0.35, 0.7),
+    bell: (x) => D.withReverb(D.delay(D.filt(x, 'hp', 300), beat * 0.75, 0.3, 0.2), 0.5, 0.5, 0.25, 0.8),
+    fx: (x) => D.withReverb(D.filt(x, 'hp', 150), 0.7, 0.5, 0.3, 0.8),
+  };
+  const levels = { kick: -2, bass: -3, snare: -3, hats: -6, keys: -8, pad: -11, bell: -5, fx: -9, ...s.levels };
+  const sc = new Float32Array(n).fill(1); const rel = Math.round(beat * 0.4 * SR);
+  for (const kt of kicks) { const i = Math.round(kt * SR); for (let k = 0; k < rel && i + k < n; k++) { const v = 1 - (1 - D.db(-3)) * Math.pow(1 - k / rel, 1.5); if (v < sc[i + k]) sc[i + k] = v; } }
+  const stems = {}; const mix = D.stereo(n);
+  for (const [k, x] of Object.entries(T)) { let y = D.peak(x) > 0 ? chain[k](x) : x; D.gain(y, D.db(levels[k]));
+    if (['bass', 'keys', 'pad'].includes(k)) for (let i = 0; i < n; i++) { y.L[i] *= sc[i]; y.R[i] *= sc[i]; }
+    stems[k] = y; D.mixInto(mix, y); }
+  const secGain = { intro: 1.5, breakdown: -1.0 };
+  for (const m of markers) if (secGain[m.section] != null) { const a = Math.round(m.start_s * SR), L = Math.round(m.bars * bar * SR), g = D.db(secGain[m.section]), r = Math.min(Math.round(0.08 * SR), L >> 2);
+    for (let i = 0; i < L && a + i < n; i++) { let gg = g; if (i < r) gg = 1 + (g - 1) * i / r; else if (i > L - r) gg = g + (1 - g) * (i - (L - r)) / r; mix.L[a + i] *= gg; mix.R[a + i] *= gg; } }
+  D.fadeOut(mix, 2.0);
+  const beats = []; for (let t = 0; t < dur; t += beat) beats.push(+t.toFixed(4));
+  return { mix, stems, markers, kicks, dur, spec: s, beats };
+}

package/vendor/motioncraft/scripts/lib/phase1.mjs

@@ -0,0 +1,90 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import {run, die, readJson, writeJson, mkdirp, workDir, ff} from './util.mjs';
+
+const ROLES = ['hook', 'reframe', 'proof', 'proof', 'how', 'how', 'cta', 'end'];
+const WEIGHTS = [0.09, 0.12, 0.19, 0.13, 0.15, 0.14, 0.10, 0.08];
+const VISUAL = {
+  hook: 'one plain-language headline and one visual focal point',
+  reframe: 'show the old problem, then the new approach',
+  proof: 'real footage, credited example, or a verified claim',
+  how: 'one step with an on-screen action',
+  cta: 'one clear action',
+  end: 'brand and handle with breathing room',
+};
+const clean = (x) => String(x || '').trim();
+const num = (x, name, min, max) => { const n = Number(x); if (!Number.isFinite(n) || n < min || n > max) die(`${name} must be ${min}-${max}`); return n; };
+const slug = (x) => x.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-|-$/g, '').slice(0, 50) || 'scene';
+function loadBrief(a) {
+  const file = path.resolve(a.brief || 'brief.json'); const b = readJson(file);
+  if (!b || typeof b !== 'object') die(`read a brief JSON at ${file}`, 'required: topic, audience, goal; optional: duration, language, handle, facts, proof, cta, scenes');
+  for (const k of ['topic','audience','goal']) if (!clean(b[k])) die(`brief needs ${k}`);
+  const duration = num(b.duration ?? 60, 'duration', 15, 180);
+  return { ...b, duration, language: clean(b.language) || 'id', format: clean(b.format) || '16:9' };
+}
+export function storyboard(a) {
+  const brief = loadBrief(a); const scenes = [];
+  const supplied = brief.scenes;
+  if (supplied && (!Array.isArray(supplied) || supplied.length < 3 || supplied.length > 12)) die('brief.scenes needs 3-12 scene objects');
+  const specs = supplied || ROLES.map((role) => ({role}));
+  const weights = supplied ? specs.map((s) => num(s.weight ?? 1, 'scene weight', 0.1, 20)) : WEIGHTS;
+  const fps = num(a.fps || 30, 'fps', 1, 120), total = Math.round(brief.duration * fps);
+  if(!Number.isInteger(fps)) die('fps must be a whole number');
+  const minFrames = Math.round(0.8 * fps); if (total < specs.length * minFrames) die('video too short for scene count');
+  const free = total - specs.length * minFrames, sum = weights.reduce((x,y) => x+y,0);
+  const ends = []; let cumulative = 0;
+  for (let i=0;i<specs.length;i++) { cumulative += weights[i]/sum; ends.push(i === specs.length-1 ? total : Math.round((i+1)*minFrames + cumulative*free)); }
+  let start=0;
+  for (let i=0;i<specs.length;i++) { const s=specs[i], role=clean(s.role)||'scene'; const end=ends[i];
+    scenes.push({ id: `${String(i+1).padStart(2,'0')}-${slug(role)}`, role, fromFrame:start, toFrame:end, start:+(start/fps).toFixed(2), end:+(end/fps).toFixed(2), previewFrame:Math.min(end-1, start+Math.max(1,Math.floor((end-start)*0.72))),
+      headline:clean(s.headline), visual:clean(s.visual) || VISUAL[role] || 'one clear focal point', proof:clean(s.proof), cue:clean(s.cue), ...(s.events ? {events:s.events} : {}), ...(s.animations ? {animations:s.animations} : {}), ...(s.transition===false ? {transition:false} : {}), status:s.headline?'draft':'needs_copy' }); start=end; }
+  const board={version:1, topic:brief.topic, audience:brief.audience, goal:brief.goal, language:brief.language, format:brief.format, duration:brief.duration, fps, handle:clean(brief.handle), cta:clean(brief.cta), scenes,
+    notes:['This is a timing and visual-role scaffold, not a written script or a Remotion composition.', 'Fill each headline, confirm factual claims and licenses, and inspect the stills before a full render.']};
+  const file=path.resolve(a.out||'storyboard.json'); writeJson(file,board);
+  const md=path.resolve(a.md||file.replace(/\.json$/i,'')+'.md');
+  fs.writeFileSync(md,`# ${brief.topic}\n\nAudience: ${brief.audience} | Goal: ${brief.goal} | ${brief.duration}s | ${brief.language}\n\n| Time | Role | Headline | Visual / evidence |\n|---|---|---|---|\n${scenes.map(s=>`| ${s.start.toFixed(1)}-${s.end.toFixed(1)}s | ${s.role} | ${s.headline||'TODO: write and approve'} | ${s.visual.replace(/\|/g,'/')} |`).join('\n')}\n\nApprove the copy, proof and assets before rendering. This board is not final video code.\n`);
+  return {storyboard:file, review:md, scenes:scenes.length, duration:brief.duration, needsCopy:scenes.filter(s=>!s.headline).length};
+}
+function project(a) { const p=workDir(a), entry=path.join(p,'src/index.ts'); if (!fs.existsSync(entry)) die(`not a Remotion project: ${p}`); return p; }
+function remotion(p,args) { const r=run('npx',['--no-install','remotion',...args],{cwd:p,encoding:'utf8',maxBuffer:1<<24}); if(r.status!==0) die('Remotion failed: '+(r.stderr||r.stdout||'').slice(-800)); return r; }
+export function preview(a) {
+  const p=project(a), board=readJson(path.resolve(a.board||path.join(p,'storyboard.json')));
+  if (!board?.scenes?.length) die('storyboard scenes missing; pass --board storyboard.json');
+  const fps=num(board.fps,'storyboard fps',1,120), scale=num(a.scale??0.35,'scale',0.1,1), comp=clean(a.comp)||'Main';
+  const r=remotion(p,['compositions','src/index.ts']); const line=r.stdout.split('\n').find(x=>x.trim().startsWith(comp+' '));
+  if(!line) die(`composition ${comp} not found`); const match=line.match(/^\s*\S+\s+(\d+)\s+\S+\s+(\d+)\s+\(/);
+  if(!match) die(`could not read composition metadata: ${line}`);
+  if(Number(match[1])!==fps) die(`board fps ${fps} differs from composition fps ${match[1]}`);
+  const last=Math.max(...board.scenes.map(s=>Number(s.previewFrame))); if(last>=Number(match[2])) die(`board needs frame ${last}, but composition ${comp} ends at ${Number(match[2])-1}; update durationInFrames in src/Root.tsx before preview`);
+  const out=path.resolve(a.out||path.join(p,'out','preview-stills')); mkdirp(out);
+  const ids=new Set(); for(const scene of board.scenes) { if(!/^[a-z0-9_-]+$/i.test(scene.id||'')) die(`invalid scene id: ${scene.id}`); if(ids.has(scene.id)) die(`duplicate scene id: ${scene.id}`); ids.add(scene.id); }
+  const frames=[];
+  for (const s of board.scenes) { const f=Math.round(Number(s.previewFrame)); if (!Number.isFinite(f)||f<0) die(`bad preview frame for ${s.id}`);
+    const image=path.join(out,`${s.id}.png`); remotion(p,['still','src/index.ts',comp,image,'--frame',String(f),'--scale',String(scale),'--gl',a.gl||'swangle']); frames.push({id:s.id,frame:f,time:+(f/fps).toFixed(2),image}); }
+  // ffmpeg tile is deterministic and operates on actual rendered still pixels, not a mock storyboard.
+  const list=path.join(out,'frames.txt'); fs.writeFileSync(list,frames.map(f=>`file '${f.image.replace(/'/g,"'\\''")}'`).join('\n')+'\n');
+  const sheet=path.join(out,'contact-sheet.jpg');
+  ff(['-f','concat','-safe','0','-i',list,'-vf',`scale=640:-2,tile=${Math.min(3,frames.length)}x${Math.ceil(frames.length/Math.min(3,frames.length))}:padding=12:margin=12:color=white`,'-frames:v','1',sheet]);
+  return {sheet,frames,note:'Stills are sampled from the current composition at storyboard frames. Review every image; this does not create scenes from the board or replace a motion/audio preview.'};
+}
+function sourceFiles(root,paths) { return paths.flatMap(name=>{const p=path.resolve(root,name); if(!p.startsWith(root+path.sep)||!fs.existsSync(p)) die(`missing or outside project source: ${name}`); const st=fs.statSync(p); if(st.isDirectory()) return fs.readdirSync(p).sort().flatMap(child=>sourceFiles(root,[path.relative(root,path.join(p,child))])); return [{file:path.relative(root,p),hash:crypto.createHash('sha256').update(fs.readFileSync(p)).digest('hex')}];}); }
+export function cache3d(a) {
+  const p=project(a), comp=clean(a.comp); if(!comp) die('cache3d needs --comp for an isolated 3D-only composition');
+  const sources=clean(a.sources).split(',').map(s=>s.trim()).filter(Boolean); if(!sources.length) die('cache3d needs --sources src/scenes/Logo.tsx,... so edits invalidate the cache');
+  const start=num(a.start??0,'start',0,1e6), end=num(a.end,'end',start+1,1e6), scale=num(a.scale??1,'scale',0.1,1);
+  if(!Number.isInteger(start)||!Number.isInteger(end)) die('start and end must be whole frames');
+  if(a.props) die('cache3d --props is not supported yet; bake the intended properties into the isolated composition so the cache reflects exactly what is rendered');
+  const fps=num(a.fps??30,'fps',1,120); const cs=remotion(p,['compositions','src/index.ts']); const line=cs.stdout.split('\n').find(x=>x.trim().startsWith(comp+' '));
+  const c= line?.match(/^\s*\S+\s+(\d+)\s+\S+\s+(\d+)\s+\(/); if(!c) die(`composition ${comp} not found`);
+  if(Number(c[1])!==fps) die(`composition fps ${c[1]} differs from --fps ${fps}`); if(end>=Number(c[2])) die(`end frame ${end} exceeds composition last frame ${Number(c[2])-1}`);
+  const manifest={version:1,comp,start,end,scale,fps,sources:sourceFiles(p,sources),engine:'motioncraft-cache3d-v1'};
+  const key=crypto.createHash('sha256').update(JSON.stringify(manifest)).digest('hex').slice(0,16);
+  const base=path.join(p,'public','mc-cache',`${slug(comp)}-${key}`), count=end-start+1, meta=path.join(base,'manifest.json');
+  if(fs.existsSync(meta)&&Array.from({length:count},(_,i)=>fs.existsSync(path.join(base,`${String(i).padStart(6,'0')}.png`))).every(Boolean)) return {cached:true,dir:base,frames:count,key,component:`<CachedFrames dir="mc-cache/${slug(comp)}-${key}" start={${start}} count={${count}} />`};
+  mkdirp(base); for(const f of fs.readdirSync(base)) if(f.endsWith('.png')) fs.rmSync(path.join(base,f)); remotion(p,['render','src/index.ts',comp,base,'--sequence','--image-format','png','--frames',`${start}-${end}`,'--scale',String(scale),'--gl',a.gl||'swangle','--muted']);
+  const files=fs.readdirSync(base).filter(f=>/^element-\d+\.png$/.test(f)).sort((x,y)=>Number(x.match(/\d+/)[0])-Number(y.match(/\d+/)[0]));
+  if(files.length!==count || files.some((name,i)=>Number(name.match(/\d+/)[0])!==start+i)) die(`expected ${count} contiguous frames from ${start}, got ${files.length}; cache not marked complete`);
+  files.forEach((name,i)=>fs.renameSync(path.join(base,name),path.join(base,`${String(i).padStart(6,'0')}.png`)));
+  writeJson(meta,manifest); return {cached:false,dir:base,frames:count,key,component:`<CachedFrames dir="mc-cache/${slug(comp)}-${key}" start={${start}} count={${count}} />`,warning:'Use an isolated 3D-only composition with a transparent background; include every 3D source, asset and style token in --sources. Changes outside that list cannot invalidate this cache.'};
+}

package/vendor/motioncraft/scripts/lib/phase2.mjs

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import {readJson,writeJson,die,mkdirp,ff,probe} from './util.mjs';
+import {PRESETS} from './music.mjs';
+import {SFX_TYPES} from './sfx.mjs';
+
+const MAP={typing:'type',type:'type',keypress:'type',click:'button',button:'button',transition:'whoosh_in',enter:'whoosh_in',exit:'whoosh_out',logo:'logo_sting',logo_reveal:'logo_sting',cta:'icon_pop',reveal:'icon_pop',check:'check'};
+const LOUD=new Set(['logo_sting','impact','whoosh_in','whoosh_out']);
+// Scene structure and exported animation timeline provide automatic, sparse cue candidates.
+// Never infer UI actions or a logo merely because a storyboard prose description mentions one.
+const MOTION_KINDS={text:'typing',text_appear:'typing',headline:'typing',transition:'transition',scene_transition:'transition',ui_click:'click',button_click:'click',ui:'click',logo:'logo_reveal',logo_reveal:'logo_reveal',check:'check'};
+function motionEvents(scene, timeline, start, end, index, fps) {
+ const result=[];
+ if(scene.headline && scene.headline.trim()) result.push({kind:'typing',at:Math.min(end-1/fps,start+0.12),source:'scene.headline'});
+ if(index>0 && scene.transition!==false) result.push({kind:'transition',at:start,source:'scene.boundary'});
+ // The timeline comes from the actual animation plan. Times are absolute seconds;
+ // scene IDs are checked so an event cannot leak into an adjacent scene.
+ const entries=[...(Array.isArray(scene.animations)?scene.animations:[]),
+   ...(Array.isArray(timeline?.events)?timeline.events.filter(e=>e.scene===scene.id||e.sceneId===scene.id):[])];
+ for(const e of entries){
+  const kind=MOTION_KINDS[clean(e.kind||e.type).toLowerCase()];
+  if(kind){ const at=e.at??e.t??(e.frame==null?undefined:Number(e.frame)/fps); if(at==null)die(`animation ${kind} in ${scene.id||index+1} needs at/t/frame`); result.push({kind,at,source:'animation'}); }
+ }
+ return result;
+}
+const clean=x=>String(x??'').trim();
+const seconds=(s,k)=>{const n=Number(s);if(!Number.isFinite(n)||n<0)die(`${k} needs non-negative seconds`);return n;};
+export function autoCues(a){
+ const board=readJson(path.resolve(a.board||'storyboard.json'));
+ if(!board||!Array.isArray(board.scenes)||!board.scenes.length)die('board missing scenes; pass --board storyboard.json');
+ const dur=seconds(board.duration,'duration');if(!dur)die('board duration must be positive');
+ const fps=Number(board.fps??30), raw=[]; let unknown=[];
+ if(!Number.isFinite(fps)||fps<=0)die('board fps must be positive');
+ const timeline=a.timeline?readJson(path.resolve(a.timeline)):null;
+ if(a.timeline && !timeline)die(`cannot read timeline ${a.timeline}`);
+ for(const [i,scene] of board.scenes.entries()){
+  const start=seconds(scene.start,`scene ${i+1} start`), end=seconds(scene.end,`scene ${i+1} end`);
+  if(end<=start||end>dur+0.001)die(`scene ${i+1} has invalid range`);
+  const cue=clean(scene.cue).toLowerCase();
+  const events=scene.events??(cue && (MAP[cue]||SFX_TYPES.includes(cue))?[{kind:cue,at:start+0.12}]:motionEvents(scene,timeline,start,end,i,fps));
+  if(cue && !MAP[cue] && !SFX_TYPES.includes(cue) && !scene.events)unknown.push({scene:scene.id||i+1,kind:cue,note:'cue is not a known event; automatic animation cues used'});
+  if(!Array.isArray(events))die(`scene ${i+1} events must be an array`);
+  for(const event of events){
+   const kind=clean(event.kind||event.type).toLowerCase(), type=MAP[kind]||(SFX_TYPES.includes(kind)?kind:null);
+   if(!type){unknown.push({scene:scene.id||i+1,kind});continue;}
+   const at=seconds(event.at??event.t??start,`event ${kind}`);
+   if(at<start-0.001||at>=end||at>=dur)die(`event ${kind} at ${at}s falls outside scene ${scene.id||i+1}`);
+   // Sound 1 frame ahead of an on-screen landing. Tiny type/click sounds keep their precise timing.
+   const t=Math.max(0,at-((type==='type'||type==='button')?0:1/fps));
+   raw.push({type,t:+t.toFixed(3),snap:false,scene:scene.id||String(i+1),kind,source:event.source||'manual'});
+  }
+ }
+ raw.sort((x,y)=>x.t-y.t);
+ const minGap=seconds(a.minGap??0.12,'minGap'),maxPerMin=Number(a.maxPerMin??24);if(!Number.isFinite(maxPerMin)||maxPerMin<1||maxPerMin>240)die('maxPerMin must be 1-240');
+ const max=Math.max(1,Math.floor(maxPerMin*dur/60)),cues=[];
+ // Prefer a reveal or section transition over micro-clicks when the density cap binds.
+ const priority={logo_sting:4,impact:4,whoosh_in:3,whoosh_out:3,icon_pop:2,button:1,type:0};
+ raw.sort((x,y)=>(priority[y.type]??1)-(priority[x.type]??1)||x.t-y.t);
+ for(const c of raw){ if(cues.length>=max)break; if(cues.some(x=>Math.abs(x.t-c.t)<minGap))continue;
+  if(LOUD.has(c.type)&&cues.some(x=>LOUD.has(x.type)&&Math.abs(x.t-c.t)<0.55))continue;
+  cues.push(c); }
+ cues.sort((x,y)=>x.t-y.t);
+ const out=path.resolve(a.out||'audio/auto-cues.json');writeJson(out,{duration:dur,fps,cues});
+ return {file:out,cues:cues.length,skipped:raw.length-cues.length,unknown,perMinute:+(cues.length/dur*60).toFixed(1),note:'Review generated cues against the rendered video. Scene headlines and boundaries are inferred; UI and logo cues need structured animation timeline events. Explicit scene.events overrides all inferred cues for that scene.'};
+}
+export function moodOptions(a){
+ const moods={calm:['cinematic-soft','dreamy'],warm:['warm-major','calm-punch'],focused:['lofi-desk','dark-minimal'],bright:['tech-bright','warm-major'],premium:['cinematic-soft','dark-minimal']};
+ const name=clean(a.mood).toLowerCase();if(!moods[name])die(`choose --mood ${Object.keys(moods).join('|')}`);
+ const options=moods[name].map(id=>({preset:id,bpm:PRESETS[id].bpm,key:PRESETS[id].key,lead:PRESETS[id].lead,progression:PRESETS[id].progression}));
+ return {mood:name,options,note:'Options are existing instrumental presets, not a forced selection. Audition them and choose a different vibe from the last video; music make still enforces its variety guard.'};
+}
+export function reviewHash(file){return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');}
+export function mixReview(a){
+ const file=path.resolve(a.file||'audio/final.wav');if(!fs.existsSync(file))die(`mix missing: ${file}`);
+ const p=probe(file),dur=Number(p.format.duration);if(!Number.isFinite(dur)||dur<=0)die('invalid mix duration');
+ const out=path.resolve(a.out||'out/mix-review');mkdirp(out);
+ const manifest=path.join(out,'review.json');
+ if(a.approve){const previous=readJson(manifest);if(!previous||previous.source!==file||previous.sha256!==reviewHash(file))die('mix changed or no matching review clips; rerun mix review');
+  previous.approvedAt=new Date().toISOString();writeJson(manifest,previous);return {manifest,approved:true,note:'Review gate recorded. Approval states the operator listened to the full mix and clips.'};}
+ const positions=a.cues?readJson(path.resolve(a.cues))?.cues||[]:[];
+ const markers=[0,...positions.map(c=>Number(c.t)).filter(t=>Number.isFinite(t)&&t>=0&&t<dur),Math.max(0,dur-3)];
+ const selected=[...new Set(markers.map(x=>+x.toFixed(2)))].sort((x,y)=>x-y).filter((t,i,all)=>i===0||t-all[i-1]>=0.5);
+ const clips=[];for(const [i,t] of selected.entries()){
+  const start=Math.max(0,t-0.45),length=Math.min(2.8,dur-start),dest=path.join(out,`cue-${String(i+1).padStart(2,'0')}.wav`);
+  ff(['-ss',String(start),'-i',file,'-t',String(length),'-ac','2','-ar','48000','-c:a','pcm_s16le',dest]);clips.push({at:t,start:+start.toFixed(2),file:dest}); }
+ writeJson(manifest,{source:file,sha256:reviewHash(file),duration:dur,clips});
+ return {manifest,clips,note:'Listen to the full mix AND cue clips before export; this command does not judge taste, masking or clipping. Run qa audio after listening.'};
+}

package/vendor/motioncraft/scripts/lib/qa-full.mjs

@@ -0,0 +1,24 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import {probe,run,mkdirp,writeJson,die} from './util.mjs';
+
+// Inspect every decoded frame of the rendered video. Sampling can miss a one-frame flash.
+export function qaFull(a) {
+ const input=path.resolve(a._?.[1]||a.file||'out/final.mp4');
+ if(!fs.existsSync(input))die(`video not found: ${input}`);
+ const p=probe(input),v=p.streams.find(s=>s.codec_type==='video');if(!v)die('qa full needs a video stream');
+ const fpsNum=Number(v.avg_frame_rate?.split('/')[0]),fpsDen=Number(v.avg_frame_rate?.split('/')[1]||1),fps=fpsNum/fpsDen;
+ if(!Number.isFinite(fps)||fps<=0)die('video frame rate unavailable');
+ const duration=Number(p.format.duration);if(!Number.isFinite(duration)||duration<=0)die('video duration unavailable');
+ const dir=path.resolve(a.outDir||'out/qa-full');mkdirp(dir);const flaggedDir=path.join(dir,'flagged');mkdirp(flaggedDir);
+ const script=path.join(path.dirname(new URL(import.meta.url).pathname),'qa_full.py');
+ const r=run('python3',[script,input,String(v.width),String(v.height),String(fps),path.join(dir,'findings.json'),flaggedDir],{maxBuffer:1<<24});
+ if(r.status!==0)die('full QA failed: '+(r.stderr||r.stdout||'').slice(-800));
+ const findings=JSON.parse(fs.readFileSync(path.join(dir,'findings.json'),'utf8'));
+ const framesScanned=findings.framesScanned;
+ if(!framesScanned)die('No decoded frames');
+ const report={source:input,sha256:crypto.createHash('sha256').update(fs.readFileSync(input)).digest('hex'),framesScanned,width:v.width,height:v.height,duration,fps,issues:findings.issues,ocrFailures:findings.ocrFailures,pass:findings.issues.length===0&&findings.ocrFailures.length===0,note:'Every decoded frame was checked. OCR heuristics can miss low-contrast, animated, stylized or non-Latin text; collision flags are OCR geometry, not semantic proof. Inspect flagged frames and watch/listen to the final video. A pass is not visual certification.',flaggedFramesDir:flaggedDir};
+ const manifest=path.join(dir,'review.json');writeJson(manifest,report);
+ return {manifest,...report};
+}

package/vendor/motioncraft/scripts/lib/qa-pixels.mjs

@@ -0,0 +1,47 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import {fileURLToPath} from 'node:url';
+import {ff,probe,readJson,writeJson,mkdirp,die,run} from './util.mjs';
+
+const hash=f=>crypto.createHash('sha256').update(fs.readFileSync(f)).digest('hex');
+const times=(duration,board,fps)=>{
+ const at=new Set([0,Math.max(0,duration-0.3)]);
+ if(board?.scenes?.length){for(const s of board.scenes){for(const t of [s.start,s.end-2/fps,s.previewFrame/fps])if(Number.isFinite(+t)&&t>=0&&t<duration)at.add(+t.toFixed(3));}}
+ else for(let i=0;i<8;i++)at.add(+((i+0.5)*duration/8).toFixed(3));
+ return [...at].sort((a,b)=>a-b).filter((v,i,x)=>i===0||v-x[i-1]>=0.18);
+};
+export function fontAudit(dir){
+ const style=readJson(path.join(dir,'src/style.json'));if(!style?.font) return {pass:false,issues:['src/style.json missing font config']};
+ const fontFile=path.join(dir,'src/lib/fonts.ts');if(!fs.existsSync(fontFile))return {pass:false,issues:['src/lib/fonts.ts missing']};
+ const text=fs.readFileSync(fontFile,'utf8'),tokenFile=path.join(dir,'src/lib/tokens.ts');const issues=[];
+ for(const [label,name] of Object.entries({display:style.font.display,mono:style.font.mono})){
+  if(!name)issues.push(`${label} font unset`);
+  else if(!text.includes(`@remotion/google-fonts/${name.replace(/[^A-Za-z0-9]/g,'')}`)&&!text.includes(`@remotion/fonts`))issues.push(`${label} font ${name} not imported in fonts.ts`);
+ }
+ if(!fs.existsSync(tokenFile)||!fs.readFileSync(tokenFile,'utf8').includes("import './fonts'"))issues.push('tokens.ts does not import fonts.ts');
+ const sizes=style.font.size||{};for(const [level,range] of Object.entries(sizes))if(!Array.isArray(range)||!range.every(x=>Number.isFinite(x)&&x>0))issues.push(`${level} font range invalid`);
+ return {pass:!issues.length,issues,note:'Static import/weight check only; inspect rendered glyphs for missing fonts or fallback. A successful import does not prove every character loaded.'};
+}
+export function qaPixels(a){
+ const file=path.resolve(a._?.[1]||a.file||'out/final.mp4'),p=probe(file),v=p.streams.find(s=>s.codec_type==='video');if(!v)die('qa pixels needs video');
+ const duration=Number(p.format.duration),fps=Number(v.avg_frame_rate?.split('/')[0])/Number(v.avg_frame_rate?.split('/')[1]||1)||30;
+ const dir=path.resolve(a.outDir||'out/qa-pixels');mkdirp(dir);
+ const board=a.board?readJson(path.resolve(a.board)):null,frames=[],audio=p.streams.some(s=>s.codec_type==='audio');
+ for(const [i,t] of times(duration,board,fps).entries()){
+  const image=path.join(dir,`frame-${String(i+1).padStart(2,'0')}.png`);
+  ff(['-ss',String(t),'-i',file,'-frames:v','1',image]);
+  const snippet=audio?path.join(dir,`audio-${String(i+1).padStart(2,'0')}.wav`):null;
+  if(snippet)ff(['-ss',String(Math.max(0,t-0.5)),'-i',file,'-vn','-t',String(Math.min(2,duration-Math.max(0,t-0.5))),'-ac','2','-ar','48000',snippet]);
+  frames.push({at:t,image,snippet});
+ }
+ const script=path.join(path.dirname(fileURLToPath(import.meta.url)),'qa_pixels.py');
+ const r=run('python3',[script,JSON.stringify({frames,width:v.width,height:v.height,dir})],{encoding:'utf8',maxBuffer:1<<23});if(r.status!==0)die('pixel review failed: '+(r.stderr||r.stdout||'').slice(-800));
+ const metrics=JSON.parse(r.stdout);metrics.frames.forEach((f,i)=>f.audioSnippet=frames[i].snippet);const project=path.resolve(a.dir||'.');const fonts=fontAudit(project);
+ if(!metrics.frames.every(x=>x.ocrAvailable))fonts.issues.push('OCR unavailable on at least one frame; text checks incomplete');
+ fonts.pass=!fonts.issues.length;
+ const report={source:file,sha256:hash(file),duration,width:v.width,height:v.height,frames:metrics.frames,contactSheet:metrics.contactSheet,fonts,audioSnippets:audio,pass:fonts.pass&&!metrics.frames.some(x=>x.warnings.length),note:'Heuristic OCR and edge analysis on sampled final pixels only. A pass is not a zero-overlap or perfect-crop claim. Inspect the contact sheet and each critical full-size frame; listen to the audio snippets, then watch the full video at phone size with audio. No sound playback occurs automatically.'};
+ const manifest=path.join(dir,'review.json');writeJson(manifest,report);
+ return {manifest,...report};
+}

package/vendor/motioncraft/scripts/lib/qa.mjs

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import * as D from './dsp.mjs';
+import { ff, ffmpeg, probe, toWav48, run, die, readJson, mkdirp, has } from './util.mjs';
+import { silences } from './audio.mjs';
+import {geometry} from '../../assets/template/src/lib/format.mjs';
+
+export function qaFile(file, a) {
+  const p = probe(file); const v = p.streams.find((s) => s.codec_type === 'video'); const au = p.streams.find((s) => s.codec_type === 'audio');
+  const size = +p.format.size / 1048576; const dur = +p.format.duration; const max = a.maxMb ? +a.maxMb : null; const issues = [];
+  if (max && size > max) issues.push(`file is ${size.toFixed(1)} MB, limit ${max} MB -> re-encode with render --preset wa`);
+  if (!au) issues.push('no audio stream');
+  if (au && v && Math.abs(+(au.duration || dur) - +(v.duration || dur)) > 0.15) issues.push(`audio (${au.duration}s) and video (${v.duration}s) lengths differ`);
+  return { file, sizeMb: +size.toFixed(2), duration: +dur.toFixed(2), video: v && `${v.width}x${v.height} ${v.codec_name} ${v.r_frame_rate}`, audio: au && `${au.codec_name} ${au.sample_rate}Hz`, pass: !issues.length, issues };
+}
+export function qaAudio(file) {
+  const w = D.readWav(toWav48(file, 'qa.wav'), fs).buf; const l = D.lufs(w), tp = D.truePeakDb(w); const issues = [];
+  if (Math.abs(l + 14) > 1) issues.push(`loudness ${l.toFixed(1)} LUFS (target -14 ±1)`);
+  if (tp > -1) issues.push(`true peak ${tp.toFixed(2)} dBTP (must be <= -1)`);
+  const sil = silences(w.L, 48000, -45, 1.2).filter(([s]) => s > 0.5 && s < w.L.length / 48000 - 3); if (sil.length) issues.push(`long silences at ${sil.map((x) => x[0] + 's').join(', ')}`);
+  return { lufs: +l.toFixed(2), truePeak: +tp.toFixed(2), pass: !issues.length, issues };
+}
+export function qaSheet(file, a) {
+  const dur = +probe(file).format.duration; const n = +(a.count || 24); const dir = path.resolve(a.outDir || 'out/qa'); mkdirp(dir); const frames = [];
+  for (let i = 0; i < n; i++) { const t = (i + 0.5) * dur / n; const o = path.join(dir, `q_${String(i).padStart(2, '0')}.jpg`); ff(['-ss', t.toFixed(2), '-i', file, '-frames:v', '1', '-vf', `scale=480:-2,drawtext=text='${t.toFixed(1)}s':x=6:y=6:fontsize=18:fontcolor=white:box=1:boxcolor=black@0.5`, o]); frames.push(o); }
+  const sheet = path.join(dir, 'sheet.jpg'); ff(['-pattern_type', 'glob', '-i', path.join(dir, 'q_*.jpg'), '-frames:v', '1', '-vf', 'tile=4x6:padding=4', sheet]);
+  return { sheet, frames: frames.length, note: 'Open the sheet. Check: text collisions, text near edges, one focus per frame, hierarchy, accent count, anything that looks like AI slop.' };
+}
+// ffprobe reports frame rates as rational strings. Never execute metadata as code.
+export function parseFrameRate(value) {
+  if (typeof value !== 'string' || !/^[0-9]+(?:\/[0-9]+)?$/.test(value)) throw new Error('invalid ffprobe frame rate');
+  const [numerator, denominator = '1'] = value.split('/');
+  const n = Number(numerator), d = Number(denominator);
+  if (!Number.isSafeInteger(n) || !Number.isSafeInteger(d) || n <= 0 || d <= 0) throw new Error('invalid ffprobe frame rate');
+  const fps = n / d;
+  if (!Number.isFinite(fps) || fps <= 0) throw new Error('invalid ffprobe frame rate');
+  return fps;
+}
+// Overlap check: renders the composition in debug-box mode at 1/4 scale, then scans every frame.
+export function qaOverlap(a) {
+  const proj = path.resolve(a.dir || '.'); const comp = a.comp || 'Main'; const scale = +(a.scale || 0.25); const tmp = path.join(os.tmpdir(), `mc-ov-${process.pid}`); mkdirp(tmp);
+  const supplied=a.props ? (a.props.trim().startsWith('{')?JSON.parse(a.props):readJson(path.resolve(a.props))) : {};
+  if(!supplied || typeof supplied!=='object'||Array.isArray(supplied))die('invalid --props JSON');
+  const g=geometry(a.format||supplied.format||'16:9',a.platform||supplied.platform);
+  const props=JSON.stringify({...supplied,format:g.format,platform:g.platform,mcDebug:true});
+  const r = run('npx', ['--no-install', 'remotion', 'render', 'src/index.ts', comp, path.join(tmp, 'dbg.mp4'), `--props=${props}`, `--scale=${scale}`, '--codec=h264', '--crf=1', '--muted', `--gl=${a.gl || 'swangle'}`], { cwd: proj, stdio: ['ignore', 'ignore', 'pipe'] });
+  if (r.status !== 0) die('debug render failed: ' + (r.stderr || '').slice(-600), 'run inside the project folder after npm install');
+  const p = probe(path.join(tmp, 'dbg.mp4')); const v = p.streams.find((s) => s.codec_type === 'video'); const W = v.width, H = v.height; const fps = parseFrameRate(v.r_frame_rate);
+  const F = ffmpeg(); const rawPath = path.join(tmp, 'frames.rgb');
+  run(F.ff[0], [...F.ff.slice(1), '-y', '-v', 'error', '-i', path.join(tmp, 'dbg.mp4'), '-f', 'rawvideo', '-pix_fmt', 'rgb24', rawPath]);
+  const fsz = W * H * 3, frames = Math.floor(fs.statSync(rawPath).size / fsz); const left=Math.round(g.insets.left*scale),right=Math.round(g.insets.right*scale),top=Math.round(g.insets.top*scale),bottom=Math.round(g.insets.bottom*scale);
+  const hits = []; const minPx = Math.max(4, Math.round(W * H * 0.00015)); const fd = fs.openSync(rawPath, 'r'); const raw = Buffer.alloc(fsz);
+  for (let f = 0; f < frames; f++) { let over = 0, blockOver = 0, edge = 0; fs.readSync(fd, raw, 0, fsz, f * fsz);
+    for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) { const i = (y * W + x) * 3, R = raw[i], G = raw[i + 1], B = raw[i + 2];
+      if (R > 200 && G < 100 && B < 100) over++;                       // two text boxes stacked (red on red)
+      if (G > 200 && R < 110 && B < 110) blockOver++;                  // two blocks stacked (green on green)
+      if ((x < left || x >= W-right || y < top || y >= H-bottom) && R > 200 && G < 170 && B < 170) edge++; } // text in the margin
+    if (over > minPx || blockOver > minPx * 4 || edge > minPx) hits.push({ frame: f, time: +(f / fps).toFixed(2), textOverlapPx: over, blockOverlapPx: blockOver, textInMarginPx: edge }); }
+  fs.closeSync(fd); fs.rmSync(rawPath, { force: true });
+  const shots = []; const dir = path.resolve(proj, 'out', 'qa-overlap'); mkdirp(dir);
+  const groups = []; for (const h of hits) { const g = groups[groups.length - 1]; if (g && h.frame - g.end <= 2) g.end = h.frame; else groups.push({ start: h.frame, end: h.frame, first: h }); }
+  for (const g of groups.slice(0, 12)) { const o = path.join(dir, `overlap_f${g.start}.png`); ff(['-ss', (g.start / fps).toFixed(3), '-i', path.join(tmp, 'dbg.mp4'), '-frames:v', '1', o]); shots.push(o); }
+  return { format:g.format,platform:g.platform,frames, pass: hits.length === 0, problemRanges: groups.map((g) => ({ fromFrame: g.start, toFrame: g.end, fromSec: +(g.start / fps).toFixed(2), toSec: +(g.end / fps).toFixed(2), ...g.first })), screenshots: shots,
+    note: hits.length ? 'Red = text box, green = card/block. Dark red/green = two boxes stacked. Fix by moving to separate zones, exiting the old element first, or shortening text. Mark intentional stickers with allowOverlap.' : 'No flagged collisions among instrumented debug boxes at this resolution. This does not prove final pixels are collision-free; run qa pixels and inspect final frames.' };
+}

package/vendor/motioncraft/scripts/lib/qa_full.py

@@ -0,0 +1,45 @@
+"""Frame-complete OCR geometry audit of an already-rendered video."""
+import json,sys,subprocess,os,re
+from PIL import Image
+source,w,h,fps,out,flagged_dir=sys.argv[1],int(sys.argv[2]),int(sys.argv[3]),float(sys.argv[4]),sys.argv[5],sys.argv[6]
+issues=[]; failures=[]
+# Stream decoded frames: keep only flagged PNGs instead of gigabytes of intermediates.
+ff=subprocess.Popen(['ffmpeg','-hide_banner','-loglevel','error','-i',source,'-an','-f','rawvideo','-pix_fmt','rgb24','-vsync','0','-'],stdout=subprocess.PIPE,stderr=subprocess.PIPE)
+size=w*h*3;idx=0
+while True:
+ raw=ff.stdout.read(size)
+ if not raw:break
+ if len(raw)!=size:raise RuntimeError('truncated decoded frame')
+ timestamp=round(idx/fps,3)
+ image=os.path.join(flagged_dir,'frame-%08d.png'%idx)
+ im=Image.frombytes('RGB',(w,h),raw)
+ # tesseract accepts stdin image bytes; no disk write for unflagged frames.
+ import io
+ buf=io.BytesIO();im.save(buf,format='PNG')
+ proc=subprocess.run(['tesseract','stdin','stdout','tsv'],input=buf.getvalue(),capture_output=True)
+ stderr=proc.stderr.decode('utf8','replace')
+ if proc.returncode!=0:
+  failures.append({'frame':idx,'at':timestamp,'error':stderr[-160:]});idx+=1;continue
+ words=[]
+ for line in proc.stdout.decode('utf8','replace').splitlines()[1:]:
+  p=line.split('\t',11)
+  if len(p)<12:continue
+  try: x,y,bw,bh=map(int,p[6:10]);confidence=float(p[10])
+  except ValueError:continue
+  if confidence>=45 and p[11].strip() and bw>1 and bh>1:words.append((x,y,bw,bh,p[11].strip()))
+ warnings=[]
+ for x,y,bw,bh,text in words:
+  if bh*360/w<8:warnings.append({'type':'tiny_text','text':text,'box':[x,y,bw,bh]})
+  if x<.025*w or x+bw>.975*w or y<.025*h or y+bh>.975*h:warnings.append({'type':'clipped_or_edge_text','text':text,'box':[x,y,bw,bh]})
+ # Word boxes overlap beyond OCR tolerance; strong lead for inter-layer collision.
+ for i,(x,y,bw,bh,text) in enumerate(words):
+  for xx,yy,ww,hh,other in words[i+1:]:
+   overlap=max(0,min(x+bw,xx+ww)-max(x,xx))*max(0,min(y+bh,yy+hh)-max(y,yy))
+   if overlap>min(bw*bh,ww*hh)*.10:warnings.append({'type':'possible_text_collision','text':text+' / '+other,'boxes':[[x,y,bw,bh],[xx,yy,ww,hh]]})
+ if warnings:
+  im.save(image);issues.append({'frame':idx,'at':timestamp,'image':image,'warnings':warnings[:30]})
+ idx+=1
+ff.stdout.close()
+if ff.wait()!=0:raise RuntimeError('ffmpeg video decode failed: '+ff.stderr.read().decode('utf8','replace')[-400:])
+with open(out,'w') as f:json.dump({'framesScanned':idx,'issues':issues,'ocrFailures':failures},f,indent=2)
+print(json.dumps({'framesScanned':idx,'flaggedFrames':len(issues),'ocrFailures':len(failures)}))

package/vendor/motioncraft/scripts/lib/qa_pixels.py

@@ -0,0 +1,50 @@
+"""Sample actual final-frame pixels; OCR warnings are review leads, not proofs."""
+import json,sys,subprocess,os,math
+from PIL import Image,ImageOps,ImageDraw,ImageFilter
+from statistics import mean
+
+inp=json.loads(sys.argv[1]); W=inp['width']; H=inp['height']; samples=[]; thumbs=[]
+for item in inp['frames']:
+ im=Image.open(item['image']).convert('RGB'); w,h=im.size
+ proc=subprocess.run(['tesseract',item['image'],'stdout','tsv'],capture_output=True,text=True)
+ words=[]
+ if proc.returncode==0:
+  for line in proc.stdout.splitlines()[1:]:
+   parts=line.split('\t',11)
+   if len(parts)<12:continue
+   try: left,top,bw,bh=map(int,parts[6:10]); conf=float(parts[10])
+   except ValueError:continue
+   if conf>=45 and parts[11].strip() and bw>1 and bh>1:words.append((left,top,bw,bh,parts[11].strip()))
+ # OCR geometry is not font metrics, but catches apparent small glyphs and crop risks.
+ warnings=[]
+ for x,y,bw,bh,text in words:
+  phoneHeight=bh*360/w
+  if phoneHeight<8:warnings.append(f'small text on 360px-wide phone: {text} ({phoneHeight:.1f}px glyph)')
+  if x<.025*w or x+bw>.975*w or y<.025*h or y+bh>.975*h:warnings.append(f'text near image edge: {text}')
+  if h>w and ((x+bw>.88*w and y>.12*h) or y+bh>.8*h):warnings.append(f'9:16 UI area may cover text: {text}')
+ # For likely headline line (largest OCR words), scan a 1.5-glyph-height halo.
+ # High luminance-edge density around text suggests busy background, not certain collision.
+ headline=[]
+ if words:
+  largest=max(z[3] for z in words)
+  headline=[z for z in words if z[3]>=largest*.72 and z[3]>h*.018]
+ if headline:
+  x0=min(x for x,y,bw,bh,t in headline);y0=min(y for x,y,bw,bh,t in headline)
+  x1=max(x+bw for x,y,bw,bh,t in headline);y1=max(y+bh for x,y,bw,bh,t in headline)
+  pad=int(max(15,mean(z[3] for z in headline)*1.25)); rect=(max(0,x0-pad),max(0,y0-pad),min(w,x1+pad),min(h,y1+pad))
+  edges=im.convert('L').filter(ImageFilter.FIND_EDGES).crop(rect)
+  # Exclude OCR glyphs before measuring neighboring graphics; text's own strokes are not clutter.
+  mask=Image.new('L',edges.size,255);brush=ImageDraw.Draw(mask)
+  for x,y,bw,bh,text in words:
+   brush.rectangle((x-rect[0]-3,y-rect[1]-3,x+bw-rect[0]+3,y+bh-rect[1]+3),fill=0)
+  ep=list(edges.getdata());mp=list(mask.getdata());area=sum(z>0 for z in mp)
+  dense=sum(1 for e,m in zip(ep,mp) if m and e>65)/max(1,area)
+  if dense>.12:warnings.append(f'busy area around apparent headline ({dense:.0%} non-text edge density); inspect spacing against graphics')
+ thumb=im.copy();thumb.thumbnail((480,520))
+ tile=Image.new('RGB',(500,thumb.height+42),'white');tile.paste(thumb,((500-thumb.width)//2,32));ImageDraw.Draw(tile).text((8,8),f"{item['at']:.2f}s  {len(words)} OCR words  {len(warnings)} flags",fill='black');thumbs.append(tile)
+ samples.append({'at':item['at'],'image':item['image'],'ocrWords':len(words),'warnings':warnings[:20],'ocrAvailable':proc.returncode==0})
+cols=min(4,len(thumbs));rows=math.ceil(len(thumbs)/cols);height=max(t.height for t in thumbs)
+sheet=Image.new('RGB',(cols*500,rows*height),'#ddd')
+for i,tile in enumerate(thumbs):sheet.paste(tile,((i%cols)*500,(i//cols)*height))
+out=os.path.join(inp['dir'],'critical-sheet.jpg');sheet.save(out,quality=90)
+print(json.dumps({'frames':samples,'contactSheet':out}))