primocode 10.17.1 → 10.19.0

package/vendor/motioncraft/scripts/lib/render-worker.mjs

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import {spawnSync} from 'node:child_process';
+import {readJson,writeJson,die} from './util.mjs';
+
+const secretFile=/^(?:\.env(?:\..*)?|.*\.(?:pem|key|p12|pfx|asc)|id_(?:rsa|ed25519)|credentials(?:\..*)?|secrets?(?:\..*)?)$/i;
+const sha=file=>crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+const permitted=new Set(['angle','swangle','egl']);
+export function probeRenderer(a={}){
+ const project=path.resolve(a.dir||'.'),gl=String(a.gl||'angle');
+ if(!permitted.has(gl))throw Error('GL backend must be angle, egl, or swangle');
+ const entry=path.join(project,'src/index.ts');if(!fs.existsSync(entry))throw Error('missing Remotion src/index.ts');
+ const device=process.platform==='linux'?(fs.existsSync('/dev/dri')?'/dev/dri':null):process.platform==='win32'?'Windows graphics API':process.platform==='darwin'?'macOS Metal':null;
+ const nvidia=spawnSync('nvidia-smi',['-L'],{encoding:'utf8',timeout:5000});
+ const candidate=!!device||nvidia.status===0;
+ // Device presence is a lead, not proof that Chromium used hardware acceleration.
+ return {platform:process.platform,device,nvidia:nvidia.status===0?nvidia.stdout.trim():null,gpuCandidate:candidate,gl,requiresVisualAndTimingTest:true,note:candidate?'GPU device visible; this is not proof that Remotion uses hardware. Compare a short 3D render and inspect logs/output.':'No GPU device visible. Use software fallback or move the project to a configured GPU worker.'};
+}
+export function gpuPreflight(a){try{return probeRenderer(a)}catch(e){die(e.message)}}
+export function workerManifest(a){
+ const root=path.resolve(a.dir||'.'),dest=path.resolve(a.out||'render-job.json');
+ const comp=String(a.comp||'Main'),gl=String(a.gl||'angle');if(!/^[A-Za-z0-9_-]+$/.test(comp)||!permitted.has(gl))die('invalid composition or GL mode');
+ const required=['package.json','src/index.ts'];for(const item of required)if(!fs.existsSync(path.join(root,item)))die(`project missing ${item}`);
+ const props=a.props?path.resolve(a.props):null;if(props&&!readJson(props))die('cannot read props JSON');
+ const files=[];function walk(dir){for(const name of fs.readdirSync(dir).sort()){if(['node_modules','.git','out','.motioncraft'].includes(name))continue;if(secretFile.test(name))die(`secret-looking file in project: ${name}; move it outside the render project before packaging`);const p=path.join(dir,name),rel=path.relative(root,p).replaceAll('\\','/'),st=fs.lstatSync(p);if(st.isSymbolicLink())die(`symlink not accepted in job: ${rel}`);if(st.isDirectory())walk(p);else if(st.isFile()){if(st.size>2*1024*1024*1024)die(`file too large: ${rel}`);files.push({path:rel,sha256:sha(p),bytes:st.size});}}}
+ walk(root);if(props&&!files.some(f=>f.path===path.relative(root,props).replaceAll('\\','/')))die('props file must be inside the project and included in the manifest');
+ if(!files.some(f=>f.path==='package-lock.json'))die('package-lock.json required: run npm install --package-lock-only before bundling a worker job');
+ const manifest={version:1,composition:comp,gl,createdAt:new Date().toISOString(),files,propsPath:props?(props.startsWith(root+path.sep)?path.relative(root,props).replaceAll('\\','/'):null):null,warning:'No GPU or cloud execution guaranteed. Worker must use matching source, media, fonts and Chromium; inspect a short 3D segment and final pixels.'};
+ if(props&&!manifest.propsPath)die('props file must be inside the project for portable worker jobs');
+ writeJson(dest,manifest);return {manifest:dest,fileCount:files.length,bytes:files.reduce((n,x)=>n+x.bytes,0),sha256:sha(dest),note:'Copy the complete project directory and this manifest to your chosen worker. Do not include secrets in the project; verify hashes on worker before rendering.'};
+}
+export function workerVerify(a){const root=path.resolve(a.dir||'.'),m=readJson(path.resolve(a.manifest||'render-job.json'));
+ if(m?.version!==1||!Array.isArray(m.files)||!m.files.length)die('invalid render-job manifest');
+ const failures=[];for(const f of m.files){const absolute=path.resolve(root,f.path);if(typeof f.path!=='string'||!absolute.startsWith(root+path.sep)||!fs.existsSync(absolute)||fs.lstatSync(absolute).isSymbolicLink()||sha(absolute)!==f.sha256)failures.push(f.path)}
+ return {pass:failures.length===0,checked:m.files.length,failures,composition:m.composition,gl:m.gl};
+}

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

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { run, die, ff, probe, mkdirp, has, readJson, writeJson } from './util.mjs';
+import {reviewHash} from './phase2.mjs';
+import {geometry} from '../../assets/template/src/lib/format.mjs';
+import {validateRenderBoard} from './timeline-editor.mjs';
+import {probeRenderer} from './render-worker.mjs';
+const PRESETS = { wa: { maxMb: 15.5, audioK: 128 }, ig: { maxMb: 95, audioK: 192 }, yt: { crf: 16, audioK: 192 }, master: { crf: 12, audioK: 256 } };
+export function cmdRender(a) {
+  const proj = path.resolve(a.dir || '.'); const comp = a.comp || 'Main'; const preset = PRESETS[a.preset || 'yt'] || die(`unknown preset ${a.preset}`, 'wa | ig | yt | master');
+  if(a.audio){ const audio=path.resolve(a.audio), review=readJson(path.resolve(a.review||path.join(proj,'out/mix-review/review.json')));
+    if(!review?.approvedAt||review.source!==audio||review.sha256!==reviewHash(audio))die('mix review missing or stale; listen to full mix and cue clips, then run mix review --file <mix> --approve before export'); }
+  const g=geometry(a.format || '16:9',a.platform);
+  if((a['all-formats']||a.allFormats)) return ['1:1','4:5','9:16'].map(format=>cmdRender({...a,'all-formats':false,allFormats:false,format,platform:format==='9:16'?(a.platform==='reels'?'reels':'tiktok'):'ig-feed',out:`out/${comp}_${format.replace(':','x')}_${a.preset||'yt'}.mp4`}));
+  mkdirp(path.join(proj, 'out')); const raw = path.join(proj, 'out', `raw_${g.format.replace(':','x')}_${g.platform}.mp4`);
+  const propsPath=path.join(proj,'out',`props_${g.format.replace(':','x')}_${g.platform}.json`);const provided=a.props?readJson(path.resolve(a.props)):{};if(!provided || typeof provided!=='object'||Array.isArray(provided))die('invalid --props JSON');
+  let timeline=null,beats=[];if(a.timeline){try{timeline=validateRenderBoard(readJson(path.resolve(a.timeline)),comp==='TimelineLaunch'?'launch':comp==='TimelineTutorial'?'tutorial':comp==='Main'||comp==='MainVertical'?'main':comp==='ProductLaunch'?'product-launch':comp==='ScreenTutorial'?'screen-tutorial':'unsupported');}catch(e){die(e.message)}}
+  if(a.grid && !timeline)die('--grid needs a timeline-aware composition with --timeline');
+  if(a.grid){const grid=readJson(path.resolve(a.grid));if(!grid||!Array.isArray(grid.beats)||grid.beats.some(b=>typeof b!=='number'||!Number.isFinite(b)))die('invalid beat grid');beats=grid.beats;}
+  writeJson(propsPath,{...provided,...(timeline?{timeline}:{}),...(a.grid?{beats}:{}),format:g.format,platform:g.platform}); const gl = a.gl || (process.platform === 'linux' && !fs.existsSync('/dev/dri') ? 'swangle' : 'angle');
+  if(a['require-gpu']||a.requireGpu){const probe=probeRenderer({dir:proj,gl});if(!probe.gpuCandidate||gl==='swangle')die('GPU required but no candidate hardware device was found or software GL selected; no render started. Even a device candidate needs a test to prove acceleration.');}
+  const args = ['--no-install', 'remotion', 'render', 'src/index.ts', comp, raw, '--crf=14', `--gl=${gl}`]; args.push(`--props=${propsPath}`); if (a.concurrency) args.push(`--concurrency=${a.concurrency}`);
+  if (!a.skipRender) { const r = run('npx', args, { cwd: proj, stdio: 'inherit' }); if (r.status !== 0) die('render failed', 'common fixes: video clips that fail to decode -> convert to a JPG sequence (<Frames>); out of memory -> --concurrency 2; WebGL errors -> --gl swangle'); }
+  const outF = path.resolve(proj, a.out || `out/${comp}_${g.format.replace(':','x')}_${g.platform}_${a.preset || 'yt'}.mp4`); const dur = +probe(raw).format.duration; const audio = a.audio ? path.resolve(a.audio) : null;
+  const inA = audio ? ['-i', audio, '-map', '0:v', '-map', '1:a', '-shortest'] : [];
+  if (preset.maxMb) { const vk = Math.max(300, Math.floor(preset.maxMb * 8192 / dur - preset.audioK)); const pl = path.join(proj, 'out', 'pass');
+    ff(['-i', raw, '-c:v', 'libx264', '-preset', 'medium', '-b:v', `${vk}k`, '-pass', '1', '-passlogfile', pl, '-an', '-f', 'mp4', process.platform === 'win32' ? 'NUL' : '/dev/null']);
+    ff(['-i', raw, ...inA, '-c:v', 'libx264', '-preset', 'medium', '-b:v', `${vk}k`, '-pass', '2', '-passlogfile', pl, '-pix_fmt', 'yuv420p', '-movflags', '+faststart', '-c:a', 'aac', '-b:a', `${preset.audioK}k`, outF]); }
+  else ff(['-i', raw, ...inA, '-c:v', 'libx264', '-preset', 'slow', '-crf', String(preset.crf), '-pix_fmt', 'yuv420p', '-movflags', '+faststart', '-c:a', 'aac', '-b:a', `${preset.audioK}k`, outF]);
+  const p = probe(outF); return { output: outF, sizeMb: +(+p.format.size / 1048576).toFixed(2), duration: +(+p.format.duration).toFixed(2), format:g.format,platform:g.platform,dimensions:`${g.width}x${g.height}`,gl };
+}

