@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/suite/node-run.js

@@ -0,0 +1,81 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, relative, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const TRIES = `const tries = (specifier) => {
+  const stem = specifier.replace(/\\.(m?js)$/, '');
+  return [...new Set([stem + '.ts', stem + '.mts', specifier + '.ts', specifier + '/index.ts'])];
+};
+const retry = (specifier, e) => (/^\\.{1,2}\\//.test(specifier) || specifier.startsWith('file:'))
+  && (e?.code === 'ERR_MODULE_NOT_FOUND' || e?.code === 'ERR_UNSUPPORTED_DIR_IMPORT');
+`;
+export const HOOK = `${TRIES}export async function resolve(specifier, context, next) {
+  try { return await next(specifier, context); } catch (e) {
+    if (!retry(specifier, e)) throw e;
+    for (const s of tries(specifier)) { try { return await next(s, context); } catch {} }
+    throw e;
+  }
+}
+`;
+export const register = (hookUrl) => `import * as mod from 'node:module';
+${TRIES}if (typeof mod.registerHooks === 'function') {
+  mod.registerHooks({ resolve(specifier, context, next) {
+    try { return next(specifier, context); } catch (e) {
+      if (!retry(specifier, e)) throw e;
+      for (const s of tries(specifier)) { try { return next(s, context); } catch {} }
+      throw e;
+    }
+  } });
+} else mod.register(${JSON.stringify(hookUrl)});
+`;
+export function stripFlags(version = process.versions.node) {
+    const [major, minor] = version.split('.').map(Number);
+    if (major > 22 || (major === 22 && minor >= 18))
+        return [];
+    if (major === 22 && minor >= 6)
+        return ['--experimental-strip-types'];
+    return null;
+}
+export function testFiles(dir) {
+    const root = join(dir, 'test');
+    if (!existsSync(root))
+        return [];
+    const out = [];
+    const walk = (d) => {
+        for (const e of readdirSync(d, { withFileTypes: true })) {
+            const p = join(d, e.name);
+            if (e.isDirectory() && e.name !== 'node_modules')
+                walk(p);
+            else if (e.isFile() && /\.test\.(ts|mts|js|mjs)$/.test(e.name))
+                out.push(relative(dir, p).split(sep).join('/'));
+        }
+    };
+    walk(root);
+    return out.sort();
+}
+export function nodeArgs(files, register, flags) {
+    return [...flags, '--import', pathToFileURL(register).href, '--test', ...files];
+}
+export function nodeTest(dir, json = false, silent = false) {
+    const files = testFiles(dir);
+    if (!files.length)
+        return Promise.resolve({ exit: 127, why: 'no test/**/*.test.ts file', files });
+    const flags = stripFlags();
+    if (!flags)
+        return Promise.resolve({ exit: 127, why: `Node ${process.versions.node} cannot run TypeScript (22.18 or newer can)`, files });
+    const tmp = mkdtempSync(join(tmpdir(), 'funtools-test-'));
+    const hook = join(tmp, 'resolve.mjs');
+    const registrar = join(tmp, 'register.mjs');
+    writeFileSync(hook, HOOK);
+    writeFileSync(registrar, register(pathToFileURL(hook).href));
+    return new Promise((done) => {
+        const env = { ...process.env };
+        delete env.NODE_TEST_CONTEXT;
+        const child = spawn(process.execPath, nodeArgs(files, registrar, flags), { cwd: dir, env, stdio: silent ? 'ignore' : ['ignore', json ? 'pipe' : 'inherit', 'inherit'] });
+        child.stdout?.pipe(process.stderr);
+        const end = (exit) => { rmSync(tmp, { recursive: true, force: true }); done({ exit, files }); };
+        child.on('error', () => end(127));
+        child.on('close', (code) => end(code ?? 1));
+    });
+}

package/dist/suite/test-types.js

