@amg555/frameforge-mcp 2.7.3 → 2.7.7

package/plugins/faceless-shorts/styles/paper-atlas/example/src/shots.js

@@ -0,0 +1,139 @@
+// HOW ONE BAKERY BURNED DOWN LONDON : the shot list (Paper Atlas example). Everything is cut paper.
+import { ctx, W, H, TAU, clamp, lerp, seg, eo, eio, eob, rnd, rr, circle, ell, line } from './core/lib.js';
+import { L, Wd, T } from './core/timing.js';
+import * as K from './core/kit.js';
+const { P, cut, P_rr, P_poly, P_circ } = K;
+
+// ── set pieces for this story (cut paper) ──
+const NIGHT = '#2F3550', NIGHT2 = '#262B42';
+function nightPage(seed) { K.parchment(seed); ctx.save(); ctx.globalAlpha = 0.86; ctx.fillStyle = NIGHT; ctx.fillRect(-300, -300, W + 600, H + 600); ctx.restore(); for (let i = 0; i < 30; i++) circle(rnd(i + seed) * W, rnd(i + 40 + seed) * 900, 3 + rnd(i) * 3, '#E9DCBC'); }
+/** a timber house: x = centre, y = ground, w, h; roof colour; burning 0..1 */
+function house(x, y, w, h, wall = '#B68A5C', roof = '#7A4B33', win = 0) {
+  cut(P_rr(x - w / 2, y - h, w, h, 4), wall, { shadow: 0.7, edge: 5 });
+  cut(P_poly([[x - w / 2 - 18, y - h + 4], [x, y - h - w * 0.55], [x + w / 2 + 18, y - h + 4]]), roof, { shadow: 0.6, edge: 5 });
+  ctx.strokeStyle = 'rgba(62,44,30,0.55)'; ctx.lineWidth = 6; ctx.beginPath(); ctx.moveTo(x - w / 2, y - h * 0.5); ctx.lineTo(x + w / 2, y - h * 0.5); ctx.moveTo(x, y - h); ctx.lineTo(x, y); ctx.stroke();
+  for (const dx of [-0.25, 0.25]) { rr(x + dx * w - 22, y - h * 0.82, 44, 54, 4); ctx.fillStyle = win ? `rgba(242,190,90,${0.4 + 0.6 * win})` : '#3E2C1E'; ctx.fill(); }
+}
+/** paper flame: layered crimson / orange / gold, flickering */
+function flame(x, y, s, t, seed = 0) {
+  if (s <= 0) return; ctx.save(); ctx.translate(x, y); ctx.scale(s, s * (1 + 0.08 * Math.sin(t * 9 + seed)));
+  const f = (w, h, c) => cut(() => { ctx.beginPath(); ctx.moveTo(-w, 0); ctx.quadraticCurveTo(-w * 1.1, -h * 0.5, -w * 0.2 + Math.sin(t * 6 + seed) * 8, -h); ctx.quadraticCurveTo(w * 0.2, -h * 0.55, w * 0.5, -h * 0.75 + Math.sin(t * 7 + seed) * 6); ctx.quadraticCurveTo(w * 1.1, -h * 0.4, w, 0); ctx.closePath(); }, c, { shadow: 0.4, edge: 3 });
+  f(70, 190, P.crimson); f(50, 140, '#E0782E'); f(28, 90, '#F2C14E'); ctx.restore();
+}
+function smoke(x, y, s, a = 1) { ctx.save(); ctx.globalAlpha = a; ctx.translate(x, y); ctx.scale(s, s); cut(() => { ctx.beginPath(); for (const [dx, dy, r] of [[-60, 0, 60], [0, -30, 75], [60, 0, 58], [0, 25, 60]]) { ctx.moveTo(dx + r, dy); ctx.arc(dx, dy, r, 0, TAU); } }, '#8F8578', { shadow: 0.4, edge: 4 }); ctx.restore(); }
+function wind(t, y, a = 1) { ctx.save(); ctx.globalAlpha = a; ctx.strokeStyle = P.edge; ctx.lineWidth = 9; ctx.lineCap = 'round'; for (let i = 0; i < 4; i++) { const x = ((t * 420 + i * 300) % 1500) - 300, yy = y + i * 70; ctx.beginPath(); ctx.moveTo(x, yy); ctx.bezierCurveTo(x + 120, yy - 30, x + 200, yy + 30, x + 300, yy); ctx.arc(x + 300, yy - 26, 26, Math.PI / 2, -Math.PI * 0.9, true); ctx.stroke(); } ctx.restore(); }
+function stPauls(x, y, s) { ctx.save(); ctx.translate(x, y); ctx.scale(s, s); cut(P_rr(-200, -260, 400, 260, 4), P.stone); cut(P_rr(-90, -380, 180, 130, 4), P.stone); cut(() => { ctx.beginPath(); ctx.arc(0, -380, 110, Math.PI, TAU); ctx.closePath(); }, P.stoneDark); cut(P_rr(-12, -560, 24, 90, 4), P.stoneDark); for (let i = 0; i < 4; i++) { rr(-150 + i * 90, -200, 40, 120, 18); ctx.fillStyle = P.ink; ctx.fill(); } ctx.restore(); }
+function oven(x, y, s, t) { ctx.save(); ctx.translate(x, y); ctx.scale(s, s); cut(() => { ctx.beginPath(); ctx.moveTo(-230, 0); ctx.lineTo(-230, -200); ctx.arc(0, -200, 230, Math.PI, TAU); ctx.lineTo(230, 0); ctx.closePath(); }, '#9C6B48'); cut(() => { ctx.beginPath(); ctx.moveTo(-110, 0); ctx.lineTo(-110, -120); ctx.arc(0, -120, 110, Math.PI, TAU); ctx.lineTo(110, 0); ctx.closePath(); }, '#1F140C', { shadow: 0, edge: 3 }); for (let i = 0; i < 7; i++) circle(-60 + i * 20, -18 - (i % 2) * 10, 12 + Math.sin(t * 5 + i) * 3, i % 2 ? '#E0782E' : '#F2C14E'); ctx.restore(); }
+/** a simplified old London: the Thames, the city wall area, fire spreading with p 0..1 from Pudding Lane */
+function londonMap(p, t) {
+  K.parchment(4);
+  cut(() => { ctx.beginPath(); ctx.moveTo(-300, 1180); ctx.bezierCurveTo(200, 1080, 500, 1240, 800, 1150); ctx.bezierCurveTo(950, 1110, 1100, 1160, 1400, 1120); ctx.lineTo(1400, 1340); ctx.bezierCurveTo(1000, 1360, 800, 1350, 500, 1420); ctx.bezierCurveTo(200, 1460, 0, 1380, -300, 1400); ctx.closePath(); }, P.sea, { shadow: 0.5, edge: 5 });
+  K.label('RIVER THAMES', 540, 1310, 40);
+  const city = [[140, 1130], [180, 720], [420, 560], [760, 600], [930, 820], [900, 1090], [600, 1170], [300, 1150]];
+  P_poly(city)(); ctx.setLineDash([16, 12]); ctx.strokeStyle = P.ink; ctx.lineWidth = 6; ctx.stroke(); ctx.setLineDash([]); K.label('THE CITY', 520, 640, 44);
+  for (let i = 0; i < 120; i++) { const x = 190 + rnd(i) * 700, y = 640 + rnd(i + 50) * 480; const d = Math.hypot(x - 700, y - 1100) / 700; if (d > p * 1.15) continue; rr(x - 14, y - 14, 28, 28, 4); ctx.fillStyle = d > p * 0.8 ? '#E0782E' : P.crimson; ctx.fill(); }
+  circle(700, 1100, 14, P.ink); K.slip('PUDDING LANE', 760, 1040, 1, 0.02, 30);
+}
+
+export function buildShots() {
+  const S = [], CUES = [], add = (o) => (S.push(o), o), cue = (t, type, o = {}) => CUES.push({ t: +t.toFixed(3), type, ...o });
+  const cut_ = (i) => (i === 0 ? 0 : L(i) - 0.08);
+  const ROW = [[90, 0], [300, 1], [510, 0], [720, 1], [930, 0]];
+
+  // 1 · 1666: London at night, a gold ribbon, one glowing window
+  add({ id: 'S01', at: 0, cam: [540, 900], zoom: 0.08, note: 'night skyline, 1666 ribbon, bakery window glows', draw(lt, d, t) {
+    nightPage(1); ROW.forEach(([x, k], i) => house(x, 1400, 190, 300 + k * 60, k ? '#8C6B4E' : '#A37A55', k ? '#5E3B28' : '#6E4430', i === 2 ? 0.6 + 0.4 * Math.sin(t * 6) : 0));
+    cut(P_rr(-300, 1400, W + 600, 800, 0), '#4A3A2E', { shadow: 0, edge: 0 });
+    K.ribbon('1666', 540, 400, eob(seg(lt, 0.1, 0.5)));
+    if (lt > d * 0.6) flame(510, 1300, eob(seg(lt, d * 0.6, d * 0.6 + 0.4)) * 0.8, t);
+  } });
+  cue(0.1, 'whoosh'); cue(0.15, 'pop', { gain: 0.6 });
+
+  // 2 · just after midnight, Farriner's bakery on Pudding Lane
+  { const st = cut_(1), lane = Wd('pudding', 1) - st;
+    add({ id: 'S02', at: st, cam: [540, 1050], zoom: 0.12, note: 'the bakery: oven embers, baker asleep, PUDDING LANE slip', draw(lt, d, t) {
+      nightPage(2); cut(P_rr(-300, 1500, W + 600, 700, 0), '#4A3A2E', { shadow: 0, edge: 0 }); house(540, 1500, 760, 760, '#A37A55', '#6E4430', 0.5);
+      oven(380, 1450, 0.7, t); K.figure({ x: 760, y: 1500, h: 520, role: 'worker', dir: -1 });
+      K.slip('12:30 A.M.', 540, 260, eob(seg(lt, 0.1, 0.35)));
+      K.slip('PUDDING LANE', 540, 420, lt > lane ? eob(seg(lt, lane, lane + 0.3)) : 0, 0.03);
+    } });
+    cue(st, 'whoosh'); cue(st + 0.1, 'pop', { gain: 0.5 }); cue(st + lane, 'pop'); }
+
+  // 3 · wooden houses, strong wind
+  { const st = cut_(2), wd = Wd('wind', 2) - st;
+    add({ id: 'S03', at: st, cam: [540, 1000], zoom: 0.08, note: 'a street of timber houses, wind gusts', draw(lt, d, t) {
+      nightPage(3); const pan = lerp(0, -160, eio(lt / d)); ctx.save(); ctx.translate(pan, 0);
+      for (let i = 0; i < 7; i++) house(80 + i * 200, 1450, 180, 330 + (i % 3) * 50, i % 2 ? '#8C6B4E' : '#A37A55', i % 2 ? '#5E3B28' : '#6E4430');
+      flame(80, 1450 - 380, 0.7, t); ctx.restore(); cut(P_rr(-300, 1450, W + 600, 800, 0), '#4A3A2E', { shadow: 0, edge: 0 });
+      if (lt > wd - 0.2) wind(t, 560, clamp((lt - wd + 0.2) * 3));
+    } });
+    cue(st, 'whoosh'); cue(st + wd - 0.2, 'slide', { dur: 1.6, gain: 0.7 }); }
+
+  // 4 · flames jump roof to roof
+  { const st = cut_(3);
+    add({ id: 'S04', at: st, cam: [540, 1000], zoom: 0.1, note: 'fire leaps from house to house', draw(lt, d, t) {
+      nightPage(4); ctx.save(); ctx.globalAlpha = 0.35 * clamp(lt); ctx.fillStyle = '#E0782E'; ctx.fillRect(-300, -300, W + 600, 1500); ctx.restore();
+      for (let i = 0; i < 6; i++) { const x = 60 + i * 200, top = 1450 - (330 + (i % 3) * 50) - 100; house(x, 1450, 180, 330 + (i % 3) * 50, i % 2 ? '#8C6B4E' : '#A37A55', i % 2 ? '#5E3B28' : '#6E4430', 0.8); const p = seg(lt, i * (d / 7), i * (d / 7) + 0.3); flame(x, top + 60, eob(p) * 0.9, t, i); }
+      cut(P_rr(-300, 1450, W + 600, 800, 0), '#4A3A2E', { shadow: 0, edge: 0 });
+    } });
+    cue(st, 'whoosh'); for (let i = 0; i < 6; i++) cue(st + i * 0.33, 'pop', { gain: 0.45 }); cue(st, 'sizzle', { dur: 2 }); }
+
+  // 5 · the Lord Mayor shrugs it off
+  { const st = cut_(4), off = Wd('shrugged', 4) - st;
+    add({ id: 'S05', at: st, cam: [540, 1000], note: 'the Lord Mayor in his nightcap waves it away', draw(lt, d, t) {
+      K.hall(); ctx.save(); ctx.globalAlpha = 0.45; ctx.fillStyle = NIGHT; ctx.fillRect(-300, -300, W + 600, H + 600); ctx.restore();
+      K.figure({ x: 540, y: 1500, h: 760, role: 'merchant', arm: lt > off ? 70 + Math.sin(lt * 12) * 25 : 10 });
+      K.slip('THE LORD MAYOR', 540, 330, eob(seg(lt, 0.1, 0.35)));
+      if (lt > off) K.slip('BACK TO BED', 540, 520, eob(seg(lt, off, off + 0.3)), 0.04, 44);
+    } });
+    cue(st, 'whoosh'); cue(st + 0.1, 'pop', { gain: 0.5 }); cue(st + off, 'boing', { gain: 0.5 }); }
+
+  // 6 · for four days, the city burned (map + timeline)
+  { const st = cut_(5);
+    add({ id: 'S06', at: st, cam: [540, 900], zoom: 0.06, note: 'map: fire spreads over the city, timeline Sept 2-5', draw(lt, d, t) {
+      const p = eio(clamp(lt / (d * 0.9))); londonMap(p, t);
+      K.timeline(['SEP 2', 'SEP 3', 'SEP 4', 'SEP 5'], 150, 300, 780, p, Math.min(3, Math.floor(p * 3.99)));
+    } });
+    cue(st, 'whoosh'); cue(st, 'sizzle', { dur: 2.4, gain: 0.7 }); }
+
+  // 7 · 13,000 houses, 87 churches, St Paul's
+  { const st = cut_(6), h1 = Wd('thirteen', 6) - st, c1 = Wd('eighty', 6) - st, sp = Wd('paul', 6) - st;
+    add({ id: 'S07', at: st, cam: [540, 950], zoom: 0.08, note: 'tallies pop in, St Pauls burns', draw(lt, d, t) {
+      nightPage(7); ctx.save(); ctx.globalAlpha = 0.3; ctx.fillStyle = '#E0782E'; ctx.fillRect(-300, -300, W + 600, 1500); ctx.restore();
+      stPauls(540, 1450, 1.4); cut(P_rr(-300, 1450, W + 600, 800, 0), '#4A3A2E', { shadow: 0, edge: 0 });
+      if (lt > sp) for (let i = 0; i < 5; i++) flame(300 + i * 120, 1450 - 320 - (i === 2 ? 200 : 0), eob(seg(lt, sp + i * 0.08, sp + i * 0.08 + 0.3)) * 0.9, t, i);
+      K.slip('13,200 HOUSES', 540, 330, lt > h1 ? eob(seg(lt, h1, h1 + 0.3)) : 0, -0.03);
+      K.slip('87 CHURCHES', 540, 500, lt > c1 ? eob(seg(lt, c1, c1 + 0.3)) : 0, 0.03);
+    } });
+    cue(st, 'whoosh'); cue(st + h1, 'pop'); cue(st + c1, 'pop'); cue(st + sp, 'thud'); }
+
+  // 8 · they blew up whole streets (firebreak)
+  { const st = cut_(7), bl = Wd('blew', 7) - st;
+    add({ id: 'S08', at: st, cam: [540, 1000], zoom: 0.08, note: 'houses vanish into smoke: a gap stops the fire', draw(lt, d, t) {
+      nightPage(8); const gone = lt > bl + 0.1;
+      for (let i = 0; i < 6; i++) { const x = 60 + i * 200; if (gone && (i === 3 || i === 4)) continue; house(x, 1450, 180, 340, '#8C6B4E', '#5E3B28', i < 3 ? 0.8 : 0); if (i < 3) flame(x, 1450 - 440, 0.85, t, i); }
+      if (lt > bl) for (let k = 0; k < 4; k++) smoke(660 + (k % 2) * 200, 1250 - k * 90 - (lt - bl) * 120, 0.9 + (lt - bl) * 0.6, clamp(1.6 - (lt - bl)));
+      cut(P_rr(-300, 1450, W + 600, 800, 0), '#4A3A2E', { shadow: 0, edge: 0 });
+    } });
+    cue(st, 'whoosh'); cue(st + bl, 'slam'); cue(st + bl + 0.25, 'thud', { gain: 0.6 }); }
+
+  // 9 · rebuilt in brick and stone (day, gold light)
+  { const st = cut_(8), br = Wd('brick', 8) - st;
+    add({ id: 'S09', at: st, cam: [540, 950], zoom: 0.08, note: 'daylight: new brick and stone city rises', draw(lt, d, t) {
+      K.parchment(9); ctx.fillStyle = P.sky; ctx.fillRect(-300, -300, W + 600, 1450); cut(P_circ(820, 380, 90), '#EFC66A', { shadow: 0.4, edge: 5 });
+      for (let i = 0; i < 5; i++) { const p = eob(seg(lt, 0.2 + i * 0.15, 0.55 + i * 0.15)); if (p <= 0) continue; ctx.save(); ctx.translate(0, (1 - p) * 500); house(110 + i * 215, 1450, 190, 380 + (i % 2) * 70, i % 2 ? '#B9A98C' : '#A8503E', i % 2 ? '#7E8B5A' : '#5E3B28'); ctx.restore(); }
+      cut(P_rr(-300, 1450, W + 600, 800, 0), P.sepia, { shadow: 0, edge: 0 });
+      K.ribbon('REBUILT', 540, 360, lt > br ? eob(seg(lt, br, br + 0.4)) : 0, 90);
+    } });
+    cue(st, 'whoosh'); for (let i = 0; i < 5; i++) cue(st + 0.25 + i * 0.15, 'thud', { gain: 0.35 }); cue(st + br, 'sparkle', { dur: 1 }); }
+
+  // 10 · all because of one small bakery (oven close-up, seal)
+  { const st = cut_(9);
+    add({ id: 'S10', at: st, cam: [540, 1150], zoom: 0.16, note: 'oven embers close-up, wax seal stamps', draw(lt, d, t) {
+      nightPage(10); cut(P_rr(-300, 1500, W + 600, 700, 0), '#4A3A2E', { shadow: 0, edge: 0 }); oven(540, 1500, 1.5, t);
+      K.seal(540, 520, lt > d - 1.1 ? eob(seg(lt, d - 1.1, d - 0.8)) * 1.2 : 0, 'L');
+    } });
+    cue(st, 'whoosh'); }
+
+  return { shots: S, cues: CUES };
+}