package/vendor/motioncraft/scripts/lib/retime-audio.mjs

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {ff,probe,readJson,mkdirp} from './util.mjs';
+
+export function audioPlan(original,edited) {
+ const fps=original?.fps;
+ if(!Number.isInteger(fps)||fps<1||edited?.fps!==fps||!Array.isArray(original.scenes)||!original.scenes.length||!Array.isArray(edited.scenes))throw Error('Original and edited boards need matching fps and scenes');
+ const ids=new Map(original.scenes.map(s=>[s.id,s]));
+ if(ids.size!==original.scenes.length||edited.scenes.length!==ids.size||new Set(edited.scenes.map(s=>s.id)).size!==ids.size)throw Error('Both boards must contain each unique scene exactly once');
+ let sourceEnd=0,targetEnd=0;
+ const segments=edited.scenes.map(s=>{
+  const o=ids.get(s.id);
+  if(!o||!Number.isInteger(o.fromFrame)||!Number.isInteger(o.toFrame)||o.toFrame<=o.fromFrame||!Number.isInteger(s.fromFrame)||!Number.isInteger(s.toFrame)||s.fromFrame!==targetEnd||s.toFrame<=s.fromFrame)throw Error(`Invalid source or edited scene ${s.id}`);
+  targetEnd=s.toFrame;
+  return {id:s.id,start:o.fromFrame/fps,end:o.toFrame/fps,duration:(s.toFrame-s.fromFrame)/fps,ratio:(s.toFrame-s.fromFrame)/(o.toFrame-o.fromFrame)};
+ });
+ for(const s of original.scenes){if(s.fromFrame!==sourceEnd)throw Error('Original scenes must be contiguous');sourceEnd=s.toFrame;}
+ if(Math.abs(edited.duration*fps-targetEnd)>.01||Math.abs(original.duration*fps-sourceEnd)>.01)throw Error('Board duration does not match scene frames');
+ return {segments,duration:targetEnd/fps,sourceDuration:sourceEnd/fps};
+}
+// atempo takes speed, inverse of scene length ratio. Chain when outside ffmpeg's portable [0.5,2] range.
+export function tempoFilters(ratio){if(!Number.isFinite(ratio)||ratio<=0)throw Error('Invalid stretch ratio');let speed=1/ratio,filters=[];
+ if(!Number.isFinite(speed)||speed<=0)throw Error('Invalid stretch ratio');
+ while(speed>2){filters.push('atempo=2');speed/=2;}
+ while(speed<.5){filters.push('atempo=0.5');speed*=2;}
+ filters.push(`atempo=${speed.toFixed(8)}`);return filters.join(',');
+}
+export function retimeAudio(a) {
+ if(!a.original||!a.edited||(!a.music&&!a.vo))throw Error('usage: timeline audio --original storyboard.json --edited storyboard.edited.json --music music.wav [--vo vo.wav] [--grid beatgrid.edited.json] --outDir audio/retimed');
+ const original=readJson(path.resolve(a.original)),edited=readJson(path.resolve(a.edited)),plan=audioPlan(original,edited);
+ const grid=a.grid?readJson(path.resolve(a.grid)):null;
+ const offset=Number(grid?.beatOffset??edited.beatOffset??0);
+ if(!Number.isFinite(offset)||Math.abs(offset)>60)throw Error('Invalid beat offset');
+ const dest=path.resolve(a.outDir||'audio/retimed');mkdirp(dest);
+ const outputs={};
+ for(const type of ['music','vo'])if(a[type]){
+  const input=path.resolve(a[type]);if(!fs.existsSync(input))throw Error(`Missing ${type}: ${input}`);
+  const info=probe(input),length=Number(info.format.duration);
+  if(!info.streams.some(s=>s.codec_type==='audio')||length+0.02<plan.sourceDuration)throw Error(`${type} must contain audio through the original board duration (${plan.sourceDuration}s)`);
+  // atrim/reset timestamps, stretch each scene, then force exact output sample counts
+  // so an imperfect tempo filter cannot drift between scenes or from the video.
+  const chains=plan.segments.map((s,i)=>`[0:a]atrim=start=${s.start}:end=${s.end},asetpts=PTS-STARTPTS,aresample=48000,${tempoFilters(s.ratio)},apad,atrim=duration=${s.duration},asetpts=PTS-STARTPTS[a${i}]`);
+  const n=plan.segments.length;let graph=`${chains.join(';')};${plan.segments.map((_,i)=>`[a${i}]`).join('')}concat=n=${n}:v=0:a=1`;
+  if(type==='music'&&offset){graph+=`,${offset>0?`adelay=${Math.round(offset*1000)}:all=1`:`atrim=start=${-offset},asetpts=PTS-STARTPTS`},apad,atrim=duration=${plan.duration}`;}
+  graph+=',aresample=48000[out]';
+  const output=path.join(dest,`${type}.wav`);ff(['-i',input,'-filter_complex',graph,'-map','[out]','-c:a','pcm_s24le',output]);outputs[type]=output;
+ }
+ return {files:outputs,duration:plan.duration,beatOffset:offset,segments:plan.segments,note:'Scene audio is reordered and tempo-stretched to edited timing. Music additionally follows beat offset. Listen to cuts and stretched voice; re-mix, approve a new mix review, then render with --audio. This does not change the original media files.'};
+}

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