@@ -0,0 +1,71 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join, relative } from 'node:path';
+export const TEST_TSCONFIG = join('.funtools', 'tsconfig.tests.json');
+const NODE_TYPES = /TS2307: Cannot find module '[^']*[?#][^']*'|TS2307: Cannot find module '(node:[^']+|assert|test|fs|path|url|child_process|os|util)'|TS25(80|91|92)|TS2503: Cannot find namespace 'NodeJS'|TS2304: Cannot find name '(process|Buffer|__dirname|__filename|require|global)'/;
+export function testFiles(dir) {
+    const out = [];
+    const walk = (d, depth) => {
+        if (depth > 4 || out.length >= 200)
+            return;
+        let entries = [];
+        try {
+            entries = readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.name === 'node_modules' || e.name.startsWith('.'))
+                continue;
+            const p = join(d, e.name);
+            if (e.isDirectory())
+                walk(p, depth + 1);
+            else if (/\.(m|c)?tsx?$/.test(e.name) && !e.name.endsWith('.d.ts'))
+                out.push(relative(dir, p).split('\\').join('/'));
+        }
+    };
+    walk(join(dir, 'test'), 0);
+    return out.sort();
+}
+export function gameTsc(dir) {
+    try {
+        return createRequire(join(dir, 'package.json')).resolve('typescript/bin/tsc');
+    }
+    catch {
+        return null;
+    }
+}
+export function testDiagnostics(output) {
+    return output.split('\n').map((l) => l.trim())
+        .filter((l) => /^test[\\/][^(]+\(\d+,\d+\): error TS\d+:/.test(l) && !NODE_TYPES.test(l));
+}
+export function typecheckTests(dir, timeoutMs = 120_000) {
+    const files = testFiles(dir);
+    if (!files.length)
+        return { state: 'skipped', says: 'no TypeScript under test/', errors: [], files };
+    const tsc = gameTsc(dir);
+    if (!tsc)
+        return { state: 'skipped', says: 'TypeScript is not installed for this game: test/ was not type-checked', errors: [], files };
+    const config = {
+        ...(existsSync(join(dir, 'tsconfig.json')) ? { extends: '../tsconfig.json' } : {}),
+        compilerOptions: { noEmit: true, allowImportingTsExtensions: true, skipLibCheck: true, incremental: false, composite: false },
+        include: ['../test/**/*.ts', '../test/**/*.mts', '../src/**/*.ts', '../src/**/*.tsx'],
+    };
+    try {
+        mkdirSync(join(dir, '.funtools'), { recursive: true });
+        writeFileSync(join(dir, TEST_TSCONFIG), JSON.stringify(config, null, 2) + '\n');
+    }
+    catch {
+        return { state: 'skipped', says: `could not write ${TEST_TSCONFIG}`, errors: [], files };
+    }
+    const r = spawnSync(process.execPath, [tsc, '-p', TEST_TSCONFIG, '--pretty', 'false'], { cwd: dir, encoding: 'utf8', timeout: timeoutMs });
+    if (r.error)
+        return { state: 'skipped', says: `tsc could not run: ${r.error.message}`, errors: [], files };
+    const errors = testDiagnostics(`${r.stdout ?? ''}\n${r.stderr ?? ''}`);
+    if (!errors.length)
+        return { state: 'pass', says: `test/ type-checks against src/ (${files.length} file(s))`, errors: [], files };
+    const where = [...new Set(errors.map((e) => e.split('(')[0]))];
+    return { state: 'fail', says: `${where.slice(0, 3).join(', ')}${where.length > 3 ? ` and ${where.length - 3} more` : ''} ${where.length === 1 ? 'does' : 'do'} not type-check against src/ (${errors.length} error(s)): stale against the rules it drives`, errors: errors.slice(0, 20), files };
+}

package/dist/trailer/assemble.js

@@ -0,0 +1,90 @@
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { FRAME_PATTERN } from "../reel/encode.js";
+export const FPS = 30;
+export function takeArgs(framesDir, fps, out) {
+    return [
+        '-hide_banner', '-loglevel', 'error', '-y', '-framerate', String(fps), '-i', join(framesDir, FRAME_PATTERN),
+        '-vf', 'scale=trunc(iw/2)*2:trunc(ih/2)*2,format=yuv420p', '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '14', out,
+    ];
+}
+function fit(inp, out, fmt, k) {
+    const { width: w, height: h } = fmt;
+    return `[${inp}]split=2[fa${k}][fb${k}];`
+        + `[fa${k}]scale=${w}:${h}:force_original_aspect_ratio=increase,crop=${w}:${h},gblur=sigma=28,eq=brightness=-0.12[fbg${k}];`
+        + `[fb${k}]scale=${w}:${h}:force_original_aspect_ratio=decrease[ffg${k}];`
+        + `[fbg${k}][ffg${k}]overlay=(W-w)/2:(H-h)/2[${out}]`;
+}
+const frames = (inp, out, n, extra = '') => `[${inp}]fps=${FPS},tpad=stop_mode=clone:stop_duration=2,trim=end_frame=${n},setpts=PTS-STARTPTS${extra}[${out}]`;
+export function assembleArgs(cut, fmt, src, out, preset = 'medium') {
+    const args = ['-hide_banner', '-loglevel', 'error', '-y'];
+    let inputs = 0;
+    const input = (...a) => { args.push(...a); return inputs++; };
+    const take = input('-i', src.take);
+    const titleCard = input('-loop', '1', '-i', src.cards.title);
+    const endCard = input('-loop', '1', '-i', src.cards.end);
+    const shots = cut.segments.filter((s) => s.source === 'gameplay').length;
+    const generated = cut.segments.filter((s) => s.source === 'generated').length;
+    const label = generated ? input('-loop', '1', '-i', src.cards.label) : -1;
+    const clipInput = new Map();
+    for (const s of cut.segments) {
+        if (s.source === 'generated' && s.file && !clipInput.has(s.file))
+            clipInput.set(s.file, input('-i', s.file));
+    }
+    const audio = src.audio ? input('-i', src.audio) : -1;
+    const at = (t) => Math.round(t * FPS);
+    const graph = [];
+    if (shots)
+        graph.push(`[${take}:v]split=${shots}${Array.from({ length: shots }, (_, i) => `[take${i}]`).join('')}`);
+    if (generated)
+        graph.push(`[${label}:v]split=${generated}${Array.from({ length: generated }, (_, i) => `[lab${i}]`).join('')}`);
+    let shot = 0, gen = 0;
+    const finish = ',format=yuv420p,setsar=1';
+    cut.segments.forEach((s, k) => {
+        const n = at(s.start + s.duration) - at(s.start);
+        const done = `s${k}`;
+        if (s.source === 'gameplay') {
+            graph.push(`[take${shot++}]trim=start=${s.from.toFixed(3)},setpts=PTS-STARTPTS[t${k}]`);
+            graph.push(fit(`t${k}`, `f${k}`, fmt, k));
+            graph.push(frames(`f${k}`, done, n, finish));
+        }
+        else if (s.source === 'card') {
+            const fade = s.role === 'end'
+                ? `,fade=t=out:st=${Math.max(0, n / FPS - 0.5).toFixed(3)}:d=0.5`
+                : ',fade=t=in:st=0:d=0.3';
+            graph.push(frames(`${s.role === 'title' ? titleCard : endCard}:v`, done, n, `,scale=${fmt.width}:${fmt.height}${fade}${finish}`));
+        }
+        else {
+            graph.push(frames(`${clipInput.get(s.file)}:v`, `c${k}`, n));
+            graph.push(fit(`c${k}`, `g${k}`, fmt, k));
+            graph.push(`[lab${gen++}]scale=${fmt.width}:${fmt.height},format=rgba[l${k}]`);
+            graph.push(`[g${k}][l${k}]overlay=0:0:shortest=1${finish}[${done}]`);
+        }
+    });
+    graph.push(`${cut.segments.map((_, k) => `[s${k}]`).join('')}concat=n=${cut.segments.length}:v=1:a=0[v]`);
+    const total = at(cut.total) / FPS;
+    args.push('-filter_complex', graph.join(';'), '-map', '[v]');
+    if (src.audio)
+        args.push('-map', `${audio}:a`, '-c:a', 'aac', '-b:a', '192k', '-ar', '48000');
+    args.push('-c:v', 'libx264', '-preset', preset, '-crf', '20', '-pix_fmt', 'yuv420p', '-r', String(FPS), '-t', total.toFixed(3), '-movflags', '+faststart', out);
+    return args;
+}
+export function run(bin, args) {
+    const r = spawnSync(bin, args, { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    if (r.status === 0)
+        return { ok: true };
+    return { ok: false, error: (r.stderr || r.error?.message || `ffmpeg exited ${r.status}`).trim().split('\n').slice(-3).join(' ') };
+}
+export function probe(file) {
+    const r = spawnSync('ffprobe', ['-v', 'error', '-show_entries', 'stream=codec_type,width,height:format=duration', '-of', 'json', file], { encoding: 'utf8' });
+    if (r.status !== 0)
+        return null;
+    try {
+        const j = JSON.parse(r.stdout);
+        const v = (j.streams ?? []).find((s) => s.codec_type === 'video');
+        return { width: v?.width ?? 0, height: v?.height ?? 0, seconds: Number(j.format?.duration) || 0, audio: (j.streams ?? []).some((s) => s.codec_type === 'audio') };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/trailer/beats.js

@@ -0,0 +1,74 @@
+import { spawnSync } from 'node:child_process';
+export const DEFAULT_GRID = { bpm: 120, period: 0.5, offset: 0, detected: false };
+export const RATE = 11_025;
+const HOP = 256;
+const WIN = 512;
+const BPM_RANGE = [70, 180];
+const MAX_SECONDS = 60;
+export function decode(bin, file) {
+    const r = spawnSync(bin, ['-hide_banner', '-loglevel', 'error', '-t', String(MAX_SECONDS), '-i', file,
+        '-ac', '1', '-ar', String(RATE), '-f', 'f32le', '-'], { maxBuffer: 4 * RATE * MAX_SECONDS + 1024 });
+    if (r.status !== 0 || !r.stdout?.length)
+        return null;
+    const buf = r.stdout;
+    return new Float32Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + (buf.length & ~3)));
+}
+export function onsets(samples) {
+    const n = Math.max(0, Math.floor((samples.length - WIN) / HOP) + 1);
+    const energy = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        let e = 0;
+        for (let j = i * HOP, end = j + WIN; j < end; j++)
+            e += samples[j] * samples[j];
+        energy[i] = Math.log1p(e);
+    }
+    const flux = new Float64Array(n);
+    for (let i = 1; i < n; i++)
+        flux[i] = Math.max(0, energy[i] - energy[i - 1]);
+    return flux;
+}
+export function beatGrid(samples, rate = RATE) {
+    const flux = onsets(samples);
+    const hopS = HOP / rate;
+    if (flux.length < 64)
+        return DEFAULT_GRID;
+    const mean = flux.reduce((a, b) => a + b, 0) / flux.length;
+    if (mean <= 1e-9)
+        return DEFAULT_GRID;
+    const x = Array.from(flux, (v) => v - mean);
+    const minLag = Math.max(1, Math.floor(60 / BPM_RANGE[1] / hopS));
+    const maxLag = Math.ceil(60 / BPM_RANGE[0] / hopS);
+    let best = 0, bestLag = 0, total = 0, count = 0;
+    for (let lag = minLag; lag <= maxLag && lag < x.length / 2; lag++) {
+        let ac = 0;
+        for (let i = lag; i < x.length; i++)
+            ac += x[i] * x[i - lag];
+        ac /= x.length - lag;
+        const bpm = 60 / (lag * hopS);
+        const score = ac * Math.exp(-0.5 * Math.log2(bpm / 120) ** 2);
+        total += Math.max(0, score);
+        count++;
+        if (score > best) {
+            best = score;
+            bestLag = lag;
+        }
+    }
+    if (!bestLag || best <= 0 || best < 2 * (total / Math.max(1, count)))
+        return DEFAULT_GRID;
+    let period = bestLag * hopS, bestPhase = 0, combScore = -Infinity;
+    for (let f = 0.97; f <= 1.03 + 1e-9; f += 0.001) {
+        const P = bestLag * hopS * f;
+        for (let ph = 0; ph < Math.max(1, Math.round(P / hopS)); ph++) {
+            let s = 0, n = 0;
+            for (let t = ph * hopS; t / hopS < flux.length - 0.5; t += P, n++)
+                s += flux[Math.round(t / hopS)];
+            if (n && s / n > combScore) {
+                combScore = s / n;
+                period = P;
+                bestPhase = ph;
+            }
+        }
+    }
+    const offset = (bestPhase * hopS + (WIN - HOP / 2) / rate) % period;
+    return { bpm: Math.round((60 / period) * 10) / 10, period, offset, detected: true };
+}

package/dist/trailer/cards.js

@@ -0,0 +1,77 @@
+import { readFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+import { SAFE } from "./placement.js";
+export const FORMATS = {
+    '16x9': { name: '16x9', width: 1920, height: 1080 },
+    '9x16': { name: '9x16', width: 1080, height: 1920 },
+    '1x1': { name: '1x1', width: 1080, height: 1080 },
+    '4x5': { name: '4x5', width: 1080, height: 1350 },
+};
+function insets(fmt) {
+    const s = SAFE[fmt.name], floor = Math.round(Math.min(fmt.width, fmt.height) * 0.08);
+    const px = (share, side) => Math.max(floor, Math.round(share * side));
+    return `${px(s.top, fmt.height)}px ${px(s.right, fmt.width)}px ${px(s.bottom, fmt.height)}px ${px(s.left, fmt.width)}px`;
+}
+export const LABEL = 'Generated video · not gameplay';
+const MIME = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp' };
+async function dataUri(file) {
+    if (!file)
+        return null;
+    const mime = MIME[extname(file).toLowerCase()];
+    if (!mime)
+        return null;
+    return `data:${mime};base64,${(await readFile(file)).toString('base64')}`;
+}
+const esc = (s) => s.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
+export function cardHtml(kind, art, fmt, images) {
+    const short = Math.min(fmt.width, fmt.height);
+    const titleSize = Math.round(short * (kind === 'title' ? 0.11 : 0.085));
+    const bg = images.art
+        ? `background:#000 url("${images.art}") center/cover no-repeat;${images.blurred ? 'filter:blur(28px) brightness(.55);transform:scale(1.1);' : ''}`
+        : 'background:radial-gradient(circle at 50% 40%,#2b2f4a,#0b0c14);';
+    const dim = kind === 'end' ? 0.62 : 0.35;
+    const logo = images.logo
+        ? `<img src="${images.logo}" style="max-width:70%;max-height:${Math.round(fmt.height * 0.3)}px;object-fit:contain">`
+        : `<h1 style="margin:0;font-size:${titleSize}px;line-height:1.05;letter-spacing:-.01em">${esc(art.title)}</h1>`;
+    const cta = kind === 'end'
+        ? `<p style="margin:${Math.round(short * 0.04)}px 0 0;font-size:${Math.round(short * 0.045)}px;font-weight:600;opacity:.92">${esc(art.cta)}</p>`
+        : '';
+    return `<!doctype html><html><head><meta charset="utf-8"><style>
+html,body{margin:0;width:${fmt.width}px;height:${fmt.height}px;overflow:hidden;background:#000}
+.bg{position:absolute;inset:0;${bg}}
+.shade{position:absolute;inset:0;background:linear-gradient(to bottom,rgba(0,0,0,${dim * 0.4}),rgba(0,0,0,${dim}))}
+.fg{position:absolute;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:${kind === 'title' ? 'flex-end' : 'center'};
+padding:${insets(fmt)};box-sizing:border-box;text-align:center;color:#fff;
+font-family:"Avenir Next","Segoe UI",Roboto,"Helvetica Neue",Arial,sans-serif;font-weight:800;text-shadow:0 4px 24px rgba(0,0,0,.6)}
+</style></head><body><div class="bg"></div><div class="shade"></div><div class="fg">${logo}${cta}</div></body></html>`;
+}
+export function labelHtml(fmt, text = LABEL) {
+    const short = Math.min(fmt.width, fmt.height), s = SAFE[fmt.name];
+    return `<!doctype html><html><head><meta charset="utf-8"><style>
+html,body{margin:0;width:${fmt.width}px;height:${fmt.height}px;background:transparent}
+span{position:absolute;left:${Math.max(Math.round(short * 0.04), Math.round(s.left * fmt.width))}px;bottom:${Math.max(Math.round(short * 0.05), Math.round(s.bottom * fmt.height))}px;padding:${Math.round(short * 0.012)}px ${Math.round(short * 0.022)}px;
+border-radius:999px;background:rgba(0,0,0,.62);color:#fff;font:600 ${Math.round(short * 0.028)}px "Avenir Next","Segoe UI",Roboto,Arial,sans-serif}
+</style></head><body><span>${esc(text)}</span></body></html>`;
+}
+export async function renderCards(browser, art, fmt, dir) {
+    const keyArt = await dataUri(art.keyArt);
+    const images = {
+        art: keyArt ?? (await dataUri(art.backdrop)),
+        logo: await dataUri(art.logo),
+        blurred: !keyArt,
+    };
+    const page = await (await browser.newContext({ viewport: { width: fmt.width, height: fmt.height }, deviceScaleFactor: 1 })).newPage();
+    const out = { title: join(dir, `title-${fmt.name}.png`), end: join(dir, `end-${fmt.name}.png`), label: join(dir, `label-${fmt.name}.png`) };
+    try {
+        for (const kind of ['title', 'end']) {
+            await page.setContent(cardHtml(kind, art, fmt, images), { waitUntil: 'load' });
+            await page.screenshot({ path: out[kind], type: 'png' });
+        }
+        await page.setContent(labelHtml(fmt), { waitUntil: 'load' });
+        await page.screenshot({ path: out.label, type: 'png', omitBackground: true });
+    }
+    finally {
+        await page.context().close().catch(() => { });
+    }
+    return out;
+}

package/dist/trailer/cues.js

@@ -0,0 +1,78 @@
+export const SHOT_TAIL = 0.25;
+export const LONGEST_EFFECT = 8;
+export const MAX_CUES = 160;
+export function takeTime(frameTimes, t, fps) {
+    const n = frameTimes.length;
+    if (!n || !Number.isFinite(t) || t < frameTimes[0] || t > frameTimes[n - 1])
+        return null;
+    let i = 0;
+    while (i < n - 1 && frameTimes[i + 1] <= t)
+        i++;
+    if (i === n - 1)
+        return i / fps;
+    const span = frameTimes[i + 1] - frameTimes[i];
+    const frac = span > 0 ? (t - frameTimes[i]) / span : 0;
+    return (i + frac) / fps;
+}
+export function skipReason(c) {
+    if (c.kind === 'synth')
+        return 'synth';
+    if (c.kind === 'made')
+        return 'made in the page';
+    if (!c.src)
+        return 'no file';
+    if (c.loop || (c.seconds !== null && c.seconds > LONGEST_EFFECT && c.duration === null))
+        return 'loop (the bed)';
+    if (!(c.gain > 0))
+        return 'muted';
+    if (c.state === 'suspended' || c.state === 'closed')
+        return 'context suspended';
+    return null;
+}
+const round3 = (n) => Math.round(n * 1000) / 1000;
+export function placeCues(cues, frameTimes, fps, cut) {
+    const used = [];
+    const skipped = new Map();
+    let outside = 0, offFilm = 0;
+    const shots = cut.segments.map((s, k) => ({ s, k })).filter(({ s }) => s.source === 'gameplay');
+    for (const c of cues) {
+        const why = skipReason(c);
+        if (why) {
+            const key = `${c.name}\u0000${why}`;
+            const k = skipped.get(key) ?? { name: c.name, kind: c.kind, reason: why, count: 0 };
+            k.count++;
+            skipped.set(key, k);
+            continue;
+        }
+        const tau = takeTime(frameTimes, c.t, fps);
+        if (tau === null) {
+            offFilm++;
+            continue;
+        }
+        const hit = shots.find(({ s }) => tau >= s.from - 1e-6 && tau < s.from + s.duration - 1e-6);
+        if (!hit) {
+            outside++;
+            continue;
+        }
+        const { s, k } = hit;
+        const at = s.start + (tau - s.from);
+        const own = c.duration ?? (c.seconds !== null ? Math.max(0, c.seconds - c.offset) / Math.max(0.05, c.rate) : LONGEST_EFFECT);
+        const length = Math.min(own, s.start + s.duration + SHOT_TAIL - at);
+        if (length <= 0.02) {
+            outside++;
+            continue;
+        }
+        used.push({ at: round3(at), take: round3(tau), name: c.name, src: c.src, gain: round3(c.gain), rate: round3(c.rate), offset: round3(c.offset), length: round3(length), segment: k });
+    }
+    used.sort((a, b) => a.at - b.at);
+    const kept = used.length > MAX_CUES
+        ? [...used].sort((a, b) => b.gain - a.gain).slice(0, MAX_CUES).sort((a, b) => a.at - b.at)
+        : used;
+    outside += used.length - kept.length;
+    return { used: kept, skipped: [...skipped.values()].sort((a, b) => b.count - a.count || (a.name < b.name ? -1 : 1)), outside, offFilm };
+}
+export function loopedBed(cues) {
+    const beds = cues.filter((c) => c.src && c.loop && c.gain > 0 && (c.kind === 'buffer' || c.kind === 'media'));
+    beds.sort((a, b) => (b.seconds ?? 0) - (a.seconds ?? 0));
+    return beds[0]?.src ?? null;
+}

package/dist/trailer/cut.js

@@ -0,0 +1,49 @@
+export const MAX_CLIP_SECONDS = 4;
+const round3 = (n) => Math.round(n * 1000) / 1000;
+export function planCut(input) {
+    const p = input.grid.period;
+    const beats = (seconds, min = 1) => Math.max(min, Math.round(seconds / p));
+    const titleBeats = beats(2, 2);
+    const endBeats = beats(2.5, 2);
+    const clipCap = Math.min(MAX_CLIP_SECONDS, input.seconds / 5);
+    const clipBeats = (c) => (c ? Math.max(1, Math.min(Math.floor(c.seconds / p), Math.floor(clipCap / p))) : 0);
+    const introBeats = clipBeats(input.intro);
+    const outroBeats = clipBeats(input.outro);
+    let shotBeats = beats(1.8);
+    let playBeats = Math.max(shotBeats, beats(input.seconds) - titleBeats - endBeats - introBeats - outroBeats);
+    if (input.footage < shotBeats * p) {
+        shotBeats = Math.max(1, Math.floor(input.footage / p));
+        playBeats = shotBeats;
+    }
+    const L = shotBeats * p;
+    const shots = Math.max(1, Math.min(Math.floor(playBeats / shotBeats), Math.floor(input.footage / L) || 1));
+    const maxStart = Math.max(0, input.footage - L);
+    const clamp = (s) => Math.max(0, Math.min(maxStart, s));
+    const chosen = [];
+    const free = (s) => chosen.every((c) => Math.abs(c.from - s) >= L - 1e-6);
+    const take = (s, moment) => { if (chosen.length < shots && free(s))
+        chosen.push({ from: s, moment }); };
+    for (const m of [...input.moments].filter((m) => m.weight > 0).sort((a, b) => b.weight - a.weight || a.t - b.t)) {
+        take(clamp(m.t - 0.75 * L), m.name);
+    }
+    for (let k = 0; k < shots; k++)
+        take(clamp(((k + 0.5) * input.footage) / shots - L / 2));
+    for (let s = 0; s <= maxStart + 1e-6 && chosen.length < shots; s += L)
+        take(s);
+    chosen.sort((a, b) => a.from - b.from);
+    const spare = Math.min(playBeats - chosen.length * shotBeats, Math.floor((input.footage - (chosen.at(-1)?.from ?? 0)) / p) - shotBeats);
+    const segments = [];
+    let at = 0;
+    const push = (s) => { segments.push({ ...s, start: round3(at), duration: round3(s.duration), from: round3(s.from) }); at += s.duration; };
+    if (input.intro)
+        push({ source: 'generated', role: 'intro', duration: introBeats * p, from: 0, file: input.intro.file });
+    push({ source: 'card', role: 'title', duration: titleBeats * p, from: 0 });
+    chosen.forEach((c, i) => {
+        const beatsHere = shotBeats + (i === chosen.length - 1 ? Math.max(0, spare) : 0);
+        push({ source: 'gameplay', role: 'shot', duration: beatsHere * p, from: c.from, ...(c.moment ? { moment: c.moment } : {}) });
+    });
+    if (input.outro)
+        push({ source: 'generated', role: 'outro', duration: outroBeats * p, from: 0, file: input.outro.file });
+    push({ source: 'card', role: 'end', duration: endBeats * p, from: 0 });
+    return { segments, total: round3(at), shotSeconds: round3(L) };
+}

package/dist/trailer/find.js

@@ -0,0 +1,33 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+const IMAGE = /\.(png|jpe?g|webp)$/i;
+const AUDIO = /\.(mp3|ogg|m4a|wav|aac|flac)$/i;
+function files(dir, depth = 0) {
+    if (depth > 4 || !existsSync(dir))
+        return [];
+    const out = [];
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+        if (e.name.startsWith('.') || e.name === 'node_modules' || e.name === 'dist')
+            continue;
+        const p = join(dir, e.name);
+        if (e.isDirectory())
+            out.push(...files(p, depth + 1));
+        else if (e.isFile())
+            out.push(p);
+    }
+    return out.sort();
+}
+const named = (list, re) => list.filter((f) => re.test(basename(f, extname(f))));
+export function findMaterial(dir, manifest) {
+    const where = ['design', 'public', 'assets', 'src/assets'].flatMap((d) => files(join(dir, d)));
+    const images = where.filter((f) => IMAGE.test(f));
+    const audio = where.filter((f) => AUDIO.test(f));
+    const title = [manifest.name, manifest.metadata?.title, manifest.title]
+        .find((t) => typeof t === 'string' && t.trim() !== '')?.trim() ?? basename(dir);
+    const keyArt = named(images, /^(key[-_ ]?art|cover|poster|hero[-_ ]?art|splash|capsule)([-_.].*)?$/i)[0];
+    const logo = named(images, /^(logo|wordmark|title[-_ ]?logo)([-_.].*)?$/i)[0];
+    const inMusic = audio.filter((f) => /[\\/](music|bgm|soundtrack)[\\/]/i.test(f));
+    const byName = named(audio, /(music|bgm|theme|soundtrack|song|track|loop)/i);
+    const music = [...inMusic, ...byName].sort((a, b) => statSync(b).size - statSync(a).size)[0];
+    return { title, ...(keyArt ? { keyArt } : {}), ...(logo ? { logo } : {}), ...(music ? { music } : {}) };
+}