creator-editing-studio 1.3.5 → 1.3.7

package/template/scripts/refmotion.mjs

@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+/**
+ * Study HOW a reference moves and sounds, not just what it looks like at a few moments.
+ *
+ *   node scripts/refmotion.mjs <clip> [--from <s>] [--to <s>] [--strips 10] [--out work/refs/motion/<name>]
+ *
+ * A contact sheet shows where things end up. It cannot show the thing that makes motion feel expensive:
+ * how a move speeds up and slows down, how long it holds, whether one scene flows into the next or cuts,
+ * and whether the sound lands ahead of the picture or on it. This measures all of that, frame by frame:
+ *
+ *   MOTION  every frame's change from the one before. A hard cut is a one-frame spike; a move is a
+ *           hill. Each hill is reported with its length, how many frames it takes to reach full speed
+ *           and to settle (an eased move settles slowly — long tail), and the holds between moves.
+ *   SOUND   onsets (where a sound starts), each classed by its shape — click, hit, whoosh, other —
+ *           plus loudness and, if there is a steady pulse, the music's tempo.
+ *   SYNC    for every cut and every move's peak, the nearest sound and how many frames it leads or lags.
+ *   STRIPS  every frame across each cut and the biggest moves, as images to look at closely.
+ *
+ * Writes report.md + report.json + strips/*.jpg. Measurement only — nothing from a reference is ever
+ * used in a video.
+ */
+import {spawnSync} from 'node:child_process';
+import {mkdirSync, rmSync, writeFileSync} from 'node:fs';
+import {basename, extname, join} from 'node:path';
+import {FFMPEG, probe} from './lib/media.mjs';
+
+const args = process.argv.slice(2);
+const clip = args.find((a) => !a.startsWith('--') && !/^\d/.test(a));
+const flag = (n, d) => (args.includes(`--${n}`) ? args[args.indexOf(`--${n}`) + 1] : d);
+if (!clip) {
+  console.error('Usage: node scripts/refmotion.mjs <clip> [--from s] [--to s] [--strips 10]');
+  process.exit(2);
+}
+const name = basename(clip, extname(clip));
+const out = flag('out', join('work', 'refs', 'motion', name));
+const from = Number(flag('from', 0));
+const vs = probe(clip);
+if (!vs) throw new Error(`cannot read ${clip}`);
+const fps = vs.fps;
+const total = vs.duration;
+const to = Math.min(total, Number(flag('to', Math.min(total, from + 180))));
+const maxStrips = Number(flag('strips', 10));
+rmSync(out, {recursive: true, force: true});
+mkdirSync(join(out, 'strips'), {recursive: true});
+
+const range = ['-ss', String(from), '-to', String(to)];
+const tc = (s) => `${Math.floor(s / 60)}:${(s % 60).toFixed(2).padStart(5, '0')}`;
+
+/* ------------------------------------------------------------------ motion */
+
+const W = 128;
+const H = Math.max(2, Math.round((W * vs.height) / vs.width / 2) * 2);
+const v = spawnSync(FFMPEG, ['-v', 'error', ...range, '-i', clip, '-vf', `scale=${W}:${H},format=gray`, '-f', 'rawvideo', '-'], {maxBuffer: 1 << 30});
+const px = W * H;
+const nFrames = Math.floor(v.stdout.length / px);
+const frame = (i) => v.stdout.subarray(i * px, (i + 1) * px);
+const diff = [0];
+const hist = (buf) => {
+  const h = new Float64Array(16);
+  for (let k = 0; k < buf.length; k++) h[buf[k] >> 4]++;
+  return h.map((x) => x / buf.length);
+};
+const histDist = [0];
+let prevH = hist(frame(0));
+for (let i = 1; i < nFrames; i++) {
+  const a = frame(i - 1);
+  const b = frame(i);
+  let s = 0;
+  for (let k = 0; k < px; k++) s += Math.abs(a[k] - b[k]);
+  diff.push(s / px);
+  const hcur = hist(b);
+  let hd = 0;
+  for (let k = 0; k < 16; k++) hd += Math.abs(hcur[k] - prevH[k]);
+  histDist.push(hd / 2);
+  prevH = hcur;
+}
+const sorted = [...diff].sort((x, y) => x - y);
+const pct = (p) => sorted[Math.min(sorted.length - 1, Math.floor(p * sorted.length))];
+const floor = Math.max(0.6, pct(0.25) * 2.5);
+
+// A cut: one frame that changes far more than both neighbours, and changes the picture's tones too.
+const cuts = [];
+for (let i = 1; i < nFrames - 1; i++) {
+  const nb = Math.max(diff[i - 1], diff[i + 1], floor);
+  if (diff[i] > 3 * nb && diff[i] > 8 && histDist[i] > 0.12) cuts.push(i);
+}
+const isCut = new Set(cuts);
+
+// Moves: runs of frames above the noise floor (cut frames excluded), smoothed over 3 frames.
+const sm = diff.map((_, i) => (isCut.has(i) ? 0 : (diff[Math.max(0, i - 1)] * (isCut.has(i - 1) ? 0 : 1) + diff[i] + (isCut.has(i + 1) ? 0 : diff[Math.min(nFrames - 1, i + 1)])) / 3));
+const moves = [];
+for (let i = 0; i < nFrames; ) {
+  if (sm[i] <= floor) {
+    i++;
+    continue;
+  }
+  let j = i;
+  while (j < nFrames && sm[j] > floor) j++;
+  if (j - i >= 3) {
+    let pk = i;
+    for (let k = i; k < j; k++) if (sm[k] > sm[pk]) pk = k;
+    moves.push({start: i, end: j - 1, peak: pk, frames: j - i, rise: pk - i, settle: j - 1 - pk, strength: sm[pk]});
+  }
+  i = j;
+}
+const holds = [];
+const events = [...cuts.map((c) => [c, c]), ...moves.map((m) => [m.start, m.end])].sort((a, b) => a[0] - b[0]);
+for (let k = 1; k < events.length; k++) {
+  const gap = events[k][0] - events[k - 1][1];
+  if (gap > 1) holds.push(gap);
+}
+const inMotion = sm.filter((x) => x > floor).length / nFrames;
+const med = (a) => (a.length ? [...a].sort((x, y) => x - y)[Math.floor(a.length / 2)] : 0);
+
+/* ------------------------------------------------------------------ sound */
+
+const SR = 22050;
+const a = spawnSync(FFMPEG, ['-v', 'error', ...range, '-i', clip, '-vn', '-ac', '1', '-ar', String(SR), '-f', 's16le', '-'], {maxBuffer: 1 << 30});
+const hasAudio = a.stdout && a.stdout.length > SR;
+let sound = {present: false};
+if (hasAudio) {
+  const pcm = new Int16Array(a.stdout.buffer.slice(a.stdout.byteOffset, a.stdout.byteOffset + (a.stdout.length & ~1)));
+  const N = 1024;
+  const HOP = 512;
+  const win = Float64Array.from({length: N}, (_, i) => 0.5 - 0.5 * Math.cos((2 * Math.PI * i) / N));
+  // A small radix-2 FFT, magnitude only — enough for flux and centroid.
+  const fft = (re) => {
+    const n = re.length;
+    const im = new Float64Array(n);
+    for (let i = 1, j = 0; i < n; i++) {
+      let bit = n >> 1;
+      for (; j & bit; bit >>= 1) j ^= bit;
+      j ^= bit;
+      if (i < j) [re[i], re[j]] = [re[j], re[i]];
+    }
+    for (let len = 2; len <= n; len <<= 1) {
+      const ang = (-2 * Math.PI) / len;
+      for (let i = 0; i < n; i += len)
+        for (let k = 0; k < len / 2; k++) {
+          const cr = Math.cos(ang * k);
+          const ci = Math.sin(ang * k);
+          const ur = re[i + k];
+          const ui = im[i + k];
+          const vr = re[i + k + len / 2] * cr - im[i + k + len / 2] * ci;
+          const vi = re[i + k + len / 2] * ci + im[i + k + len / 2] * cr;
+          re[i + k] = ur + vr;
+          im[i + k] = ui + vi;
+          re[i + k + len / 2] = ur - vr;
+          im[i + k + len / 2] = ui - vi;
+        }
+    }
+    return Float64Array.from({length: n / 2}, (_, k) => Math.hypot(re[k], im[k]));
+  };
+  const rms = [];
+  const flux = [];
+  const centroid = [];
+  let prev = new Float64Array(N / 2);
+  for (let off = 0; off + N <= pcm.length; off += HOP) {
+    const buf = new Float64Array(N);
+    let e = 0;
+    for (let i = 0; i < N; i++) {
+      const s = pcm[off + i] / 32768;
+      e += s * s;
+      buf[i] = s * win[i];
+    }
+    rms.push(Math.sqrt(e / N));
+    const mag = fft(buf);
+    let f = 0;
+    let num = 0;
+    let den = 0;
+    for (let k = 1; k < N / 2; k++) {
+      f += Math.max(0, mag[k] - prev[k]);
+      num += k * mag[k];
+      den += mag[k];
+    }
+    flux.push(f);
+    centroid.push(den ? ((num / den) * SR) / N : 0);
+    prev = mag;
+  }
+  const hopS = HOP / SR;
+  const dB = (x) => (x > 0 ? 20 * Math.log10(x) : -99);
+  // Onsets: flux peaks well above the local median.
+  const onsets = [];
+  for (let i = 2; i < flux.length - 2; i++) {
+    const lo = Math.max(0, i - 20);
+    const local = [...flux.slice(lo, i + 20)].sort((x, y) => x - y);
+    const thr = local[Math.floor(local.length / 2)] * 2.2 + 0.5;
+    if (flux[i] > thr && flux[i] >= flux[i - 1] && flux[i] >= flux[i + 1] && rms[i + 1] > 0.004) {
+      if (onsets.length && i - onsets.at(-1).i < 4) continue;
+      // Shape: how long the sound lasts above (peak − 12 dB), and how it built up before the onset.
+      let pk = i;
+      for (let k = i; k < Math.min(rms.length, i + 6); k++) if (rms[k] > rms[pk]) pk = k;
+      let end = pk;
+      while (end < rms.length - 1 && dB(rms[end]) > dB(rms[pk]) - 12 && end - pk < 120) end++;
+      let pre = i;
+      while (pre > 0 && rms[pre - 1] < rms[pre] && i - pre < 40) pre--;
+      const dur = (end - i) * hopS;
+      const build = (i - pre) * hopS;
+      const c = centroid[pk];
+      const kind = dur < 0.12 && c > 2500 ? 'click' : build > 0.15 && c > 1500 ? 'whoosh' : c < 1800 && dur >= 0.12 ? 'hit' : dur < 0.18 ? 'tick' : 'other';
+      // jump: how far the sound rises above what was playing just before it — a sound effect stands out
+      // from the voice/music bed; a syllable or a note mostly does not.
+      const bed = Math.max(...rms.slice(Math.max(0, i - 12), Math.max(1, i - 2)));
+      onsets.push({i, t: i * hopS, db: Math.round(dB(rms[pk])), jump: Math.round(dB(rms[pk]) - dB(bed)), flux: flux[i], centroid: Math.round(c), dur: Math.round(dur * 1000), kind});
+    }
+  }
+  // Tempo: autocorrelation of the onset strength over 60–180 BPM.
+  let bpm = null;
+  let pulse = 0;
+  const env = flux.map((x, i) => x - (flux[i - 1] ?? x));
+  const meanEnv = env.reduce((s, x) => s + Math.max(0, x), 0) / env.length;
+  let best = 0;
+  let bestLag = 0;
+  let base = 0;
+  for (let lag = Math.round(60 / 180 / hopS); lag <= Math.round(60 / 60 / hopS); lag++) {
+    let s = 0;
+    for (let i = lag; i < env.length; i++) s += Math.max(0, env[i]) * Math.max(0, env[i - lag]);
+    s /= env.length - lag;
+    base += s;
+    if (s > best) [best, bestLag] = [s, lag];
+  }
+  base /= Math.round(60 / 60 / hopS) - Math.round(60 / 180 / hopS) + 1;
+  pulse = base ? best / base : 0;
+  if (pulse > 1.6 && meanEnv > 0) bpm = Math.round(60 / (bestLag * hopS));
+  const lufs = spawnSync(FFMPEG, ['-v', 'info', ...range, '-i', clip, '-vn', '-af', 'ebur128=framelog=quiet', '-f', 'null', '-'], {encoding: 'utf8'}).stderr;
+  // Strong onsets: the ones that stand out — top 12% by onset strength AND at least 6 dB over the bed.
+  // These are the sound design (whooshes, hits, risers, music accents); the rest is mostly voice and music.
+  const fluxes = onsets.map((o) => o.flux).sort((x, y) => x - y);
+  const strongCut = fluxes[Math.floor(fluxes.length * 0.88)] ?? Infinity;
+  for (const o of onsets) o.strong = o.flux >= strongCut && o.jump >= 6;
+  sound = {
+    present: true,
+    lufs: Number(/I:\s+(-?[\d.]+) LUFS/.exec(lufs)?.[1] ?? NaN),
+    lra: Number(/LRA:\s+([\d.]+) LU/.exec(lufs)?.[1] ?? NaN),
+    bpm,
+    pulse: Math.round(pulse * 100) / 100,
+    onsets,
+    perMinute: Math.round((onsets.length / ((to - from) / 60)) * 10) / 10,
+    kinds: onsets.reduce((m, o) => ({...m, [o.kind]: (m[o.kind] ?? 0) + 1}), {}),
+  };
+}
+
+/**
+ * The sound as a picture, for whoever cannot listen: time left to right, pitch bottom to top, loudness as
+ * brightness. Risers climb diagonally, whooshes are short sweeps high up, hits are vertical lines, music is
+ * horizontal bands, a drop-out is a dark gap, a beat is a row of evenly spaced lines. One image per minute.
+ */
+const spectra = [];
+if (hasAudio) {
+  for (let s = from; s < to && spectra.length < 5; s += 60) {
+    const file = join(out, `spectrum-${Math.round(s)}.png`);
+    spawnSync(FFMPEG, ['-y', '-v', 'error', '-ss', String(s), '-t', String(Math.min(60, to - s)), '-i', clip, '-lavfi', 'showspectrumpic=s=1400x360:legend=1:scale=log:fscale=log:color=intensity:gain=2', file]);
+    spectra.push(file);
+  }
+}
+
+/* ------------------------------------------------------------------ sync */
+
+const nearest = (t) => {
+  const strong = sound.present ? sound.onsets.filter((o) => o.strong) : [];
+  if (!strong.length) return null;
+  let best = strong[0];
+  for (const o of strong) if (Math.abs(o.t - t) < Math.abs(best.t - t)) best = o;
+  const lead = Math.round((best.t - t) * fps * 10) / 10; // frames; negative = sound before picture
+  return Math.abs(lead) <= fps * 0.5 ? {lead, kind: best.kind} : null;
+};
+const cutSync = cuts.map((c) => nearest(c / fps)).filter(Boolean);
+const moveSync = moves.map((m) => nearest(m.start / fps)).filter(Boolean);
+
+/* ------------------------------------------------------------------ strips */
+
+const strip = (startF, endF, label) => {
+  const s = Math.max(0, startF);
+  const e = Math.min(nFrames - 1, endF);
+  const n = e - s + 1;
+  const step = Math.max(1, Math.ceil(n / 12));
+  const count = Math.ceil(n / step);
+  const file = join(out, 'strips', `${label}.jpg`);
+  const tw = vs.width >= vs.height ? 320 : 180;
+  spawnSync(FFMPEG, ['-y', '-v', 'error', '-ss', String(from + s / fps), '-i', clip, '-frames:v', String(count), '-vf', `select='not(mod(n\\,${step}))',scale=${tw}:-2,tile=${Math.min(count, 6)}x${Math.ceil(count / 6)}:padding=4:color=white`, '-q:v', '4', file]);
+  return file;
+};
+const pickedMoves = [...moves].sort((x, y) => y.strength * y.frames - x.strength * x.frames).slice(0, maxStrips);
+const strips = [];
+for (const c of cuts.slice(0, maxStrips)) strips.push({what: 'cut', at: tc(from + c / fps), file: strip(c - 4, c + 7, `cut-${(from + c / fps).toFixed(2)}`)});
+for (const m of pickedMoves) strips.push({what: `move ${m.frames}f`, at: tc(from + m.start / fps), file: strip(m.start - 1, m.end + 1, `move-${(from + m.start / fps).toFixed(2)}`)});
+
+/* ------------------------------------------------------------------ report */
+
+const easeOf = (m) => (m.settle >= m.rise * 1.6 ? 'ease-out (fast start, long settle)' : m.rise >= m.settle * 1.6 ? 'ease-in (slow start, sharp stop)' : 'ease-in-out');
+const report = {
+  clip: basename(clip),
+  window: [from, to],
+  fps,
+  size: `${vs.width}x${vs.height}`,
+  motion: {
+    frames: nFrames,
+    cuts: cuts.length,
+    cutsPerMinute: Math.round((cuts.length / ((to - from) / 60)) * 10) / 10,
+    moves: moves.length,
+    inMotionShare: Math.round(inMotion * 100),
+    medianMoveFrames: med(moves.map((m) => m.frames)),
+    medianRise: med(moves.map((m) => m.rise)),
+    medianSettle: med(moves.map((m) => m.settle)),
+    medianHoldFrames: med(holds),
+    easing: moves.reduce((acc, m) => ({...acc, [easeOf(m)]: (acc[easeOf(m)] ?? 0) + 1}), {}),
+  },
+  sound,
+  sync: {
+    cutsWithSound: `${cutSync.length}/${cuts.length}`,
+    medianCutLeadFrames: med(cutSync.map((s) => s.lead)),
+    movesWithSound: `${moveSync.length}/${moves.length}`,
+    medianMoveLeadFrames: med(moveSync.map((s) => s.lead)),
+  },
+  cutTimes: cuts.map((c) => tc(from + c / fps)),
+  moveList: moves.map((m) => ({at: tc(from + m.start / fps), frames: m.frames, rise: m.rise, settle: m.settle, ease: easeOf(m), strength: Math.round(m.strength * 10) / 10})),
+  strips,
+};
+if (sound.present) report.sound = {...sound, onsets: sound.onsets.map((o) => ({...o, at: tc(from + o.t)}))};
+writeFileSync(join(out, 'report.json'), JSON.stringify(report, null, 1));
+
+const M = report.motion;
+const md = [
+  `# ${report.clip} — ${tc(from)}–${tc(to)} · ${report.size} @ ${fps.toFixed(2)}fps`,
+  '',
+  `**Motion.** ${M.cuts} hard cuts (${M.cutsPerMinute}/min) · ${M.moves} moves · in motion ${M.inMotionShare}% of frames · median move ${M.medianMoveFrames}f (${(M.medianMoveFrames / fps).toFixed(2)}s), reaching full speed in ${M.medianRise}f and settling over ${M.medianSettle}f · median hold ${M.medianHoldFrames}f (${(M.medianHoldFrames / fps).toFixed(2)}s).`,
+  `Easing: ${Object.entries(M.easing)
+    .map(([k, n]) => `${n}× ${k}`)
+    .join(', ')}.`,
+  '',
+  sound.present
+    ? `**Sound.** ${report.sound.onsets.filter((o) => o.strong).length} standout hits (${(report.sound.onsets.filter((o) => o.strong).length / ((to - from) / 60)).toFixed(1)}/min: ${Object.entries(report.sound.onsets.filter((o) => o.strong).reduce((m, o) => ({...m, [o.kind]: (m[o.kind] ?? 0) + 1}), {})).map(([k, n]) => `${n} ${k}`).join(', ')}) · ${report.sound.lufs} LUFS (range ${report.sound.lra} LU) · ${report.sound.onsets.length} onsets (${report.sound.perMinute}/min): ${Object.entries(report.sound.kinds)
+        .map(([k, n]) => `${n} ${k}`)
+        .join(', ')} · ${report.sound.bpm ? `steady pulse ~${report.sound.bpm} BPM (strength ${report.sound.pulse})` : `no steady beat (pulse ${report.sound.pulse})`}.`
+    : '**Sound.** none in this file.',
+  `**Sync** (standout hits only). cuts with a hit within ½s: ${report.sync.cutsWithSound} (median ${report.sync.medianCutLeadFrames}f, − = sound first) · moves: ${report.sync.movesWithSound} (median ${report.sync.medianMoveLeadFrames}f).`,
+  '',
+  ...(spectra.length ? ['## The sound, as a picture (risers climb, whooshes sweep high, hits are vertical lines, music is bands, a drop is a dark gap)', ...spectra.map((f) => `- ${f.replace(/\\/g, '/')}`), ''] : []),
+  '## Strips (every frame across the event)',
+  ...strips.map((s) => `- ${s.what} at ${s.at}: ${s.file.replace(/\\/g, '/')}`),
+  '',
+  '## Moves',
+  ...report.moveList.slice(0, 40).map((m) => `- ${m.at}  ${m.frames}f  rise ${m.rise} / settle ${m.settle}  ${m.ease}  (strength ${m.strength})`),
+  '',
+  '## Cuts',
+  report.cutTimes.join(' · ') || 'none',
+].join('\n');
+writeFileSync(join(out, 'report.md'), md);
+console.log(md.split('\n').slice(0, 7).join('\n'));