@@ -0,0 +1,68 @@
+// SFX engine: 16 synthesized sounds, placed on timeline events, snapped to the beat grid.
+import * as D from './dsp.mjs';
+import * as V from './voices.mjs';
+const { SR } = D;
+
+// Default levels (dB) and high-pass (Hz). These are the tested pi-v2 values.
+export const SFX_RULES = {
+  word_pop: [-17, 300], icon_pop: [-14, 250], letter_tick: [-18, 400], check: [-12, 300], success: [-10, 250], slot_tick: [-18, 500],
+  bubble: [-15, 250], type: [-22, 500], button: [-14, 300], whoosh_in: [-9, 150], whoosh_out: [-10, 150], swoosh: [-11, 150],
+  riser: [-8, 120], impact: [-6, 20], confetti: [-16, 400], logo_sting: [-8, 200],
+};
+export const SFX_TYPES = Object.keys(SFX_RULES);
+
+// Packs change timbre, never the level table. pitch in semitones, bright = filter multiplier, decay = envelope multiplier.
+export const PACKS = {
+  'soft-pop':     { pitch: 0, bright: 1.0, decay: 1.0, room: 0.18 },
+  'glass':        { pitch: 5, bright: 1.4, decay: 0.7, room: 0.26 },
+  'paper':        { pitch: -3, bright: 0.7, decay: 1.4, room: 0.1 },
+  'digital-soft': { pitch: 2, bright: 1.2, decay: 1.2, room: 0.14 },
+  'organic-wood': { pitch: -5, bright: 0.8, decay: 1.1, room: 0.2 },
+};
+
+function bank(pk) {
+  const dk = pk.decay; const P = (x) => V.pitchShift(x, pk.pitch);
+  const B = {
+    word_pop: [0, 2, 4, 6].map((i) => V.sineBlip(1400 * 2 ** (i / 12), 700 * 2 ** (i / 12), 0.07, 55 * dk)),
+    icon_pop: [0, 1].map(() => { const a = V.sineBlip(900, 450, 0.12, 30 * dk); D.mixInto(a, V.chime([96], 0.12), 0.35); return a; }),
+    letter_tick: [V.sineBlip(2400, 1800, 0.03, 120), V.sineBlip(2600, 1900, 0.03, 120)],
+    check: [V.chime([84, 91], 0.9, 0.07)],
+    success: [V.chime([79, 84, 88, 91], 1.4, 0.06)],
+    slot_tick: [V.sineBlip(2000, 1500, 0.03, 150)],
+    bubble: [V.sineBlip(600, 1100, 0.09, 35 * dk, 0.05), V.sineBlip(700, 1250, 0.09, 35 * dk, 0.05)],
+    type: [0, 1, 2].map((i) => { const b = V.hat(); return D.gain(D.filt(b, 'bp', 3000 + i * 500, 1.2), 0.8); }),
+    button: [V.sineBlip(1200, 900, 0.05, 80)],
+    whoosh_in: [D.gain(V.noiseSweep(0.32, 400, 7000 * pk.bright, true, 0.8), 0.5)],
+    whoosh_out: [D.gain(V.noiseSweep(0.32, 7000 * pk.bright, 400, false, 0.8), 0.5)],
+    swoosh: [D.gain(V.noiseSweep(0.45, 2500 * pk.bright, 600, false, 1.5), 0.4)],
+    riser: [D.gain(V.noiseSweep(1.8, 250, 9000 * pk.bright, true, 1.0), 0.6)],
+    impact: [D.gain(V.deepKick(1.3), 0.9)],
+    confetti: [0, 1, 2].map((i) => V.chime([100 + i, 103 + i], 0.3, 0.02)),
+    logo_sting: [D.gain(V.chime([77, 84, 89, 96], 2.0, 0.05), 0.8)],
+  };
+  for (const k of Object.keys(B)) if (!['impact', 'riser', 'whoosh_in', 'whoosh_out', 'swoosh'].includes(k)) B[k] = B[k].map(P);
+  return B;
+}
+
+// cues: [{type, t, gain?, pitch?, pan?, end? (riser), snap?}]
+export function renderSfx(cues, dur, { bpm = null, pack = 'soft-pop', density = 1, seed = 11 } = {}) {
+  D.setSeed(seed); const pk = PACKS[pack] || PACKS['soft-pop']; const B = bank(pk);
+  const n = Math.round(dur * SR), out = D.stereo(n), grid = bpm ? 60 / bpm / 4 : null; const count = {}; const warnings = []; let lastLoud = -1;
+  const sorted = [...cues].sort((a, b) => a.t - b.t);
+  for (const c of sorted) {
+    const typ = c.type; if (!B[typ]) { warnings.push(`unknown sfx type ${typ}`); continue; }
+    if (density < 1 && ['word_pop', 'letter_tick', 'type', 'slot_tick'].includes(typ) && D.rand() > density) continue;
+    let t = c.t;
+    if (typ === 'riser' && c.end != null) t = c.end - 1.8;
+    else if (grid && c.snap !== false) { const s = Math.round(t / grid) * grid; if (Math.abs(s - t) < 0.045) t = s; }
+    const [g0, hp] = SFX_RULES[typ]; const g = g0 + (c.gain || 0);
+    if (g > -12 && lastLoud >= 0 && t - lastLoud < 0.12) warnings.push(`two loud sfx within 120 ms at ${t.toFixed(2)}s`);
+    if (g > -12) lastLoud = t;
+    const i = count[typ] = (count[typ] || 0) + 1; let x = B[typ][(i - 1) % B[typ].length];
+    if (c.pitch) x = V.pitchShift(x, c.pitch);
+    x = D.filt(x, 'hp', hp);
+    D.place(out, x, Math.max(0, t), D.db(g), c.pan || 0);
+  }
+  const wet = D.reverb(out, 0.2, 0.6, pk.room); D.mixInto(out, wet);
+  return { buf: out, warnings };
+}

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