package/plugins/faceless-shorts/styles/paper-atlas/example/tools/capture.mjs

@@ -0,0 +1,122 @@
+// Frame-exact capture through headless Chrome. No npm packages (Node 22+). Run from the project folder.
+//   node tools/capture.mjs check                         boot, list shots + captions, report errors
+//   node tools/capture.mjs cues                          write data/cues.json (the sound cues, for tools/mix.py)
+//   node tools/capture.mjs sheet review/all.jpg [step=0.5] [cols=9]   contact sheet, a frame every `step` s, time-stamped
+//   node tools/capture.mjs frames review/full "1.2,8.4"  full-size JPEGs of those times
+//   node tools/capture.mjs video renders/out.mp4 [start end] [--draft]   the film (30 fps) with data/mix.wav if it exists
+//   node tools/capture.mjs preview                       serve the project and print a URL to watch it in a browser
+// CHROME=/path/to/chrome overrides the browser.
+import { spawn, spawnSync } from 'node:child_process';
+import http from 'node:http';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const FPS = +(process.env.FPS || 30);
+const CHROME = [process.env.CHROME, '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/Applications/Chromium.app/Contents/MacOS/Chromium',
+  '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge', '/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium',
+  '/usr/bin/chromium-browser', '/snap/bin/chromium', 'C:/Program Files/Google/Chrome/Application/chrome.exe',
+  'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'].find((p) => p && fs.existsSync(p));
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const args = process.argv.slice(2), flags = new Set(args.filter((a) => a.startsWith('--')));
+const [mode, ...rest] = args.filter((a) => !a.startsWith('--'));
+
+const MIME = { '.html': 'text/html', '.js': 'text/javascript', '.mjs': 'text/javascript', '.json': 'application/json', '.otf': 'font/otf',
+  '.ttf': 'font/ttf', '.woff2': 'font/woff2', '.wav': 'audio/wav', '.mp3': 'audio/mpeg', '.png': 'image/png', '.jpg': 'image/jpeg' };
+function serve(port = 0) {
+  return new Promise((res) => {
+    const srv = http.createServer((req, r) => {
+      const u = decodeURIComponent(req.url.split('?')[0]), f = path.join(ROOT, u === '/' ? 'index.html' : u);
+      if (!f.startsWith(ROOT) || !fs.existsSync(f) || fs.statSync(f).isDirectory()) { r.writeHead(404); r.end(); return; }
+      r.writeHead(200, { 'Content-Type': MIME[path.extname(f)] || 'application/octet-stream', 'Cache-Control': 'no-store' });
+      fs.createReadStream(f).pipe(r);
+    });
+    srv.listen(port, '127.0.0.1', () => res(srv));
+  });
+}
+
+async function openPage(port) {
+  if (!CHROME) throw new Error('Chrome not found: install Google Chrome or set CHROME=/path/to/chrome');
+  const prof = fs.mkdtempSync(path.join(os.tmpdir(), 'fs-chrome-'));
+  const chrome = spawn(CHROME, ['--headless=new', '--remote-debugging-port=0', `--user-data-dir=${prof}`, '--no-first-run', '--no-default-browser-check',
+    '--hide-scrollbars', '--window-size=1080,1920', '--ignore-gpu-blocklist', '--enable-unsafe-swiftshader', ...(process.env.SOFTWARE_GL ? ['--use-angle=swiftshader'] : []), ...(process.getuid?.() === 0 ? ['--no-sandbox'] : []), '--disable-background-timer-throttling', '--disable-renderer-backgrounding', 'about:blank'], { stdio: 'ignore' });
+  let dbg;
+  for (let i = 0; i < 200 && !dbg; i++) { try { dbg = fs.readFileSync(path.join(prof, 'DevToolsActivePort'), 'utf8').split('\n')[0].trim(); } catch { await sleep(100); } }
+  if (!dbg) throw new Error('Chrome did not start');
+  const r = await fetch(`http://127.0.0.1:${dbg}/json/new?${encodeURIComponent(`http://127.0.0.1:${port}/index.html?capture=1${process.env.QS || ''}`)}`, { method: 'PUT' });
+  const target = await r.json();
+  const ws = new WebSocket(target.webSocketDebuggerUrl);
+  await new Promise((res, rej) => { ws.onopen = res; ws.onerror = rej; });
+  let id = 0; const pend = new Map(), logs = [];
+  ws.onmessage = (e) => {
+    const m = JSON.parse(e.data);
+    if (m.id && pend.has(m.id)) { const p = pend.get(m.id); pend.delete(m.id); m.error ? p.rej(new Error(m.error.message)) : p.res(m.result); }
+    else if (m.method === 'Runtime.exceptionThrown') logs.push('EXCEPTION ' + (m.params.exceptionDetails.exception?.description || m.params.exceptionDetails.text));
+    else if (m.method === 'Runtime.consoleAPICalled' && m.params.type === 'error') logs.push('ERROR ' + m.params.args.map((a) => a.value ?? a.description).join(' '));
+  };
+  const send = (method, params = {}) => new Promise((res, rej) => { const i = ++id; pend.set(i, { res, rej }); ws.send(JSON.stringify({ id: i, method, params })); });
+  const ev = async (expr) => { const x = await send('Runtime.evaluate', { expression: expr, returnByValue: true, awaitPromise: true }); if (x.exceptionDetails) throw new Error(x.exceptionDetails.exception?.description || x.exceptionDetails.text); return x.result.value; };
+  await send('Runtime.enable');
+  for (let i = 0; ; i++) {
+    const st = await ev('window.OP ? (OP.bootError ? "ERR:" + OP.bootError : OP.ready) : false').catch(() => false);
+    if (st === true) break;
+    if (typeof st === 'string') throw new Error('boot failed: ' + st + '\n' + logs.join('\n'));
+    if (i > 1200) throw new Error('boot timeout\n' + logs.join('\n'));
+    await sleep(100);
+  }
+  const close = () => { try { ws.close(); } catch {} chrome.kill('SIGKILL'); setTimeout(() => { try { fs.rmSync(prof, { recursive: true, force: true }); } catch {} }, 300); };
+  return { ev, logs, close };
+}
+const jpg = (d) => Buffer.from(d.slice(d.indexOf(',') + 1), 'base64');
+const FRAME = (t, q, label) => `(() => { const d = OP.frame(${t}, ${q}); ${label ? `const cv = document.getElementById('cv'), c = cv.getContext('2d'); c.setTransform(1,0,0,1,0,0); c.fillStyle = '#000'; c.fillRect(0, 0, 250, 86); c.fillStyle = '#fff'; c.font = '700 60px sans-serif'; c.textAlign = 'left'; c.textBaseline = 'alphabetic'; c.fillText('${(+t).toFixed(2)}', 14, 64); return cv.toDataURL('image/jpeg', ${q});` : 'return d;'} })()`;
+
+const srv = await serve(mode === 'preview' ? 8765 : 0), port = srv.address().port;
+if (mode === 'preview') { console.log(`open http://127.0.0.1:${port}/  (Ctrl+C to stop)`); }
+else {
+  const P = await openPage(port);
+  try {
+    const dur = await P.ev('OP.duration()');
+    if (mode === 'check') {
+      console.log(`duration ${dur.toFixed(2)} s`);
+      for (const s of await P.ev('OP.shots()')) console.log(`${s.id.padEnd(5)} ${s.at.toFixed(2).padStart(6)} → ${s.end.toFixed(2).padStart(6)}  (${(s.end - s.at).toFixed(2)} s)  ${s.note}`);
+      console.log('captions:'); for (const c of await P.ev('OP.captions()')) console.log(`  ${c.s.toFixed(2).padStart(6)}–${c.e.toFixed(2).padEnd(6)} ${c.text}`);
+      let bad = 0; for (let t = 0; t < dur; t += 0.25) { try { await P.ev(`OP.draw(${t})`); } catch (e) { bad++; console.log(`ERROR at ${t.toFixed(2)}: ${e.message.split('\n')[0]}`); } }
+      if (P.logs.length) console.log(P.logs.join('\n'));
+      console.log(bad || P.logs.length ? 'CHECK FAILED' : 'CHECK OK');
+    } else if (mode === 'cues') {
+      const cues = await P.ev('OP.cues()');
+      fs.mkdirSync(path.join(ROOT, 'data'), { recursive: true });
+      fs.writeFileSync(path.join(ROOT, 'data/cues.json'), JSON.stringify({ duration: dur, cues }, null, 1));
+      console.log(`data/cues.json: ${cues.length} cues, ${dur.toFixed(2)} s`);
+    } else if (mode === 'frames') {
+      const dir = path.resolve(ROOT, rest[0] || 'review/frames'); fs.mkdirSync(dir, { recursive: true });
+      for (const t of (rest[1] || '0').split(',').map(Number)) { fs.writeFileSync(path.join(dir, `t${t.toFixed(2)}.jpg`), jpg(await P.ev(FRAME(t, 0.92)))); }
+      console.log(dir);
+    } else if (mode === 'sheet') {
+      const out = path.resolve(ROOT, rest[0] || 'review/all.jpg'), step = +(rest[1] || 0.5), cols = +(rest[2] || 9);
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'fs-sheet-')); let n = 0;
+      for (let t = step / 2; t < dur; t += step) fs.writeFileSync(path.join(tmp, `f${String(n++).padStart(4, '0')}.jpg`), jpg(await P.ev(FRAME(t, 0.8, true))));
+      const rows = Math.ceil(n / cols); fs.mkdirSync(path.dirname(out), { recursive: true });
+      const r = spawnSync('ffmpeg', ['-v', 'error', '-y', '-framerate', '1', '-i', path.join(tmp, 'f%04d.jpg'), '-vf', `scale=216:384,tile=${cols}x${rows}:padding=4:color=black`, '-frames:v', '1', '-q:v', '3', out]);
+      fs.rmSync(tmp, { recursive: true, force: true });
+      if (r.status) throw new Error('ffmpeg: ' + r.stderr); console.log(`${out} (${n} frames, every ${step} s)`);
+    } else if (mode === 'video') {
+      const out = path.resolve(ROOT, rest[0] || 'renders/video.mp4'); fs.mkdirSync(path.dirname(out), { recursive: true });
+      const mix = path.join(ROOT, 'data/mix.wav'), hasMix = fs.existsSync(mix), a0 = rest[1] ? +rest[1] : 0, a1 = rest[2] ? Math.min(+rest[2], dur) : dur, n = Math.round((a1 - a0) * FPS);
+      const ff = spawn('ffmpeg', ['-v', 'error', '-y', '-f', 'image2pipe', '-framerate', String(FPS), '-i', '-',
+        ...(hasMix ? ['-ss', String(a0), '-t', String(a1 - a0), '-i', mix] : ['-f', 'lavfi', '-i', 'anullsrc=r=48000:cl=stereo']), '-map', '0:v', '-map', '1:a',
+        '-c:v', 'libx264', '-preset', flags.has('--draft') ? 'ultrafast' : 'veryfast', '-crf', flags.has('--draft') ? '28' : '18', '-pix_fmt', 'yuv420p',
+        '-c:a', 'aac', '-b:a', '192k', '-shortest', '-movflags', '+faststart', out], { stdio: ['pipe', 'inherit', 'inherit'] });
+      const t0 = Date.now();
+      for (let i = 0; i < n; i++) {
+        const b = jpg(await P.ev(FRAME(a0 + i / FPS, flags.has('--draft') ? 0.8 : 0.93)));
+        if (!ff.stdin.write(b)) await new Promise((r) => ff.stdin.once('drain', r));
+        if (i % 150 === 0) process.stdout.write(`\r${i}/${n} frames`);
+      }
+      ff.stdin.end(); await new Promise((r) => ff.on('close', r));
+      console.log(`\r${out} (${n} frames, ${hasMix ? 'with data/mix.wav' : 'SILENT: no data/mix.wav'}, ${((Date.now() - t0) / 1000).toFixed(0)} s)`);
+    } else console.log('modes: check · cues · sheet · frames · video · preview');
+  } finally { P.close(); srv.close(); }
+}