package/template/scripts/setup_models.py

@@ -0,0 +1,89 @@
+"""Download, once and up front, every model the studio will need — for the language its videos are in.
+
+Usage (from the studio folder, with the studio's Python):
+    python scripts/setup_models.py --language ml          # en hi hinglish te ml ur ta kn mr bn gu pa, or any code
+    python scripts/setup_models.py --language en --no-tracking
+
+Saves the choice to studio.config.json, then fetches into the studio's .models folder:
+  1. the transcriber for that language (English: small, ~0.5 GB; Indian languages: large-v3, ~3 GB),
+  2. its word-timing model (~0.4–2.5 GB),
+  3. motion tracking: the person-finding model (~0.2 GB) and a check that the tracker loads.
+
+Why up front: these downloads are large, and finding that out in the middle of someone's first edit — with
+their footage waiting — is the worst moment to learn it (Malayalam needed ~5 GB the first time).
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+sys.path.insert(0, str(Path(__file__).resolve().parent / "lib"))
+from media import FFMPEG, use_certifi  # noqa: E402
+from languages import CONFIG, LANGS, lang, load_aligner  # noqa: E402
+
+ROOT = Path(__file__).resolve().parent.parent
+MODELS = ROOT / ".models"
+os.environ.setdefault("HF_HOME", str(MODELS / "huggingface"))
+os.environ.setdefault("TORCH_HOME", str(MODELS / "torch"))
+os.environ["PATH"] = str(Path(FFMPEG).parent) + os.pathsep + os.environ["PATH"]
+use_certifi()
+
+
+def size_gb(path: Path) -> float:
+    return sum(f.stat().st_size for f in path.rglob("*") if f.is_file()) / 1e9 if path.exists() else 0.0
+
+
+def main() -> None:
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")
+        except (AttributeError, ValueError):
+            pass
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--language", default="en", help=f"one of {', '.join(LANGS)} — or any language code")
+    ap.add_argument("--no-tracking", action="store_true", help="skip the motion-tracking model")
+    args = ap.parse_args()
+
+    choice = args.language.strip().lower()
+    info = lang(choice)
+    (ROOT / CONFIG).write_text(json.dumps({"language": choice}, indent=2) + "\n", encoding="utf-8")
+    print(f"Language: {info['name']} — saved to {CONFIG}")
+    started = time.time()
+    before = size_gb(MODELS)
+    ok = True
+
+    import whisperx  # noqa: E402  (after the cache/cert setup above)
+
+    print(f"1/3 Transcriber ({info['whisper']})…", flush=True)
+    whisperx.load_model(info["whisper"], device="cpu", compute_type="int8", language=info["code"])
+    print("    ready")
+
+    print("2/3 Word timing…", flush=True)
+    model, _ = load_aligner(whisperx, info["code"])
+    if model is None:
+        print("    none for this language — captions will use the transcriber's own timings (looser).")
+    else:
+        print("    ready" + ("" if info["tested"] else " (experimental for this language — check the first video's captions)"))
+
+    if not args.no_tracking:
+        print("3/3 Motion tracking…", flush=True)
+        try:
+            import cv2  # noqa: F401
+            from make_cutout import load_segmenter
+
+            load_segmenter("lite")
+            print("    ready")
+        except Exception as exc:  # noqa: BLE001
+            ok = False
+            print(f"    FAILED: {exc}. Run: pip install -r requirements.txt with the studio's Python, then this again.")
+
+    print(f"Done in {time.time() - started:.0f}s — {size_gb(MODELS) - before:.1f} GB downloaded, {size_gb(MODELS):.1f} GB of models in .models")
+    raise SystemExit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    main()

package/template/scripts/stills.mjs

@@ -31,7 +31,7 @@ const out = opt('out') ?? join('work', 'stills', id);
 rmSync(out, {recursive: true, force: true});
 mkdirSync(out, {recursive: true});
 
-const serveUrl = await bundle({entryPoint: resolve('src/index.ts'), publicDir: resolve('assets')});
+const serveUrl = await bundle({entryPoint: resolve(opt('entry') ?? 'src/index.ts'), publicDir: resolve(opt('public') ?? 'assets')});
 const comp = (await getCompositions(serveUrl)).find((c) => c.id === id);
 if (!comp) throw new Error(`No composition ${id}`);