@@ -0,0 +1,44 @@
+// Style validator: blocks combinations that look cheap, explains why, suggests a fix.
+import fs from 'node:fs';
+import path from 'node:path';
+import { readJson, die, SKILL_DIR } from './util.mjs';
+const SLOP_FONTS = ['inter', 'roboto', 'arial', 'helvetica', 'poppins', 'montserrat', 'open sans'];
+const hex = (h) => [1, 3, 5].map((i) => parseInt(h.slice(i, i + 2), 16) / 255);
+const lum = (h) => { const c = hex(h).map((v) => (v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4)); return 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]; };
+export const contrast = (a, b) => { const [x, y] = [lum(a), lum(b)].sort((p, q) => q - p); return (x + 0.05) / (y + 0.05); };
+export function checkStyle(t) {
+  const E = [], Wn = []; const add = (arr, rule, why, fix) => arr.push({ rule, why, fix });
+  const bg = t.color.bg[t.color.bg.length - 1];
+  const ci = contrast(t.color.ink, bg); if (ci < 4.5) add(E, 'ink contrast', `ink on background is ${ci.toFixed(2)}:1, needs >= 4.5:1`, 'darken ink or lighten background');
+  const ca = contrast(t.color.accent, bg); if (ca < 3) add(E, 'accent contrast', `accent on background is ${ca.toFixed(2)}:1; accent words are large, so >= 3:1 is the floor`, 'pick a deeper accent');
+  const cm = contrast(t.color.muted, bg); if (cm < 2.8) add(Wn, 'muted contrast', `muted text is ${cm.toFixed(2)}:1 - captions may disappear on phones`, 'darken muted');
+  if (SLOP_FONTS.includes(t.font.display.toLowerCase())) add(Wn, 'default font', `${t.font.display} is the most common AI-default font; the video will look generic`, 'Figtree, Manrope, Satoshi, General Sans, Geist, or a brand font');
+  const s = t.font.size; if (s.h0[0] / s.h1[1] < 1.5) add(E, 'hierarchy', 'h0 must be >= 1.5x h1 so the big moment reads as big', 'raise h0 or lower h1');
+  if (s.h1[0] / s.h2[1] < 1.35) add(E, 'hierarchy', 'h1 must be >= 1.35x h2', 'separate the sizes');
+  if (t.font.maxLines > 2) add(E, 'max lines', 'more than 2 lines of text on screen turns into reading, not watching', 'keep maxLines at 2');
+  const m = t.motion, L = m.limits;
+  if (m.word.inFrames < L.minEnterFrames || m.word.inFrames > L.maxEnterFrames) add(E, 'word timing', `word enter ${m.word.inFrames}f outside ${L.minEnterFrames}-${L.maxEnterFrames}f`, 'use 10-14f');
+  if (m.word.stagger[0] < L.minStagger) add(E, 'stagger', 'stagger under 2 frames reads as one blob', 'use 3-5 frames');
+  if (m.word.blur > 16 || m.card.blur > 20) add(Wn, 'blur', 'very large blur makes motion feel mushy', 'keep word blur ~10, card blur ~12');
+  const eo = t.ease.out; if (eo[0] === eo[1] && eo[2] === eo[3]) add(E, 'easing', 'linear easing on UI motion looks robotic', 'use [0.22,1,0.36,1] for enters');
+  if (m.camera.maxZoom > 1.3) add(Wn, 'camera', 'zoom over 1.3x crops text and makes collisions likely', 'cap at 1.2');
+  if (t.layout.safe.min < 48) add(E, 'safe area', 'margins under 48px get cut by phone UIs', 'min 60');
+  if ((t.color.glow || []).length > 2) add(Wn, 'glow', 'more than 2 background glows starts to look like the colored-blob AI look', 'max 2, same hue family');
+  return { style: t.name, pass: E.length === 0, errors: E, warnings: Wn };
+}
+export function cmdStyle(a) {
+  const sub = a._[0];
+  if (sub === 'list') return { styles: fs.readdirSync(path.join(SKILL_DIR, 'styles')).map((s) => ({ id: s, description: readJson(path.join(SKILL_DIR, 'styles', s, 'tokens.json'))?.description })) };
+  if (sub === 'check') { const f = a._[1] ? path.resolve(a._[1]) : fs.existsSync('src/style.json') ? path.resolve('src/style.json') : path.join(SKILL_DIR, 'styles', 'pi-v2', 'tokens.json'); const t = readJson(f) || die(`cannot read ${f}`); return checkStyle(t); }
+  if (sub === 'knobs') { // apply knob values to a tokens file -> new tokens (never edits components)
+    const f = path.resolve(a._[1] || 'src/style.json'); const t = readJson(f) || die(`cannot read ${f}`); const k = { ...t.knobs }; for (const n of ['energy', 'density', 'warmth', 'roundness', 'depth']) if (a[n] != null) k[n] = Math.max(0, Math.min(1, +a[n])); if (a.camera) k.camera = a.camera;
+    const e = k.energy; const sp = 1.25 - e * 0.5; // energy 0 -> slower, 1 -> faster
+    t.motion.word.inFrames = Math.round(12 * sp); t.motion.word.stagger = [Math.max(2, Math.round(4.5 * sp)), Math.max(3, Math.round(5 * sp))]; t.motion.card.frames = Math.round(24 * sp); t.motion.scene.overlap = Math.round(17 * sp);
+    t.motion.word.spring.damping = +(11 + (0.5 - e) * 4).toFixed(1); t.motion.camera.drift = k.camera === 'still' ? 0 : k.camera === 'active' ? 12 : 8;
+    t.shape.cardRadius = Math.round(10 + k.roundness * 20); t.motion.card.rotateX = +(k.depth * 17).toFixed(1);
+    const warm = k.warmth; t.color.bg = warm > 0.6 ? ['#faf8f5', '#f8f5f0', '#f3ece2'] : warm < 0.25 ? ['#f6f8fb', '#f2f5fa', '#e6eef9'] : t.color.bg;
+    t.audio.sfxPerMinute = [Math.round(80 + e * 80), Math.round(120 + e * 100)]; t.knobs = k;
+    const o = path.resolve(a.out || f); fs.writeFileSync(o, JSON.stringify(t, null, 2)); return { written: o, knobs: k, check: checkStyle(t) };
+  }
+  die('usage: style list | check [tokens.json] | knobs [tokens.json] --energy 0.7 --warmth 0.5 ...');
+}

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

@@ -0,0 +1,34 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import {readJson,writeJson,die} from './util.mjs';
+const launch={id:'ProductLaunch',duration:45,min:30,max:60,required:['product','problem','feature1','feature2','cta','handle','demoDir','demoCount','demoCredit'],asset:'demo'};
+const tutorial={id:'ScreenTutorial',duration:60,min:30,max:90,required:['title','handle','captureDir','captureCount','sourceCredit','steps'],asset:'capture'};
+export function templatePlan(a){
+ const kind=a._[0],model=kind==='launch'?launch:kind==='tutorial'?tutorial:null;if(!model)die('usage: template launch|tutorial --spec props.json --dir project');
+ if(a._[1]==='fields')return model;
+ const file=path.resolve(a.spec||`${kind}-props.json`),p=readJson(file);if(!p||typeof p!=='object')die(`read ${file} first`);
+ const issues=model.required.filter(k=>p[k]===undefined||p[k]===null||p[k]==='').map(k=>`missing ${k}`);
+ const duration=Number(a.duration??p.duration??model.duration);
+ if(!Number.isFinite(duration)||duration<model.min||duration>model.max)issues.push(`duration must be ${model.min}-${model.max}s`);
+ const dir=path.resolve(a.dir||'.');let data=null;
+ if(model===tutorial){if(!Array.isArray(p.steps)||!p.steps.length)issues.push('steps required');else{
+  let end=0;for(const [i,s] of p.steps.entries()){
+   if(typeof s.title!=='string'||!s.title.trim()||typeof s.caption!=='string'||!s.caption.trim())issues.push(`step ${i+1} needs title and caption`);
+   if(!Number.isFinite(s.from)||!Number.isFinite(s.to)||Math.abs(s.from-end)>0.001||s.to<=s.from||s.to>duration)issues.push(`step ${i+1} has invalid time; expected start ${end}`);
+   if(!Number.isFinite(s.x)||!Number.isFinite(s.y)||s.x<.12||s.x>.88||s.y<.12||s.y>.85)issues.push(`step ${i+1} pointer must be within safe fractional x/y bounds`);
+   if(s.zoom!=null&&(s.zoom<1||s.zoom>1.6))issues.push(`step ${i+1} zoom must be 1-1.6`);end=s.to;
+  }if(Math.abs(end-duration)>.001)issues.push(`steps must finish at duration ${duration}s`);
+ }}
+ if(p.audio){const audio=path.resolve(dir,'public',p.audio);if(!audio.startsWith(path.resolve(dir,'public')+path.sep)||!fs.existsSync(audio))issues.push('audio missing or outside public');}
+ const name=model===launch?p.demoDir:p.captureDir,count=model===launch?p.demoCount:p.captureCount;
+ if(name){const folder=path.resolve(dir,'public',name);if(!folder.startsWith(path.resolve(dir,'public')+path.sep))issues.push('frames path outside project public folder');
+ else if(!Number.isInteger(count)||count<1)issues.push('frame count needs a positive integer');
+ else if(!fs.existsSync(folder))issues.push(`frame folder missing: ${folder}`);
+ else for(let i=1;i<=count;i++)if(!fs.existsSync(path.join(folder,`${String(i).padStart(3,'0')}.jpg`))) {issues.push(`frame ${i} missing`);break;}
+ }
+ if(model===tutorial&&(!Number.isFinite(Number(p.captureFps??30))||Number(p.captureFps??30)<=0||Number(p.captureFps??30)>120))issues.push('captureFps must be 1-120');
+ if(model===tutorial&&Number.isFinite(duration)&&Number.isInteger(count)&&count<Math.ceil(duration*(Number(p.captureFps)||30)))issues.push('captureCount too short for duration * captureFps');
+ if(model===launch&&Number.isFinite(duration)&&Number.isInteger(count)&&count<Math.ceil(18*30))issues.push('demoCount too short for 18s demonstration at 30 fps');
+ if(a.out&&issues.length===0){const dest=path.resolve(a.out);writeJson(dest,{...p,duration});data=dest;}
+ return {template:model.id,duration,pass:issues.length===0,issues,props:data,note:'This checks fields and numbered JPGs only. It does not verify capture authenticity, source rights, readable UI, captions, visual motion, or factual claims. Preview final frames and listen to audio.'};
+}