package/plugins/faceless-shorts/styles/paper-atlas/example/tools/mix.py

@@ -0,0 +1,172 @@
+"""Inside Out soundtrack: narration + soft procedural sound effects + a quiet music bed, all made here with numpy.
+No samples, no AI audio, no downloads.
+
+  python3 tools/mix.py [project=.]          → data/mix.wav (48 kHz stereo)
+
+Reads data/cues.json (node tools/capture.mjs cues), data/narration.wav if it exists (voice.py or words.py --audio),
+and script.json "music": "bed" (the procedural score, default) · "none" · "audio/your-track.mp3" (your own royalty-free
+track, any format ffmpeg reads). The music ducks under the voice.
+
+Sound rules (STYLE.md): every effect is soft and rounded, nothing above ~5 kHz, no ticks / hats / glitches / beeps.
+Cue types: whoosh slide pop plop gulp boing bubbles sizzle sparkle thud slam tock zip alarm  (+ gain, dur)
+"""
+import json, subprocess, sys
+from pathlib import Path
+import numpy as np
+from scipy import signal
+from scipy.io import wavfile
+
+P = Path(sys.argv[1] if len(sys.argv) > 1 else '.')
+SR = 48000
+rng = np.random.default_rng(11)
+cj = json.loads((P / 'data/cues.json').read_text())
+script = json.loads((P / 'script.json').read_text())
+DUR = float(cj['duration'])
+N = int(DUR * SR) + SR // 10
+
+
+def lp(x, f, o=2): b, a = signal.butter(o, min(f, SR / 2 - 100) / (SR / 2), 'low'); return signal.lfilter(b, a, x)
+def hp(x, f, o=2): b, a = signal.butter(o, f / (SR / 2), 'high'); return signal.lfilter(b, a, x)
+def bp(x, f0, f1, o=2): b, a = signal.butter(o, [f0 / (SR / 2), f1 / (SR / 2)], 'band'); return signal.lfilter(b, a, x)
+def db(x): return 10 ** (x / 20)
+def tt(d): return np.arange(int(d * SR)) / SR
+def env(n, a=0.005, r=None):
+    """attack a seconds then exponential release over the rest"""
+    e = np.ones(n); na = max(1, int(a * SR)); e[:na] = np.linspace(0, 1, na)
+    rest = n - na; e[na:] = np.exp(-np.linspace(0, r or 5, rest)) if rest > 0 else 1; return e
+def sweep(f0, f1, d, shape='exp'):
+    t = tt(d); f = f0 * (f1 / f0) ** (t / d) if shape == 'exp' else f0 + (f1 - f0) * t / d
+    return np.sin(2 * np.pi * np.cumsum(f) / SR)
+def noise(d): return rng.standard_normal(int(d * SR))
+
+
+# ---------- the effects ----------
+def whoosh(d=0.38, **_):
+    n = noise(d); lo, hi = lp(n, 500), lp(n, 2200)
+    k = np.sin(np.pi * np.linspace(0, 1, len(n))); x = (lo * (1 - k) + hi * k) * k ** 1.5
+    return x / (np.abs(x).max() + 1e-9) * 0.5
+def slide(d=1.0, **_):
+    n = lp(noise(d), 700); e = np.sin(np.pi * np.linspace(0, 1, len(n))) ** 2
+    return n / (np.abs(n).max() + 1e-9) * e * 0.35 + sweep(260, 120, d) * e * 0.08
+def pop(**_): x = sweep(560, 240, 0.11) * env(int(0.11 * SR), 0.002, 6); return lp(x, 3000) * 0.7
+def plop(**_): x = sweep(700, 180, 0.14) * env(int(0.14 * SR), 0.002, 5); return lp(x, 2500) * 0.6
+def gulp(**_):
+    a = sweep(320, 140, 0.16) * env(int(0.16 * SR), 0.01, 4); b = sweep(240, 90, 0.2) * env(int(0.2 * SR), 0.01, 4)
+    x = np.concatenate([a, np.zeros(int(0.04 * SR)), b]); return lp(x, 1800) * 0.8
+def boing(**_):
+    d = 0.42; t = tt(d); f = 200 * (1 + 0.6 * t / d) * (1 + 0.08 * np.sin(2 * np.pi * 18 * t))
+    return lp(np.sin(2 * np.pi * np.cumsum(f) / SR) * env(len(t), 0.004, 4), 2000) * 0.55
+def bubbles(d=2.0, **_):
+    x = np.zeros(int(d * SR))
+    for _ in range(int(d * 7)):
+        st = rng.integers(0, max(1, len(x) - int(0.08 * SR))); f = rng.uniform(380, 900); b = sweep(f, f * 1.6, 0.06) * env(int(0.06 * SR), 0.003, 5)
+        x[st:st + len(b)] += b * rng.uniform(0.2, 0.5)
+    return lp(x, 2500) * 0.5
+def sizzle(d=1.0, **_):
+    n = bp(noise(d), 1800, 4500); crack = (rng.random(len(n)) < 0.002).astype(float); crack = lp(crack, 300) * 40
+    e = np.minimum(1, np.linspace(0, 6, len(n))) * np.linspace(1, 0.2, len(n)); return n * (0.4 + crack) * e * 0.12
+def sparkle(d=1.2, **_):
+    notes = [784, 880, 1047, 1175, 1319, 1568]; x = np.zeros(int(d * SR) + SR // 2)
+    for k, f in enumerate(notes):
+        st = int(k * d / len(notes) * SR); n = int(0.4 * SR); t = tt(0.4)
+        x[st:st + n] += (np.sin(2 * np.pi * f * t) + 0.3 * np.sin(4 * np.pi * f * t)) * env(n, 0.004, 6) * 0.22
+    return lp(x, 4500)
+def thud(**_):
+    d = 0.35; t = tt(d); x = np.sin(2 * np.pi * (70 + 40 * np.exp(-t * 30)) * t) * env(len(t), 0.002, 7)
+    return x * 0.9 + lp(noise(d), 220) * env(len(t), 0.001, 12) * 0.3
+def slam(**_):
+    d = 0.5; t = tt(d); x = np.sin(2 * np.pi * (60 + 60 * np.exp(-t * 25)) * t) * env(len(t), 0.002, 6)
+    return np.tanh(1.6 * (x + lp(noise(d), 1200) * env(len(t), 0.001, 10) * 0.6)) * 0.9
+def tock(**_): d = 0.09; t = tt(d); return (np.sin(2 * np.pi * 420 * t) + 0.3 * np.sin(2 * np.pi * 840 * t)) * env(len(t), 0.001, 9) * 0.35
+def zip_(**_):
+    d = 0.32; n = bp(noise(d), 400, 3000); k = np.linspace(0, 1, len(n))
+    return (n / (np.abs(n).max() + 1e-9) * 0.35 + sweep(300, 1100, d) * 0.12) * np.sin(np.pi * k) ** 1.2
+def alarm(d=2.0, **_):
+    x = np.zeros(int(d * SR)); one = np.sin(2 * np.pi * 150 * tt(0.22)) * env(int(0.22 * SR), 0.02, 5)
+    for st in np.arange(0, d - 0.25, 0.5): i = int(st * SR); x[i:i + len(one)] += one
+    return lp(x, 900) * 0.55
+
+def inhale(d=1.0, **_):
+    n = bp(noise(d), 300, 2600); k = np.linspace(0, 1, len(n)); e = np.sin(np.pi * np.minimum(1, k * 1.15)) ** 1.5 * (0.6 + 0.4 * k)
+    return n / (np.abs(n).max() + 1e-9) * e * 0.5
+def heartbeat(**_):
+    one = lambda d, f: np.sin(2 * np.pi * f * tt(d)) * env(int(d * SR), 0.004, 7)
+    x = np.concatenate([one(0.16, 58), np.zeros(int(0.09 * SR)), one(0.2, 52) * 0.75]); return lp(x, 300) * 1.0
+
+FX = dict(inhale=inhale, heartbeat=heartbeat, whoosh=whoosh, slide=slide, pop=pop, plop=plop, gulp=gulp, boing=boing, bubbles=bubbles, sizzle=sizzle,
+          sparkle=sparkle, thud=thud, slam=slam, tock=tock, zip=zip_, alarm=alarm)
+LEVEL = dict(inhale=-15, heartbeat=-8, whoosh=-17, slide=-19, pop=-14, plop=-15, gulp=-11, boing=-15, bubbles=-21, sizzle=-18, sparkle=-17,
+             thud=-11, slam=-9, tock=-18, zip=-14, alarm=-17)
+
+
+# ---------- the music bed: soft pad + plucked arpeggio, 100 BPM, I–vi–IV–V ----------
+def music_bed():
+    bpm = 100; beat = 60 / bpm; bar = beat * 4
+    chords = [[261.6, 329.6, 392.0], [220.0, 261.6, 329.6], [174.6, 220.0, 261.6], [196.0, 246.9, 293.7]]
+    x = np.zeros(N)
+    nb = int(np.ceil(DUR / bar)) + 1
+    for b in range(nb):
+        ch = chords[b % 4]; st = int(b * bar * SR); n = int(bar * SR)
+        if st >= N: break
+        t = tt(bar); e = np.minimum(1, t / 0.4) * np.minimum(1, (bar - t) / 0.4)
+        pad = sum(np.sin(2 * np.pi * f / 2 * t) + 0.25 * np.sin(2 * np.pi * f * t) for f in ch) * e * 0.10
+        x[st:st + n] += pad[:max(0, min(n, N - st))]
+        for k in range(8):                                                       # eighth-note pluck arpeggio
+            f = ch[[0, 1, 2, 1, 2, 0, 1, 2][k]] * (2 if k % 4 == 2 else 1); ps = st + int(k * beat / 2 * SR); pn = int(0.5 * SR)
+            if ps + pn >= N: continue
+            pt = tt(0.5); pl = (np.sin(2 * np.pi * f * pt) + 0.35 * np.sin(4 * np.pi * f * pt)) * env(pn, 0.003, 7) * 0.12
+            x[ps:ps + pn] += pl
+    x = lp(x, 3200)
+    fade = np.ones(N); fo = int(1.2 * SR); fade[-fo:] = np.linspace(1, 0, fo)
+    return x / (np.abs(x).max() + 1e-9) * fade
+
+def music_tension():
+    """low drone + slow minor pulse, for mysterious / tense explainers (script.json "music": "tension")"""
+    t = np.arange(N) / SR; x = np.zeros(N)
+    for f, g in [(55, 0.5), (82.4, 0.3), (110, 0.2), (130.8, 0.12)]: x += np.sin(2 * np.pi * f * t + np.sin(t * 0.3) * 0.5) * g
+    x *= 0.55 + 0.45 * np.sin(2 * np.pi * t / 8) ** 2
+    beat = 60 / 84; ping = lambda f: (np.sin(2 * np.pi * f * tt(1.2)) + 0.3 * np.sin(4 * np.pi * f * tt(1.2))) * env(int(1.2 * SR), 0.01, 5)
+    seq = [220.0, 261.6, 196.0, 174.6]
+    for k in range(int(DUR / (beat * 2))):
+        i = int(k * beat * 2 * SR); pg = ping(seq[(k // 2) % 4]) * 0.35
+        if i + len(pg) < N: x[i:i + len(pg)] += pg
+    x = lp(x, 2200); fade = np.ones(N); fo = int(1.5 * SR); fade[-fo:] = np.linspace(1, 0, fo); fi = int(0.8 * SR); fade[:fi] *= np.linspace(0, 1, fi)
+    return x / (np.abs(x).max() + 1e-9) * fade
+
+def load_audio(f):
+    out = subprocess.run(['ffmpeg', '-v', 'error', '-i', str(f), '-f', 'f32le', '-ac', '2', '-ar', str(SR), '-'], capture_output=True, check=True).stdout
+    a = np.frombuffer(out, dtype=np.float32).reshape(-1, 2).astype(np.float64); return a
+
+
+mix = np.zeros((N, 2))
+# voice
+vf = P / 'data/narration.wav'
+voice = None
+if vf.exists():
+    v = load_audio(vf)[:N]; voice = np.zeros((N, 2)); voice[:len(v)] = v
+    rms = np.sqrt(np.mean(voice ** 2) + 1e-12); voice *= db(-19) / rms
+    mix += voice
+# music
+mus = script.get('music', 'bed')
+if mus and mus != 'none':
+    m = music_bed() if mus == 'bed' else music_tension() if mus == 'tension' else None
+    if m is None:
+        a = load_audio(P / mus)[:N]; m = np.zeros(N); m[:len(a)] = a.mean(1); m /= np.abs(m).max() + 1e-9
+    m = np.stack([m, m], 1) * db(-24 if voice is not None else -20)
+    if voice is not None:                                                        # duck under the voice
+        lev = np.abs(voice.mean(1)); lev = signal.lfilter([1 - 0.9995], [1, -0.9995], lev); lev /= lev.max() + 1e-9
+        m *= (1 - 0.55 * np.clip(lev * 3, 0, 1))[:, None]
+    mix += m
+# effects
+for c in cj['cues']:
+    fn = FX.get(c['type'])
+    if not fn: print('unknown cue type, skipped:', c['type']); continue
+    x = fn(**({'d': c['dur']} if c.get('dur') else {}))
+    x = lp(x, 5000) * db(LEVEL[c['type']]) * c.get('gain', 1.0) / (np.abs(x).max() + 1e-9) * 0.9
+    i = int(c['t'] * SR); n = min(len(x), N - i)
+    if n > 0 and i >= 0: pan = c.get('pan', 0.0); mix[i:i + n, 0] += x[:n] * (1 - max(0, pan)); mix[i:i + n, 1] += x[:n] * (1 + min(0, pan))
+# master: gentle soft-clip, peak -1 dBFS
+mix = np.tanh(mix * 1.2) / 1.2
+mix *= db(-1) / (np.abs(mix).max() + 1e-9)
+wavfile.write(P / 'data/mix.wav', SR, (mix * 32767).astype(np.int16))
+print(f"data/mix.wav: {DUR:.2f} s · voice: {'yes' if voice is not None else 'NO (captions-only)'} · music: {mus} · {len(cj['cues'])} cues")

package/plugins/faceless-shorts/styles/stick-story/STYLE.md

@@ -0,0 +1,32 @@
+# Stick Story: "What would you do if…?" survival steps, 9:16
+
+Tense, clever, a little funny. Black stick people whose big white eyes do the acting, flat illustrated rooms in day and
+night versions, gold numbered step cards, one picture per clause.
+Example: `example/` = **WHAT IF THE POWER WENT OUT FOR 3 DAYS?** (34 s, 12 shots). Sheet: `style-sheet.png`.
+
+## 1. Rules
+- People are always ink black; colour lives in the room. At night, people get a soft warm glow (`glow: true`) so they
+  read against dark walls.
+- **Gold = steps.** Every step gets a gold numbered card (`K.stepCard(n, 'LABEL', 540, 300, scale)`) popping in on
+  "Step one". Red = danger (cross, warnings), green = safe (check).
+- One picture per clause: cut every 1.5-3 s; the eyes react first (look, then mood), then the body.
+- The same rooms all video; night versions for the problem, daylight for the happy ending.
+- Captions: sentence case on a dark rounded bar, 2-4 words, one gold word, y 1690 (they auto-shrink to fit).
+- Narration: lively, `am_puck`. Music `"bed"`. Sounds: pop on cards, whoosh on cuts, plops for objects, soft and round.
+- Safety advice is checked against official sources (Red Cross, Ready.gov, CDC) and listed in `script.json`.
+
+## 2. Kit (`example/src/core/kit.js`, `import * as K`)
+- `K.person({ x, y: K.GROUND, h (≈840), dir, walk, arms: { L: [shoulder, elbow], R }, legs, look: [x, y], mood:
+  'calm'│'happy'│'worried'│'scared'│'determined'│'sleepy', lean, hold: (x, y) => drawProp, blink, cap, glow })`
+- `K.bigHead(x, y, r, { mood, look })` close-ups.
+- Rooms: `K.livingRoom({ night, lampOn })`, `K.kitchen({ night })`, `K.hallway({ night, a, b, openA, openB })`;
+  pieces: `windowPane, couch, lamp, frameArt, plant, door, fridge, counter`.
+- Props: `phone(x, y, s, msg)`, `bottle`, `can`, `flashlight(x, y, s, on, angle)`, `backpack`.
+- Graphics: `stepCard`, `check`, `cross`, `counterPill(text, x, y, s)`, `thought(x, y, s, inner, tailX, tailY)`,
+  `cinemaBars(a)` (only on the scary beat), `captionBar`.
+- New set pieces go in `shots.js` (see `tv`, `plug`, `candle`, `bolt` in the example) or the kit if reusable.
+
+## 3. QA pitfalls we've hit
+- Black figures vanish on night walls → `glow: true` in every night shot.
+- Figures too small in the room → h ≈ 840 for full-body shots.
+- Long captions running off screen → keep chunks short; the bar auto-shrinks but small text is hard to read.