package/vendor/motioncraft/scripts/lib/timeline-editor.mjs

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {readJson,die,writeJson} from './util.mjs';
+
+// The exported board is an edit decision, not a mutation of a Remotion composition.
+export function retimeBoard(board, edits) {
+ const fps=Number(board?.fps), scenes=board?.scenes;
+ if(!Number.isInteger(fps)||fps<1||!Array.isArray(scenes)||!scenes.length)throw Error('board needs fps and scenes');
+ const byId=new Map(scenes.map(s=>[s.id,s]));
+ if(byId.size!==scenes.length||scenes.some(s=>!s.id))throw Error('scene IDs must be unique');
+ if(edits.length!==scenes.length||new Set(edits.map(e=>e.id)).size!==scenes.length||edits.some(e=>!byId.has(e.id)))throw Error('edits must include every scene exactly once');
+ let frame=0;
+ const next=edits.map(e=>{
+  const original=byId.get(e.id), duration=Number(e.duration), frames=Math.round(duration*fps);
+  if(!Number.isFinite(duration)||duration<0.8||!Number.isSafeInteger(frames))throw Error(`invalid duration for ${e.id}`);
+  const oldStart=Number(original.start),oldEnd=Number(original.end),oldLength=oldEnd-oldStart;
+  if(!Number.isFinite(oldLength)||oldLength<=0)throw Error(`invalid original scene ${e.id}`);
+  const shift=t=>+(frame/fps+(Number(t)-oldStart)*frames/fps/oldLength).toFixed(3);
+  const shiftEvent=event=>{
+   const out={...event};
+   for(const k of ['at','t'])if(event[k]!=null)out[k]=shift(event[k]);
+   if(event.frame!=null)out.frame=Math.round(shift(Number(event.frame)/fps)*fps);
+   return out;
+  };
+  const oldPreview=Number(original.previewFrame), ratio=Number.isFinite(oldPreview)?(oldPreview-Number(original.fromFrame))/(Number(original.toFrame)-Number(original.fromFrame)):0.7;
+  const s={...original,fromFrame:frame,toFrame:frame+frames,start:+(frame/fps).toFixed(3),end:+((frame+frames)/fps).toFixed(3),previewFrame:frame+Math.min(frames-1,Math.max(0,Math.round(ratio*frames)))};
+  if(Array.isArray(s.events))s.events=s.events.map(shiftEvent);
+  if(Array.isArray(s.animations))s.animations=s.animations.map(shiftEvent);
+  frame+=frames; return s;
+ });
+ return {...board,duration:+(frame/fps).toFixed(3),scenes:next};
+}
+export function shiftBeatGrid(grid, offset, duration) {
+ const n=Number(offset);if(!Number.isFinite(n)||Math.abs(n)>60)throw Error('beat offset must be between -60 and 60 seconds');
+ const shift=a=>a.map(t=>+(Number(t)+n).toFixed(3)).filter(t=>Number.isFinite(t)&&t>=0&&t<duration);
+ return {...grid,duration,beatOffset:n,beats:shift(grid.beats||[]),sections:Array.isArray(grid.sections)?grid.sections.map(s=>typeof s==='number'?+(s+n).toFixed(3):{...s,t:s.t==null?s.t:+(Number(s.t)+n).toFixed(3)}):grid.sections};
+}
+export function timelineEditor(a){
+ const source=path.resolve(a.board||'storyboard.json'),board=readJson(source);
+ if(!board?.scenes?.length)die(`cannot read storyboard scenes: ${source}`);
+ const grid=a.grid?readJson(path.resolve(a.grid)):null;
+ if(a.grid && !grid)die(`cannot read beat grid: ${a.grid}`);
+ try{retimeBoard(board,board.scenes.map(s=>({id:s.id,duration:s.end-s.start})));}catch(e){die(e.message);}
+ const data=JSON.stringify({board,grid}).replace(/</g,'\\u003c');
+ const script=fs.readFileSync(new URL('../assets/timeline-editor.js',import.meta.url),'utf8');
+ const html=`<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>MotionCraft timeline editor</title><style>
+ :root{font-family:system-ui,sans-serif;color:#e8edf7;background:#111827}body{max-width:900px;margin:35px auto;padding:0 20px}h1{font-size:28px}p{color:#aab8ce;line-height:1.5}.row{display:flex;align-items:center;gap:14px;background:#243247;border:1px solid #465a76;padding:14px;margin:8px 0;border-radius:10px}.row.dragging{opacity:.45}.handle{cursor:grab;font-size:25px}.name{flex:1}.name small{display:block;color:#aab8ce}input{width:72px;padding:7px;background:#111827;color:white;border:1px solid #789;border-radius:5px}button{padding:10px 14px;margin:8px 8px 8px 0;background:#72bcf5;color:#102033;border:0;border-radius:6px;font-weight:700;cursor:pointer}button:focus,input:focus{outline:2px solid #ffa86c}#error{color:#ffaaa0}code{color:#b3dafa}</style>
+ <h1>MotionCraft timeline editor</h1><p>Drag scenes to reorder. Change each duration in seconds. Shift the beat grid by a signed offset. Export both files, then review the updated storyboard against your Remotion composition before rendering. Main, MainVertical, ProductLaunch, ScreenTutorial, TimelineLaunch and TimelineTutorial render this exported timing plan without code edits.</p>
+ <main id="list"></main><label>Beat offset (seconds) <input id="beat" type="number" step="0.01" value="0"></label><p id="summary"></p><p id="error" role="alert"></p><button id="export">Export storyboard and beat grid</button>
+ <p>Render with <code>--comp Main|ProductLaunch|ScreenTutorial|TimelineLaunch|TimelineTutorial --timeline storyboard.edited.json --grid beatgrid.edited.json</code>. Run timeline audio with original and edited boards; re-mix and review audio and footage.</p><script type="application/json" id="data">${data}</script><script>${script.replace(/<\/script/gi,'<\\/script')}</script></html>`;
+ const dest=path.resolve(a.out||'timeline-editor.html');fs.mkdirSync(path.dirname(dest),{recursive:true});fs.writeFileSync(dest,html);
+ return {editor:dest,scenes:board.scenes.length,note:'Open the HTML locally in a browser. Export JSON and render the matching composition with --timeline. Run timeline audio for scene-synced media and review cuts; other footage needs independent sync review.'};
+}
+
+const presets={
+ main:[['hook',3.4],['reframe',4.2],['proof',4.4],['formula',3.2],['cta',2.4],['end',2.4]],
+ 'product-launch':[['problem',8],['demo',19],['features',12],['cta',6]],
+ 'screen-tutorial':[['step',20],['step',20],['step',20]],
+ launch:[['problem',8],['demo',19],['features',12],['cta',6]],
+ tutorial:[['intro',5],['step',10],['step',10],['outro',5]]
+};
+export function timelineInit(a){
+ const kind=String(a._[1]||a.kind||'');if(!presets[kind])die('timeline init needs main|product-launch|screen-tutorial|launch|tutorial');
+ const fps=30;let frame=0;const scenes=presets[kind].map(([role,seconds],i)=>{const begin=frame;frame+=seconds*fps;return {id:(kind==='tutorial'||kind==='screen-tutorial')&&role==='step'?`step-${i}`:role,role,headline:({problem:'A real problem',demo:'Product in action',features:'What changes',cta:'Try it',intro:'A clear tutorial',step:`Step ${i}`,outro:'Review',hook:'Make videos like this',reframe:'References',proof:'Give feedback until it fits',formula:'The formula',end:'Follow for more'})[role],fromFrame:begin,toFrame:frame,start:begin/fps,end:frame/fps,previewFrame:begin+Math.floor(seconds*fps*.7),sourceFromFrame:begin,sourceToFrame:frame}});
+ const file=path.resolve(a.out||`timeline-${kind}.json`);writeJson(file,{version:1,kind,fps,duration:frame/fps,scenes});return {board:file,kind,scenes:scenes.length};
+}
+export function validateRenderBoard(board,kind){
+ if(!['launch','tutorial','main','product-launch','screen-tutorial'].includes(kind))throw Error('unsupported timeline composition');
+ const allowed=kind==='launch'||kind==='product-launch'?new Set(['problem','demo','features','cta']):kind==='main'?new Set(['hook','reframe','proof','formula','cta','end']):new Set(['intro','step','outro']);
+ if(!board||board.fps!==30||!Array.isArray(board.scenes)||board.scenes.length<2||board.scenes.length>12)throw Error('timeline needs 30 fps and 2-12 scenes');
+ let end=0;const ids=new Set();for(const s of board.scenes){if(!s.id||ids.has(s.id)||!allowed.has(s.role)||s.fromFrame!==end||!Number.isInteger(s.toFrame)||s.toFrame-s.fromFrame<24 || (['main','product-launch','screen-tutorial'].includes(kind)&&(!Number.isInteger(s.sourceFromFrame)||!Number.isInteger(s.sourceToFrame)||s.sourceToFrame<=s.sourceFromFrame||s.sourceFromFrame<0||s.sourceToFrame>(kind==='main'?600:kind==='product-launch'?1350:1800))))throw Error(`invalid or noncontiguous timeline scene ${s.id||''}`);ids.add(s.id);end=s.toFrame;}
+ if(['main','product-launch','screen-tutorial'].includes(kind)){const sources=[...board.scenes].sort((a,b)=>a.sourceFromFrame-b.sourceFromFrame);let pos=0;for(const scene of sources){if(scene.sourceFromFrame!==pos)throw Error('legacy source scenes must cover original composition once, with no gaps or overlaps');pos=scene.sourceToFrame;}if(pos!==(kind==='main'?600:kind==='product-launch'?1350:1800))throw Error('legacy source scenes must cover the original composition duration');}
+ if(Math.abs(board.duration*30-end)>.01)throw Error('timeline duration differs from scene frames');return board;
+}

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

@@ -0,0 +1,45 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+export const SKILL_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+export const log = (...a) => console.error('[motioncraft]', ...a);
+export const out = (obj) => process.stdout.write(JSON.stringify(obj, null, 2) + '\n');
+export function die(msg, hint) { console.error(`\n✖ ${msg}` + (hint ? `\n  → ${hint}` : '')); process.exit(1); }
+export function has(cmd, args = ['--version']) { try { const r = spawnSync(cmd, args, { encoding: 'utf8', shell: process.platform === 'win32', timeout: 20000 }); return r.status === 0 ? (r.stdout || r.stderr || '').trim() : null; } catch { return null; } }
+export function run(cmd, args, opts = {}) {
+  const r = spawnSync(cmd, args, { encoding: 'utf8', maxBuffer: 1 << 28, shell: process.platform === 'win32', ...opts });
+  if (r.error) throw r.error; return r;
+}
+export function parseArgs(argv) {
+  const a = { _: [] };
+  for (let i = 0; i < argv.length; i++) { const t = argv[i];
+    if (t.startsWith('--')) { const [k, v] = t.slice(2).split('='); if (v !== undefined) a[k] = v; else if (argv[i + 1] && !argv[i + 1].startsWith('--')) a[k] = argv[++i]; else a[k] = true; }
+    else a._.push(t); }
+  return a;
+}
+export const readJson = (p, d) => { try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return d; } };
+export const writeJson = (p, o) => { fs.mkdirSync(path.dirname(p), { recursive: true }); fs.writeFileSync(p, JSON.stringify(o, null, 2)); };
+export const mkdirp = (p) => fs.mkdirSync(p, { recursive: true });
+export const workDir = (a) => path.resolve(a.dir || process.cwd());
+export const stateDir = (a) => { const d = path.join(workDir(a), '.motioncraft'); mkdirp(d); return d; };
+
+// ffmpeg resolution: system binary first, then Remotion's bundled one (v4+, limited codecs).
+let FF = null;
+export function ffmpeg() {
+  if (FF) return FF;
+  if (has('ffmpeg', ['-version'])) FF = { ff: ['ffmpeg'], fp: ['ffprobe'], source: 'system' };
+  else if (has('npx', ['--no-install', 'remotion', 'ffmpeg', '-version'])) FF = { ff: ['npx', '--no-install', 'remotion', 'ffmpeg'], fp: ['npx', '--no-install', 'remotion', 'ffprobe'], source: 'remotion-bundled' };
+  else die('ffmpeg not found (neither system ffmpeg nor Remotion\'s bundled one).', 'Run `node scripts/motioncraft.mjs doctor` to see install options, or run this inside a Remotion project (npx remotion ffmpeg).');
+  return FF;
+}
+export function ff(args, opts) { const F = ffmpeg(); const r = run(F.ff[0], [...F.ff.slice(1), '-hide_banner', '-y', ...args], opts); if (r.status !== 0) die('ffmpeg failed: ' + (r.stderr || '').split('\n').slice(-6).join('\n')); return r; }
+export function probe(file) {
+  const F = ffmpeg(); const r = run(F.fp[0], [...F.fp.slice(1), '-v', 'error', '-print_format', 'json', '-show_format', '-show_streams', file]);
+  if (r.status !== 0) die('ffprobe failed on ' + file); return JSON.parse(r.stdout);
+}
+// decode any audio to 48k stereo wav with ffmpeg (so the pure-JS analyzers only ever see one format)
+export function toWav48(input, tmpName = 'a48.wav') { const o = path.join(os.tmpdir(), `mc-${process.pid}-${tmpName}`); ff(['-i', input, '-vn', '-ac', '2', '-ar', '48000', '-c:a', 'pcm_s16le', o]); return o; }
+export const fmtTime = (s) => `${Math.floor(s / 60)}:${(s % 60).toFixed(2).padStart(5, '0')}`;

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

@@ -0,0 +1,85 @@
+// Synth voices - everything is generated here, no samples, no licensing questions.
+import { SR, adsr, midiHz, rand, randn, fromMono, filt, biquadCoefs, biquadMono, stereo } from './dsp.mjs';
+
+const N = (d) => Math.max(1, Math.round(d * SR));
+
+export function epNote(midi, dur, vel = 0.8, bright = 1) { // FM electric piano
+  const n = N(dur), f = midiHz(midi), e = adsr(n, 0.002, 0.05, 1, 0.08), x = new Float32Array(n);
+  for (let i = 0; i < n; i++) { const t = i / SR;
+    const mod = Math.sin(2 * Math.PI * f * t) * (1.1 * bright * Math.exp(-t * 6) + 0.3) + Math.sin(2 * Math.PI * f * 7 * t) * 0.12 * bright * Math.exp(-t * 25);
+    x[i] = Math.sin(2 * Math.PI * f * t + mod) * Math.exp(-t * 2.2) * vel * e[i]; }
+  return fromMono(x);
+}
+export function supersaw(midis, dur, { voices = 3, spread = 0.007, bright = 1600, env = [0.4, 0.3, 0.8, 0.5] } = {}) {
+  const n = N(dur), L = new Float32Array(n), R = new Float32Array(n);
+  for (const m of midis) { const f = midiHz(m);
+    for (let v = 0; v < voices; v++) { const d = voices > 1 ? spread * (v - (voices - 1) / 2) / ((voices - 1) / 2) : 0; const p = voices > 1 ? (v / (voices - 1)) * 2 - 1 : 0; const ph = rand();
+      for (let i = 0; i < n; i++) { const s = 2 * ((f * (1 + d) * i / SR + ph) % 1) - 1; L[i] += s * (1 - p) / 2; R[i] += s * (1 + p) / 2; } } }
+  const k = 2.2 / (midis.length * voices); let b = { L, R }; b = filt(b, 'lp', bright, 0.707); b = filt(b, 'lp', bright * 1.3, 0.707);
+  const e = adsr(n, ...env); for (let i = 0; i < n; i++) { b.L[i] *= e[i] * k; b.R[i] *= e[i] * k; }
+  return b;
+}
+export function roundBass(freq, dur) {
+  const n = N(dur), e = adsr(n, 0.006, 0.15, 0.75, 0.06), x = new Float32Array(n);
+  for (let i = 0; i < n; i++) { const t = i / SR; const v = Math.sin(2 * Math.PI * freq * t) + 0.18 * Math.sin(4 * Math.PI * freq * t) + 0.06 * Math.sin(6 * Math.PI * freq * t); x[i] = Math.tanh(v * 1.1) * e[i]; }
+  return fromMono(x);
+}
+export function softKick(dur = 0.35, tone = 52) {
+  const n = N(dur), x = new Float32Array(n); let ph = 0;
+  for (let i = 0; i < n; i++) { const t = i / SR; const f = tone + 90 * Math.exp(-t * 45); ph += 2 * Math.PI * f / SR; x[i] = Math.tanh((Math.sin(ph) * Math.exp(-t * 11) + randn() * Math.exp(-t * 1200) * 0.12) * 1.3); }
+  return fromMono(x);
+}
+export function deepKick(dur = 0.6) { // for heavier presets / impact
+  const n = N(dur), x = new Float32Array(n); let ph = 0;
+  for (let i = 0; i < n; i++) { const t = i / SR; const f = 44 + 240 * Math.exp(-t * 38); ph += 2 * Math.PI * f / SR; x[i] = Math.tanh((Math.sin(ph) * Math.exp(-t * 5.5) + randn() * Math.exp(-t * 900) * 0.3) * 1.8) / Math.tanh(1.8); }
+  return fromMono(x);
+}
+function noiseBurst(dur, decay, type, f, q) { const n = N(dur), x = new Float32Array(n); for (let i = 0; i < n; i++) x[i] = randn() * Math.exp(-(i / SR) * decay); return biquadMono(x, biquadCoefs(type, f, q)); }
+export function snap() { const a = noiseBurst(0.18, 38, 'bp', 1900, 1.4); const b = noiseBurst(0.18, 60, 'hp', 3500, 0.7); const x = new Float32Array(a.length); for (let i = 0; i < x.length; i++) x[i] = a[i] * 0.8 + b[i] * 0.4; return norm(fromMono(x)); }
+export function clap() { // 3 fast bursts + tail
+  const n = N(0.3), x = new Float32Array(n);
+  for (const off of [0, 0.011, 0.022]) { const o = Math.round(off * SR); for (let i = 0; i + o < n; i++) x[i + o] += randn() * Math.exp(-(i / SR) * (off < 0.02 ? 180 : 22)); }
+  return norm(fromMono(biquadMono(x, biquadCoefs('bp', 1300, 0.9))));
+}
+export function hat(open = false) { const x = noiseBurst(open ? 0.35 : 0.06, open ? 9 : 70, 'hp', 7500, 0.7); return norm(fromMono(biquadMono(x, biquadCoefs('peak', 10000, 1, 4)))); }
+export function shaker() { const n = N(0.09), x = new Float32Array(n); for (let i = 0; i < n; i++) { const t = i / SR; x[i] = randn() * Math.min(1, t * 300) * Math.exp(-t * 45); } return norm(fromMono(biquadMono(x, biquadCoefs('hp', 5000, 0.8)))); }
+export function marimba(midi, dur = 0.8, vel = 0.7) {
+  const n = N(dur), f = midiHz(midi), e = adsr(n, 0.001, 0.02, 1, 0.05), x = new Float32Array(n);
+  for (let i = 0; i < n; i++) { const t = i / SR; x[i] = (Math.sin(2 * Math.PI * f * t + 0.8 * Math.exp(-t * 30) * Math.sin(2 * Math.PI * f * 4 * t)) * Math.exp(-t * 5.5) + 0.15 * Math.sin(2 * Math.PI * f * 3.99 * t) * Math.exp(-t * 18)) * vel * e[i]; }
+  return fromMono(x);
+}
+export function glock(midi, dur = 1.2, vel = 0.6) {
+  const n = N(dur), f = midiHz(midi), x = new Float32Array(n);
+  for (let i = 0; i < n; i++) { const t = i / SR; x[i] = (Math.sin(2 * Math.PI * f * t) + 0.3 * Math.sin(2 * Math.PI * f * 2.01 * t) * Math.exp(-t * 6) + 0.12 * Math.sin(2 * Math.PI * f * 3.98 * t) * Math.exp(-t * 10)) * Math.exp(-t * 3.5) * vel * Math.min(1, t * 2000); }
+  return fromMono(x);
+}
+export function pluck(midi, dur = 0.8, bright = 0.5) { // Karplus-Strong
+  const n = N(dur), f = midiHz(midi), P = Math.max(2, Math.round(SR / f)), buf = new Float32Array(P), x = new Float32Array(n), k = 0.5 + 0.49 * bright;
+  for (let i = 0; i < P; i++) buf[i] = rand() * 2 - 1;
+  for (let i = 0; i < n; i++) { const j = i % P; x[i] = buf[j]; buf[j] = (k * buf[j] + (1 - k) * buf[(j + 1) % P]) * 0.996; }
+  const e = adsr(n, 0.001, 0.05, 1, 0.03); for (let i = 0; i < n; i++) x[i] *= e[i];
+  return fromMono(x);
+}
+export function sineBlip(f0, f1, dur, decay = 40, harm = 0.15) {
+  const n = N(dur), x = new Float32Array(n), e = adsr(n, 0.001, 0.01, 1, 0.005); let ph = 0;
+  for (let i = 0; i < n; i++) { const t = i / SR; const f = f1 + (f0 - f1) * Math.exp(-t * 60); ph += 2 * Math.PI * f / SR; x[i] = (Math.sin(ph) + harm * Math.sin(2 * ph)) * Math.exp(-t * decay) * e[i]; }
+  return fromMono(x);
+}
+export function chime(midis, dur = 1.2, spacing = 0.06) {
+  const n = N(dur), out = stereo(n);
+  midis.forEach((m, k) => { const f = midiHz(m), o = Math.round(k * spacing * SR), p = midis.length > 1 ? -0.3 + 0.6 * k / (midis.length - 1) : 0;
+    const l = Math.cos((p + 1) * Math.PI / 4) * Math.SQRT2 * 0.5, r = Math.sin((p + 1) * Math.PI / 4) * Math.SQRT2 * 0.5;
+    for (let i = 0; i + o < n; i++) { const t = i / SR; const v = (Math.sin(2 * Math.PI * f * t) + 0.3 * Math.sin(2 * Math.PI * f * 2.01 * t) + 0.12 * Math.sin(2 * Math.PI * f * 3.98 * t)) * Math.exp(-t * 4.5); out.L[i + o] += v * l; out.R[i + o] += v * r; } });
+  return out;
+}
+export function noiseSweep(dur, f0, f1, rise = true, q = 1.2) {
+  const n = N(dur), L = new Float32Array(n), R = new Float32Array(n), blk = 256;
+  for (const X of [L, R]) { let x1 = 0, x2 = 0, y1 = 0, y2 = 0;
+    for (let s = 0; s < n; s += blk) { const fc = f0 * Math.pow(f1 / f0, s / n); const [b0, b1, b2, a1, a2] = biquadCoefs('bp', fc, q);
+      for (let i = s; i < Math.min(n, s + blk); i++) { const xin = randn(); const v = b0 * xin + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2; x2 = x1; x1 = xin; y2 = y1; y1 = v; X[i] = v; } } }
+  for (let i = 0; i < n; i++) { const fr = i / n; const e = rise ? fr * fr : Math.pow(1 - fr, 1.5); L[i] *= e; R[i] *= e; }
+  return norm({ L, R });
+}
+export function swell(dur, midis) { const b = supersaw(midis, dur, { voices: 3, spread: 0.006, bright: 1800, env: [dur * 0.9, 0.01, 1, dur * 0.08] }); const n = b.L.length; for (let i = 0; i < n; i++) { const g = (i / n) ** 2; b.L[i] *= g; b.R[i] *= g; } return b; }
+export function norm(b, to = 1) { let p = 0; for (let i = 0; i < b.L.length; i++) p = Math.max(p, Math.abs(b.L[i]), Math.abs(b.R[i])); const g = to / (p + 1e-9); for (let i = 0; i < b.L.length; i++) { b.L[i] *= g; b.R[i] *= g; } return b; }
+export function pitchShift(b, semis) { if (!semis) return b; const r = Math.pow(2, semis / 12), n = Math.floor(b.L.length / r), o = stereo(n); for (let i = 0; i < n; i++) { const p = i * r, k = Math.floor(p), f = p - k; for (const c of ['L', 'R']) o[c][i] = (b[c][k] || 0) * (1 - f) + (b[c][k + 1] || 0) * f; } return o; }

package/vendor/motioncraft/scripts/motioncraft.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+// motioncraft - one entry point for every tool in the skill. Pure Node 18+, no npm install needed.
+import { parseArgs, out, die } from './lib/util.mjs';
+import { doctor, printDoctor } from './lib/doctor.mjs';
+import * as C from './lib/commands.mjs';
+import { qaFile, qaAudio, qaSheet, qaOverlap } from './lib/qa.mjs';
+import {qaFull} from './lib/qa-full.mjs';
+import {qaPixels} from './lib/qa-pixels.mjs';
+import { cmdRender } from './lib/render.mjs';
+import { cmdStyle } from './lib/style.mjs';
+import {storyboard, preview, cache3d} from './lib/phase1.mjs';
+import {autoCues,moodOptions,mixReview} from './lib/phase2.mjs';
+import {templatePlan} from './lib/templates.mjs';
+import {timelineEditor,timelineInit} from './lib/timeline-editor.mjs';
+import {retimeAudio} from './lib/retime-audio.mjs';
+import {checkUpdate} from './lib/check-update.mjs';
+import {gpuPreflight,workerManifest,workerVerify} from './lib/render-worker.mjs';
+
+const HELP = `motioncraft <command> [options]      (all output is JSON unless noted)
+
+  check-update                         compare installed SKILL.md version with latest GitHub release
+  doctor [--quick]                     check the machine; never installs (prints a table)
+  new <folder> [--style pi-v2] [--format 1:1|4:5|9:16] [--platform ig-feed|reels|tiktok] [--handle @you]   copy the Remotion template
+  style list | check [tokens.json] | knobs [tokens.json] --energy 0-1 --density 0-1 --warmth 0-1 --roundness 0-1 --depth 0-1 --camera still|smooth|active
+  ref get <url|file> | scenes | frames [--every 0.5] | sheet | motion | colors | audio | text | report   [--dir ref]
+  audio analyze <file> [--out a.json] [--full]      BPM, beats, onsets, key, LUFS, true peak, drop, silences
+  vo clean <file> | align <file> [--script script.txt] [--lang id] [--out audio/words.json]
+  music presets | make [--preset dreamy] [--duration 52] [--drop 12.9] [--key D] [--bpm 93] [--spec music.json] [--stems] [--out audio]
+  music audition [...same]             3 x 16 s variations to choose from
+  sfx list | make --cues sfx.json [--bpm 93] [--pack soft-pop] [--density 1] [--out audio/sfx.wav]
+  mix --vo vo.wav --music audio/music.wav --sfx audio/sfx.wav [--duration 52] [--out audio/final.wav]
+  beat grid --bpm 93 --dur 52.6 | snap cues.json [--grid audio/beatgrid.json] [--maxMs 80]
+  timeline init main|product-launch|screen-tutorial|launch|tutorial [--out timeline-launch.json]
+  timeline edit --board storyboard.json [--grid audio/beatgrid.json] [--out timeline-editor.html]
+  timeline audio --original original.json --edited storyboard.edited.json [--grid beatgrid.edited.json] --music music.wav [--vo vo.wav] [--outDir audio/retimed]
+  timeline build [--words audio/words.json] [--grid audio/beatgrid.json] [--out public/timeline.json]
+  template launch|tutorial --spec props.json [--dir project] [--duration 45] (validate real frames)
+  storyboard --brief brief.json [--out storyboard.json] [--md storyboard.md]
+  preview --board storyboard.json [--comp Main] [--scale 0.35] [--out out/preview-stills]
+  sfx auto --board storyboard.json [--timeline public/timeline.json] [--maxPerMin 24] [--out audio/auto-cues.json]
+  music moods --mood premium|calm|warm|focused|bright
+  mix review --file audio/final.wav [--cues audio/auto-cues.json] [--out out/mix-review]; after listening: --approve
+  cache3d --comp LogoOnly --start 0 --end 89 --sources src/scenes/Logo.tsx,src/style.json [--scale 1]
+  qa full <video> [--outDir out/qa-full]  scan every decoded frame of real video for text issues
+  qa pixels <video> [--board storyboard.json] [--outDir out/qa-pixels] | overlap [--comp Main] | sheet <video> | audio <file> | file <video> [--maxMb 16] | all <video> [--comp Main] [--maxMb 16]
+  gpu probe --dir project [--gl angle|egl|swangle]
+  worker manifest --dir project --comp Main --gl angle --out render-job.json | verify --dir project --manifest render-job.json
+  render [--require-gpu --gl angle|egl] [--comp Main|MainVertical|ProductLaunch|ScreenTutorial|TimelineLaunch|TimelineTutorial --timeline storyboard.edited.json --grid beatgrid.edited.json --props props.json] [--review out/mix-review/review.json] [--comp Main] [--format 1:1|4:5|9:16] [--all-formats] [--platform ig-feed|reels|tiktok] [--preset wa|ig|yt|master] [--audio audio/final.wav] [--out out/final.mp4]
+`;
+const [cmd, ...rest] = process.argv.slice(2); const a = parseArgs(rest);
+try {
+  switch (cmd) {
+    case 'check-update': out(await checkUpdate()); break;
+    case 'doctor': { const r = doctor(a); if (a.json) out(r); else console.log(printDoctor(r)); break; }
+    case 'new': out(C.cmdNew(a)); break;
+    case 'style': out(cmdStyle(a)); break;
+    case 'ref': out(C.cmdRef(a)); break;
+    case 'audio': out(C.cmdAudio(a)); break;
+    case 'vo': out(C.cmdVo(a)); break;
+    case 'music': out(a._[0]==='moods'?moodOptions(a):C.cmdMusic({ ...a, _: a._[0] === 'make' ? a._.slice(1) : a._ })); break;
+    case 'sfx': out(a._[0]==='auto'?autoCues(a):C.cmdSfx({ ...a, _: a._[0] === 'make' ? a._.slice(1) : a._ })); break;
+    case 'mix': out(a._[0]==='review'?mixReview(a):C.cmdMix(a)); break;
+    case 'beat': out(C.cmdBeat(a)); break;
+    case 'timeline': out(a._[0]==='edit'?timelineEditor(a):a._[0]==='init'?timelineInit(a):a._[0]==='audio'?retimeAudio(a):C.cmdTimeline(a)); break;
+    case 'render': out(cmdRender(a)); break;
+    case 'gpu': out(gpuPreflight(a)); break;
+    case 'worker': out(a._[0]==='manifest'?workerManifest(a):a._[0]==='verify'?workerVerify(a):die('worker manifest|verify')); break;
+    case 'storyboard': out(storyboard(a)); break;
+    case 'template': out(templatePlan(a)); break;
+    case 'preview': out(preview(a)); break;
+    case 'cache3d': out(cache3d(a)); break;
+    case 'qa': { const s = a._[0], f = a._[1];
+      if (s === 'full') out(qaFull(a)); else if (s === 'pixels') out(qaPixels(a)); else if (s === 'overlap') out(qaOverlap(a)); else if (s === 'sheet') out(qaSheet(f, a)); else if (s === 'audio') out(qaAudio(f)); else if (s === 'file') out(qaFile(f, a));
+      else if (s === 'all') { const r = { file: qaFile(f, a), audio: qaAudio(f), sheet: qaSheet(f, a), overlap: a.comp || a.dir ? qaOverlap(a) : 'skipped (pass --comp/--dir to run inside the project)' }; r.pass = r.file.pass && r.audio.pass && (typeof r.overlap === 'string' || r.overlap.pass); out(r); }
+      else die('usage: qa overlap|sheet|audio|file|all'); break; }
+    case undefined: case 'help': case '--help': case '-h': console.log(HELP); break;
+    default: die(`unknown command "${cmd}"`, 'run: node scripts/motioncraft.mjs help');
+  }
+} catch (e) { die(e.message || String(e)); }

package/vendor/motioncraft/scripts/py/whisper_words.py

@@ -0,0 +1,13 @@
+"""Word timestamps with faster-whisper. Usage: whisper_words.py audio out.json [lang|auto] [model]"""
+import json, sys
+from faster_whisper import WhisperModel
+audio, out = sys.argv[1], sys.argv[2]
+lang = None if len(sys.argv) < 4 or sys.argv[3] == 'auto' else sys.argv[3]
+model = WhisperModel(sys.argv[4] if len(sys.argv) > 4 else 'small', device='auto', compute_type='int8')
+segs, info = model.transcribe(audio, language=lang, word_timestamps=True, vad_filter=True)
+words, text = [], []
+for s in segs:
+    text.append(s.text.strip())
+    for w in (s.words or []):
+        words.append({'w': w.word.strip(), 'start': round(w.start, 3), 'end': round(w.end, 3), 'p': round(w.probability, 2)})
+json.dump({'mode': 'word', 'language': info.language, 'text': ' '.join(text), 'words': words}, open(out, 'w'), ensure_ascii=False, indent=1)