@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/simulator/simctl.js

@@ -0,0 +1,79 @@
+import { execFile } from 'node:child_process';
+export const realSimctl = (args, timeoutMs = 120_000) => new Promise((ok, fail) => {
+    execFile('xcrun', ['simctl', ...args], { timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 }, (err, stdout, stderr) => {
+        if (err)
+            fail(new Error(`simctl ${args[0]}: ${String(stderr || err.message).trim().split('\n').slice(-2).join(' ')}`));
+        else
+            ok(String(stdout));
+    });
+});
+export const LEASE_PREFIX = 'ft-lease-';
+export const LIFE_VERBS = new Set(['boot', 'shutdown', 'delete', 'erase', 'rename', 'clone', 'upgrade']);
+const MANY = new Set(['all', 'booted', 'unavailable']);
+const UDID = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
+export const isUdid = (s) => UDID.test(s);
+export class Refused extends Error {
+}
+export function guarded(run, isLease) {
+    return async (args, timeoutMs) => {
+        const [verb, target] = args;
+        for (const a of args.slice(1))
+            if (MANY.has(a.toLowerCase()))
+                throw new Refused(`refused: simctl ${verb} ${a} would reach other agents' simulators — funtools names one leased device by udid`);
+        if (LIFE_VERBS.has(verb)) {
+            if (verb === 'clone' || verb === 'rename' || verb === 'upgrade')
+                throw new Refused(`refused: simctl ${verb} is not a lease verb`);
+            if (!target || !isUdid(target))
+                throw new Refused(`refused: simctl ${verb} ${target ?? ''} — a lease is named by its udid`);
+            if (!isLease(target))
+                throw new Refused(`refused: ${target} is not a funtools lease (funtools only boots, shuts down or deletes simulators it created)`);
+        }
+        return run(args, timeoutMs);
+    };
+}
+export function parseDevices(json) {
+    try {
+        const d = JSON.parse(json).devices ?? {};
+        return Object.entries(d).flatMap(([runtime, list]) => list.filter((x) => x && typeof x.udid === 'string').map((x) => ({ udid: x.udid, name: String(x.name), state: String(x.state), runtime, deviceTypeIdentifier: x.deviceTypeIdentifier, isAvailable: x.isAvailable })));
+    }
+    catch {
+        return [];
+    }
+}
+export function parseDeviceTypes(json) {
+    try {
+        return (JSON.parse(json).devicetypes ?? []).filter((x) => x && x.identifier && x.name);
+    }
+    catch {
+        return [];
+    }
+}
+export function parseRuntimes(json) {
+    try {
+        return (JSON.parse(json).runtimes ?? []).filter((x) => x && x.identifier && x.name);
+    }
+    catch {
+        return [];
+    }
+}
+const ver = (v) => v.split('.').map(Number);
+const newerFirst = (a, b) => {
+    const x = ver(a.version), y = ver(b.version);
+    for (let i = 0; i < Math.max(x.length, y.length); i++)
+        if ((x[i] ?? 0) !== (y[i] ?? 0))
+            return (y[i] ?? 0) - (x[i] ?? 0);
+    return 0;
+};
+export function pickDeviceType(types, want) {
+    const w = want.toLowerCase();
+    return types.find((t) => t.identifier.toLowerCase() === w || t.name.toLowerCase() === w) ?? null;
+}
+export function pickRuntime(runtimes, type, want) {
+    const fits = runtimes.filter((r) => r.isAvailable && (!r.supportedDeviceTypes || r.supportedDeviceTypes.some((s) => s.identifier === type.identifier)));
+    if (want) {
+        const w = want.toLowerCase().replace(/^ios\s*/, '');
+        return fits.find((r) => r.identifier.toLowerCase() === want.toLowerCase() || r.name.toLowerCase() === want.toLowerCase() || r.version === w) ?? null;
+    }
+    const family = /iPhone|iPad/.test(type.name) ? 'iOS' : null;
+    return fits.filter((r) => !family || (r.platform ?? r.name).startsWith(family)).sort(newerFirst)[0] ?? null;
+}

package/dist/smoke/art.js

@@ -0,0 +1,20 @@
+import { posix } from 'node:path';
+export const ART_FILE = /\.(png|jpe?g|webp|avif|gif|ktx2|basis|glb|gltf|hdr|exr)$/i;
+const NOT_GAME_ART = /(^|\/)(favicon|apple-touch-icon|icon-\d+|target|style-frame)[^/]*$|^public\/(draco|basis)\/|(^|\/)store-shots?\//i;
+const PRIMITIVE = [
+    /\bnew\s+(?:PIXI\.)?Graphics\s*\(/,
+    /\.(?:fillRect|strokeRect|arc|ellipse|roundRect)\s*\(/,
+    /\bnew\s+(?:THREE\.)?(?:Box|Sphere|Plane|Cylinder|Cone|Capsule|Circle|Torus|Ring|Icosahedron|Octahedron|Tetrahedron|Dodecahedron)Geometry\s*\(/,
+];
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+export function referenced(file, corpus) {
+    const base = posix.basename(file);
+    const stem = base.replace(/\.[^.]+$/, '');
+    return corpus.includes(base) || new RegExp(`['"\`/]${escape(stem)}['"\`.]`).test(corpus);
+}
+export function artReport(files, texts, code) {
+    const corpus = texts.map((t) => t.text).join('\n');
+    const art = [...files].filter((f) => ART_FILE.test(f) && !NOT_GAME_ART.test(f) && referenced(f, corpus));
+    const primitives = code.filter((c) => /\.[cm]?[jt]sx?$/.test(c.path) && PRIMITIVE.some((re) => re.test(c.text))).map((c) => c.path);
+    return { art, primitives };
+}

package/dist/smoke/checks.js

@@ -0,0 +1,165 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { join, posix } from 'node:path';
+import { ASSET, lineOf } from "./sources.js";
+import { artReport } from "./art.js";
+import { assetUses, templates } from "./orphans.js";
+const STRING_TODO = /(['"`])(?:(?!\1)[^\n])*?\b(TODO|TBD|FIXME)\b(?:(?!\1)[^\n])*?\1/g;
+export function placeholders(game) {
+    const out = [];
+    let commentTodos = 0;
+    for (const s of game.sources) {
+        const hit = (re, what) => {
+            for (const m of s.code.matchAll(re))
+                out.push({ level: 'FAIL', check: 'placeholder', path: s.path, line: lineOf(s.code, m.index), what: `${what}: ${m[0].trim().slice(0, 60)}` });
+        };
+        hit(/lorem ipsum/gi, 'lorem ipsum');
+        if (/\.html$/i.test(s.path)) {
+            hit(/>[^<]*\b(TODO|TBD|FIXME|PLACEHOLDER)\b[^<]*</g, 'placeholder text on the page');
+        }
+        else {
+            hit(STRING_TODO, 'placeholder text in a string the game may show');
+        }
+        commentTodos += [...s.text.matchAll(/\b(TODO|FIXME)\b/g)].length - [...s.code.matchAll(/\b(TODO|FIXME)\b/g)].length;
+    }
+    if (commentTodos > 0)
+        out.push({ level: 'warn', check: 'placeholder', path: '', what: `${commentTodos} TODO/FIXME comment(s) in the source` });
+    return out;
+}
+const ASSET_REF = /(['"`(])((?:\.{1,2}\/|\/)?[\w@.\/ -]*?[\w-]\.(?:png|jpe?g|webp|gif|avif|svg|mp3|m4a|ogg|wav|aac|flac|glb|gltf|ktx2|basis|hdr|woff2?|ttf|otf|mp4|webm|fnt|atlas))(?:[?#][^'"`)\s]*)?['"`)]/gi;
+const norm = (p) => posix.normalize(p).replace(/^(\.\/)+/, '').replace(/^\/+/, '');
+function candidates(from, ref) {
+    const out = [norm(ref), norm(`public/${norm(ref)}`)];
+    if (!ref.startsWith('/'))
+        out.unshift(norm(posix.join(posix.dirname(from), ref)));
+    return out;
+}
+export function assets(game) {
+    const out = [];
+    const basenames = new Set([...game.files].map((f) => posix.basename(f)));
+    const manifests = game.texts.filter((t) => /\.(json|atlas|fnt)$/i.test(t.path)).map((t) => t.text).join('\n');
+    for (const s of game.sources) {
+        for (const m of s.code.matchAll(ASSET_REF)) {
+            const ref = m[2];
+            if (ref.startsWith('//') || ref.includes('${'))
+                continue;
+            const cands = candidates(s.path, ref);
+            if (cands.some((c) => game.files.has(c))) {
+                if (ref.startsWith('/') && !/\.html?$/i.test(s.path))
+                    out.push({ level: 'warn', check: 'base', path: s.path, line: lineOf(s.code, m.index), what: `"${ref}" loads from the site root and 404s when the game is hosted in a subfolder — use "${ref.slice(1)}" (relative) or \`\${import.meta.env.BASE_URL}${ref.slice(1)}\`` });
+                continue;
+            }
+            const base = posix.basename(ref);
+            if (!ref.includes('/') && (basenames.has(base) || manifests.includes(`"${base}"`)))
+                continue;
+            const hidden = cands.find((c) => existsSync(join(game.dir, c)));
+            out.push({
+                level: 'FAIL', check: 'asset', path: s.path, line: lineOf(s.code, m.index),
+                what: hidden
+                    ? `"${ref}" exists as ${hidden} but is excluded from the upload — it works in dev and 404s live`
+                    : `"${ref}" is not in the upload — it will 404`,
+            });
+        }
+    }
+    out.push(...hiddenByName(game));
+    for (const a of assetUses(game)) {
+        if (a.use !== 'unreferenced')
+            continue;
+        out.push({ level: 'warn', check: 'orphan', path: a.path, what: 'shipped but nothing names it: no text file, no name built in code, no request in the last verify — wire it or remove it' });
+    }
+    return out;
+}
+export function art(game) {
+    const r = artReport(game.files, game.texts, game.sources.map((s) => ({ path: s.path, text: s.code })));
+    if (r.art.length || !r.primitives.length)
+        return [];
+    return [{
+            level: 'warn', check: 'art', path: r.primitives[0],
+            what: 'the game draws only shapes in code: no image or model it ships is loaded. Make the target frame and sprites (skill funpixel-art), then load them',
+        }];
+}
+export const IMPORT = /\b(?:import|export)\s+(?!type\b)[^'"`;]*?\bfrom\s*['"]([^'"]+)['"]|\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)|\bimport\s*['"]([^'"]+)['"]/g;
+const NODE_BUILTINS = new Set(['fs', 'fs/promises', 'path', 'os', 'child_process', 'net', 'http', 'https', 'zlib', 'worker_threads', 'crypto', 'module']);
+const RESOLVE_EXT = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.json', '/index.ts', '/index.tsx', '/index.js'];
+const NODE_SIDE = /(^|\/)[\w.-]*\.config\.[cm]?[jt]s$|^(scripts|tools|server|tests?)\/|\.(test|spec)\.[cm]?[jt]sx?$|^src\/art\/files\.mjs$/;
+function aliases(game) {
+    let prefixes = [];
+    try {
+        const ts = JSON.parse(game.texts.find((t) => t.path === 'tsconfig.json')?.text ?? '{}');
+        prefixes = Object.keys(ts.compilerOptions?.paths ?? {}).map((k) => k.replace(/\*$/, ''));
+    }
+    catch { }
+    return (spec) => /^[#~]/.test(spec) || /^@[^/]+$/.test(spec) || prefixes.some((p) => (p.endsWith('/') ? spec.startsWith(p) : spec === p || spec.startsWith(`${p}/`)));
+}
+export const packageOf = (spec) => spec.split('/').slice(0, spec.startsWith('@') ? 2 : 1).join('/');
+export function imports(game) {
+    const out = [];
+    const deps = new Set(Object.keys({ ...game.pkg?.dependencies, ...game.pkg?.devDependencies }));
+    const isAlias = aliases(game);
+    for (const s of game.sources) {
+        if (/\.(html|css)$/i.test(s.path) || NODE_SIDE.test(s.path))
+            continue;
+        for (const m of s.code.matchAll(IMPORT)) {
+            const spec = (m[1] ?? m[2] ?? m[3]).split('?')[0];
+            const line = lineOf(s.code, m.index);
+            if (/^(virtual:|https?:|data:|\/@|\0)/.test(spec) || isAlias(spec))
+                continue;
+            if (spec.startsWith('node:') || NODE_BUILTINS.has(spec)) {
+                out.push({ level: 'FAIL', check: 'import', path: s.path, line, what: `imports "${spec}", a Node built-in — a browser has none` });
+            }
+            else if (spec.startsWith('.') || spec.startsWith('/')) {
+                const base = spec.startsWith('/') ? norm(spec) : norm(posix.join(posix.dirname(s.path), spec));
+                const bases = [base, base.replace(/\.(m?js|jsx)$/, '')];
+                if (bases.some((b) => RESOLVE_EXT.some((e) => game.files.has(b + e) || game.files.has(norm(`public/${b}${e}`)))))
+                    continue;
+                out.push({ level: 'FAIL', check: 'import', path: s.path, line, what: `imports "${spec}", which is not in the upload` });
+            }
+            else if (!deps.has(packageOf(spec))) {
+                out.push({ level: 'FAIL', check: 'import', path: s.path, line, what: `imports "${spec}", but package.json does not list "${packageOf(spec)}" — the platform's clean install won't have it` });
+            }
+        }
+    }
+    return out;
+}
+function excludedAssets(game) {
+    const out = [];
+    const walk = (rel, depth) => {
+        if (out.length > 2000 || depth > 6)
+            return;
+        for (const e of readdirSync(join(game.dir, rel), { withFileTypes: true })) {
+            const p = `${rel}/${e.name}`;
+            if (e.isDirectory())
+                walk(p, depth + 1);
+            else if (ASSET.test(p))
+                out.push(p);
+        }
+    };
+    for (const e of game.staged.excluded) {
+        if (e.rule.line === 0 || !e.path.startsWith('public/'))
+            continue;
+        if (!e.isDir) {
+            if (ASSET.test(e.path))
+                out.push(e.path);
+        }
+        else
+            try {
+                walk(e.path, 0);
+            }
+            catch { }
+    }
+    return out;
+}
+function hiddenByName(game) {
+    const hidden = excludedAssets(game);
+    if (!hidden.length)
+        return [];
+    const out = [];
+    for (const t of templates(game)) {
+        for (const h of hidden) {
+            const served = h.replace(/^public\//, '');
+            if (![h, served, `/${served}`].some((p) => t.re.test(p)))
+                continue;
+            out.push({ level: 'FAIL', check: 'asset', path: t.path, line: t.line, what: `${t.template} can name ${h}, which .harnessignore excludes from the upload — it works in dev and 404s live` });
+        }
+    }
+    return out;
+}

package/dist/smoke/logic.js

@@ -0,0 +1,73 @@
+import { posix } from 'node:path';
+import { lineOf } from "./sources.js";
+import { IMPORT, packageOf } from "./checks.js";
+export const LOGIC_FILE = /^src\/(rules\.[cm]?[jt]s|(sim|logic|rules)\/(?!.*\.(test|spec)\.).+\.[cm]?[jt]sx?)$/;
+const VISUAL = new Set(['pixi.js', 'three', 'preact', 'react', 'react-dom', 'phaser', 'howler', '@react-three/fiber']);
+const isVisual = (spec) => VISUAL.has(packageOf(spec)) || /^@(pixi|babylonjs)\//.test(spec);
+const DOM = /\b(window|document|navigator|localStorage|sessionStorage|requestAnimationFrame)\b(?=\s*[.([])/g;
+const RANDOM = /\bMath\.random\s*\(/g;
+const BOUNDS = /\.(getBounds|getGlobalPosition|getWorldPosition)\s*\(|\bsetFromObject\s*\(/;
+const PIXI_BOUNDS = /\.getBounds\s*\(/g;
+const HIT_WORDS = /\b(intersects?\w*|overlap\w*|collid\w*|collision\w*|hit\w*)\b/i;
+const MAX_BOUNDS_FINDINGS = 3;
+const EXTS = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '/index.ts', '/index.js'];
+function importsOf(s) {
+    return [...s.code.matchAll(IMPORT)].map((m) => ({ spec: (m[1] ?? m[2] ?? m[3]).split('?')[0], line: lineOf(s.code, m.index) }));
+}
+function resolveLocal(byPath, from, spec) {
+    if (!spec.startsWith('.'))
+        return undefined;
+    const base = posix.normalize(posix.join(posix.dirname(from), spec));
+    for (const b of [base, base.replace(/\.(m?js|jsx)$/, '')])
+        for (const e of EXTS)
+            if (byPath.has(b + e))
+                return byPath.get(b + e);
+    return undefined;
+}
+function visualReach(byPath, s, seen = new Set()) {
+    if (seen.has(s.path))
+        return null;
+    seen.add(s.path);
+    for (const { spec } of importsOf(s)) {
+        if (isVisual(spec))
+            return [spec, []];
+        const next = resolveLocal(byPath, s.path, spec);
+        const found = next && visualReach(byPath, next, seen);
+        if (found)
+            return [found[0], [next.path, ...found[1]]];
+    }
+    return null;
+}
+export function logic(game) {
+    const out = [];
+    const code = game.sources.filter((s) => /\.[cm]?[jt]sx?$/.test(s.path));
+    const byPath = new Map(code.map((s) => [s.path, s]));
+    const warn = (path, line, what) => out.push({ level: 'warn', check: 'logic', path, line, what });
+    for (const s of code.filter((c) => LOGIC_FILE.test(c.path))) {
+        for (const { spec, line } of importsOf(s)) {
+            if (isVisual(spec)) {
+                warn(s.path, line, `the rules import "${spec}" — keep them engine-free: plain state in, state and events out; the renderer reads them`);
+                continue;
+            }
+            const local = resolveLocal(byPath, s.path, spec);
+            const reach = local && !LOGIC_FILE.test(local.path) ? visualReach(byPath, local) : null;
+            if (reach)
+                warn(s.path, line, `the rules import ${[local.path, ...reach[1]].join(' → ')}, which imports "${reach[0]}" — move what the rules need into the logic folder`);
+        }
+        for (const m of s.code.matchAll(DOM))
+            warn(s.path, lineOf(s.code, m.index), `the rules touch ${m[1]} — pass what they need in as data`);
+        for (const m of s.code.matchAll(RANDOM))
+            warn(s.path, lineOf(s.code, m.index), 'Math.random() in the rules: pass a seeded random source in, so a seed replays the game');
+    }
+    let bounds = 0;
+    for (const s of code.filter((c) => !LOGIC_FILE.test(c.path))) {
+        s.code.split('\n').forEach((text, i) => {
+            const judged = [...text.matchAll(PIXI_BOUNDS)].length >= 2 || (BOUNDS.test(text) && HIT_WORDS.test(text));
+            if (bounds >= MAX_BOUNDS_FINDINGS || !judged)
+                return;
+            bounds++;
+            warn(s.path, i + 1, 'a hit decided from the renderer\'s bounds — keep positions and sizes in the game state (src/rules.ts or src/sim/) and test the rule there');
+        });
+    }
+    return out;
+}

package/dist/smoke/orphans.js

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, posix } from 'node:path';
+import { referenced } from "./art.js";
+import { ASSET, lineOf } from "./sources.js";
+export const REQUESTS = join('.funtools', 'verify', 'requests.json');
+export const ASSET_FILES_LIST = 'src/art/files.json';
+function pieces(body) {
+    const out = [];
+    let lit = '', holes = 0;
+    for (let i = 0; i < body.length; i++) {
+        if (body[i] === '\\') {
+            lit += body[i + 1] ?? '';
+            i++;
+            continue;
+        }
+        if (body[i] === '$' && body[i + 1] === '{') {
+            let depth = 1, j = i + 2;
+            for (; j < body.length && depth; j++)
+                depth += body[j] === '{' ? 1 : body[j] === '}' ? -1 : 0;
+            out.push(lit);
+            lit = '';
+            holes++;
+            i = j - 1;
+            continue;
+        }
+        lit += body[i];
+    }
+    out.push(lit);
+    return holes ? out : null;
+}
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+export function templates(game) {
+    const out = [];
+    for (const s of game.sources) {
+        for (const m of s.code.matchAll(/`((?:[^`\\]|\\.)*)`/g)) {
+            const parts = pieces(m[1]);
+            if (!parts || !parts.join('').replace(/[/.]/g, '') || /\s/.test(parts.join('')))
+                continue;
+            out.push({ re: new RegExp(`(^|/)${parts.map(escape).join('[^/]*?')}$`), template: m[0], path: s.path, line: lineOf(s.code, m.index) });
+        }
+    }
+    return out;
+}
+export function requested(dir) {
+    const p = join(dir, REQUESTS);
+    if (!existsSync(p))
+        return new Set();
+    try {
+        const r = JSON.parse(readFileSync(p, 'utf8'));
+        return new Set((Array.isArray(r.paths) ? r.paths : []).filter((x) => typeof x === 'string'));
+    }
+    catch {
+        return new Set();
+    }
+}
+export function assetUses(game) {
+    const corpus = game.texts.filter((t) => t.path !== ASSET_FILES_LIST).map((t) => t.text).join('\n');
+    const tpl = templates(game);
+    const seen = requested(game.dir);
+    const out = [];
+    for (const f of game.files) {
+        if (!ASSET.test(f) || /(^|\/)(favicon|apple-touch-icon)/.test(f) || /^public\/(draco|basis)\//.test(f))
+            continue;
+        if (referenced(f, corpus)) {
+            out.push({ path: f, use: 'referenced' });
+            continue;
+        }
+        const served = f.replace(/^public\//, '');
+        const base = posix.basename(f), stem = base.replace(/\.[^.]+$/, '');
+        const hit = tpl.find((t) => t.re.test(served) || t.re.test(base) || t.re.test(stem));
+        if (hit) {
+            out.push({ path: f, use: 'pattern', by: { template: hit.template, path: hit.path, line: hit.line } });
+            continue;
+        }
+        out.push({ path: f, use: seen.has(served) ? 'request' : 'unreferenced' });
+    }
+    return out;
+}

package/dist/smoke/palette.js

@@ -0,0 +1,16 @@
+export const SCAFFOLD_PALETTE = { bg: '#101018', primary: '#4fd1c5', accent: '#f6ad55' };
+const HEXES = Object.values(SCAFFOLD_PALETTE).map((h) => h.slice(1));
+const count = (text) => HEXES.filter((h) => new RegExp(`(#|0x)${h}\\b`, 'i').test(text)).length;
+export function palette(game) {
+    const manifest = game.texts.find((t) => t.path === 'funpixel.json');
+    const files = [
+        ...(manifest && count(manifest.text) > 0 ? [manifest.path] : []),
+        ...game.sources.filter((s) => count(s.code) >= 2).map((s) => s.path),
+    ];
+    if (!files.length)
+        return [];
+    return [{
+            level: 'warn', check: 'palette', path: files[0],
+            what: `the scaffold's placeholder palette (${Object.values(SCAFFOLD_PALETTE).join(' / ')}) still ships in ${files.join(', ')}: take the palette from the design note's AD rules and the target frame (skill funpixel-art)`,
+        }];
+}

package/dist/smoke/sources.js

@@ -0,0 +1,36 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { stageFiles } from "../stage/stage.js";
+import { isText } from "../pack/leaks.js";
+export const ASSET = /\.(png|jpe?g|webp|gif|avif|svg|mp3|m4a|ogg|wav|aac|flac|glb|gltf|bin|ktx2|basis|hdr|exr|woff2?|ttf|otf|mp4|webm|fnt|atlas)$/i;
+const CODE = /\.(m?[jt]sx?|cjs|html|css)$/i;
+const blank = (s) => s.replace(/[^\n]/g, ' ');
+export function stripComments(path, text) {
+    if (/\.html$/i.test(path))
+        return text.replace(/<!--[\s\S]*?-->/g, blank);
+    let out = text.replace(/\/\*[\s\S]*?\*\//g, blank);
+    if (!/\.css$/i.test(path))
+        out = out.replace(/(^|[^:'"`\\])(\/\/[^\n]*)/gm, (_m, pre, c) => pre + blank(c));
+    return out;
+}
+export async function loadGame(dir) {
+    const staged = stageFiles(dir);
+    const texts = [];
+    for (const path of staged.included) {
+        if (ASSET.test(path) && !/\.(svg|atlas|fnt)$/i.test(path))
+            continue;
+        const bytes = await readFile(join(dir, path));
+        if (isText(bytes) && bytes.length <= 4 * 1024 * 1024)
+            texts.push({ path, text: bytes.toString('utf8') });
+    }
+    const sources = texts
+        .filter((t) => CODE.test(t.path) && !t.path.startsWith('public/') && !/\.min\.js$/.test(t.path))
+        .map((t) => ({ ...t, code: stripComments(t.path, t.text) }));
+    let pkg = null;
+    try {
+        pkg = JSON.parse(texts.find((t) => t.path === 'package.json')?.text ?? 'null');
+    }
+    catch { }
+    return { dir, staged, files: new Set(staged.included), sources, texts, pkg };
+}
+export const lineOf = (text, index) => text.slice(0, index).split('\n').length;

package/dist/sound/beats.js

@@ -0,0 +1,95 @@
+import { readFileSync } from 'node:fs';
+import { beatGrid, decode, RATE } from "../trailer/beats.js";
+export function readWav(buf) {
+    if (buf.length < 44 || buf.toString('ascii', 0, 4) !== 'RIFF' || buf.toString('ascii', 8, 12) !== 'WAVE')
+        return null;
+    let p = 12, fmt = null;
+    while (p + 8 <= buf.length) {
+        const id = buf.toString('ascii', p, p + 4), size = buf.readUInt32LE(p + 4), body = p + 8;
+        if (id === 'fmt ')
+            fmt = { format: buf.readUInt16LE(body), channels: buf.readUInt16LE(body + 2), rate: buf.readUInt32LE(body + 4), bits: buf.readUInt16LE(body + 14) };
+        if (id === 'data' && fmt) {
+            const { format, channels, bits, rate } = fmt;
+            const step = (bits / 8) * channels, n = Math.floor(Math.min(size, buf.length - body) / step);
+            const out = new Float32Array(n);
+            for (let i = 0; i < n; i++) {
+                let s = 0;
+                for (let c = 0; c < channels; c++) {
+                    const at = body + i * step + c * (bits / 8);
+                    s += format === 3 && bits === 32 ? buf.readFloatLE(at) : bits === 16 ? buf.readInt16LE(at) / 32768 : bits === 8 ? (buf.readUInt8(at) - 128) / 128 : 0;
+                }
+                out[i] = s / channels;
+            }
+            return { samples: out, rate };
+        }
+        p = body + size + (size & 1);
+    }
+    return null;
+}
+export function writeWav(samples, rate) {
+    const b = Buffer.alloc(44 + samples.length * 2);
+    b.write('RIFF', 0, 'ascii');
+    b.writeUInt32LE(36 + samples.length * 2, 4);
+    b.write('WAVE', 8, 'ascii');
+    b.write('fmt ', 12, 'ascii');
+    b.writeUInt32LE(16, 16);
+    b.writeUInt16LE(1, 20);
+    b.writeUInt16LE(1, 22);
+    b.writeUInt32LE(rate, 24);
+    b.writeUInt32LE(rate * 2, 28);
+    b.writeUInt16LE(2, 32);
+    b.writeUInt16LE(16, 34);
+    b.write('data', 36, 'ascii');
+    b.writeUInt32LE(samples.length * 2, 40);
+    for (let i = 0; i < samples.length; i++)
+        b.writeInt16LE(Math.max(-32768, Math.min(32767, Math.round(samples[i] * 32767))), 44 + i * 2);
+    return b;
+}
+function energyAt(samples, rate, t) {
+    const a = Math.max(0, Math.floor(t * rate)), b = Math.min(samples.length, a + Math.floor(0.06 * rate));
+    let e = 0;
+    for (let i = a; i < b; i++)
+        e += samples[i] * samples[i];
+    return e;
+}
+export function beatMap(samples, rate, file, meter = 4) {
+    const g = beatGrid(samples, rate);
+    const seconds = samples.length / rate;
+    const beats = [];
+    for (let t = g.offset; t < seconds; t += g.period)
+        beats.push(Math.round(t * 1000) / 1000);
+    let downbeat = 0, best = -1;
+    for (let k = 0; k < Math.min(meter, beats.length); k++) {
+        let e = 0;
+        for (let i = k; i < beats.length; i += meter)
+            e += energyAt(samples, rate, beats[i]);
+        if (e > best) {
+            best = e;
+            downbeat = k;
+        }
+    }
+    let on = 0, all = 0;
+    const win = 0.04;
+    for (let i = 0; i < samples.length; i += 32) {
+        const t = i / rate, e = samples[i] * samples[i];
+        all += e;
+        const d = ((t - g.offset) % g.period + g.period) % g.period;
+        if (Math.min(d, g.period - d) <= win)
+            on += e;
+    }
+    const expected = (2 * win) / g.period;
+    const share = all > 0 ? on / all : 0;
+    const confidence = g.detected ? Math.max(0, Math.min(1, (share - expected) / Math.max(1e-9, 1 - expected))) : 0;
+    return { version: 1, file, bpm: g.bpm, period: Math.round(g.period * 1e5) / 1e5, offset: Math.round(g.offset * 1e4) / 1e4, detected: g.detected, meter, downbeat, seconds: Math.round(seconds * 1000) / 1000, beats, confidence: Math.round(confidence * 100) / 100 };
+}
+export function readTrack(file, bin) {
+    if (/\.wav$/i.test(file)) {
+        const w = readWav(readFileSync(file));
+        if (w)
+            return w;
+    }
+    if (!bin)
+        return null;
+    const s = decode(bin, file);
+    return s ? { samples: s, rate: RATE } : null;
+}

package/dist/sound/loudness.js

@@ -0,0 +1,94 @@
+import { execFileSync, spawnSync } from 'node:child_process';
+export const TARGETS = { 'one-shot': -16, bed: -22, music: -18, voice: -18 };
+export const TOLERANCE = 3;
+export const PEAK_CEILING = -1;
+export const SILENT = -45;
+export function classOf(file, seconds) {
+    const f = file.toLowerCase();
+    if (/(^|[/_-])(vo|voice|line|bark|dialog(ue)?)([/_.-]|\d)/.test(f))
+        return 'voice';
+    if (/(^|[/_-])(bed|amb(ience|ient)?|room|wind|rain|crowd|loop)([/_.-]|\d)/.test(f))
+        return 'bed';
+    if (/(^|[/_-])(music|bgm|theme|score|song)([/_.-]|\d)|\/music\//.test(f))
+        return 'music';
+    return seconds !== null && seconds > 12 ? 'music' : 'one-shot';
+}
+export const hasFfmpeg = () => { try {
+    execFileSync('ffmpeg', ['-version'], { stdio: 'ignore', timeout: 10_000 });
+    return true;
+}
+catch {
+    return false;
+} };
+const num = (re, s) => { const m = re.exec(s); return m ? Number(m[1]) : null; };
+export function measure(file) {
+    const r128 = stderrOf(file, ['-filter_complex', 'ebur128=peak=true']);
+    const vol = stderrOf(file, ['-af', 'volumedetect']);
+    const d = /Duration:\s*(\d+):(\d+):(\d+(?:\.\d+)?)/.exec(r128);
+    const seconds = d ? Number(d[1]) * 3600 + Number(d[2]) * 60 + Number(d[3]) : null;
+    const summary = r128.slice(Math.max(0, r128.lastIndexOf('Summary:')));
+    const lufs = num(/I:\s*(-?\d+(?:\.\d+)?)\s*LUFS/, summary);
+    const peak = num(/Peak:\s*(-?\d+(?:\.\d+)?)\s*dBFS/, summary.slice(Math.max(0, summary.indexOf('True peak'))));
+    const max = num(/max_volume:\s*(-?\d+(?:\.\d+)?)\s*dB/, vol);
+    return { file, cls: classOf(file, seconds), seconds, lufs, peak, max };
+}
+const stderrOf = (file, args) => spawnSync('ffmpeg', ['-hide_banner', '-nostats', '-i', file, '-vn', ...args, '-f', 'null', '-'], { encoding: 'utf8', timeout: 120_000 }).stderr ?? '';
+export function judge(m) {
+    const out = [];
+    const target = TARGETS[m.cls];
+    const gated = m.lufs === null || m.lufs <= -69;
+    if ((m.max !== null && m.max < SILENT) || (gated && m.max === null)) {
+        out.push({ state: 'warn', what: `silent: a dud take (sample peak ${m.max ?? '–'} dB): retake it` });
+        return out;
+    }
+    if (gated)
+        out.push({ state: 'not_observed', what: `too short for integrated loudness (${m.seconds?.toFixed(2) ?? '?'} s); sample peak ${m.max} dB` });
+    else if (Math.abs(m.lufs - target) > TOLERANCE)
+        out.push({ state: 'warn', what: `${m.lufs} LUFS, target ${target} ±${TOLERANCE} for a ${m.cls}: ${m.lufs < target ? 'too quiet beside the rest' : 'too loud beside the rest'}` });
+    if (m.peak !== null && m.peak > PEAK_CEILING)
+        out.push({ state: 'warn', what: `true peak ${m.peak} dBTP, over the ${PEAK_CEILING} ceiling: it clips on phone speakers` });
+    if (!out.length)
+        out.push({ state: 'pass', what: `${m.lufs} LUFS (${m.cls}, target ${target}), peak ${m.peak} dBTP` });
+    return out;
+}
+export const WRAP_RATE = 44_100;
+export const WRAP_MIN_S = 1;
+export const WRAP_MAX_S = 600;
+export const WRAP_GAP_MS = 20;
+export const WRAP_CLICK_RATIO = 4;
+export const WRAP_CLICK_MIN = 0.02;
+const WRAP_SILENCE = 10 ** (-50 / 20);
+export const loopsAsPlayed = (cls) => cls === 'bed' || cls === 'music';
+export function wrapSeam(x, rate = WRAP_RATE) {
+    const n = x.length;
+    if (n < rate * WRAP_MIN_S)
+        return null;
+    let lead = 0;
+    while (lead < n && Math.abs(x[lead]) < WRAP_SILENCE)
+        lead++;
+    if (lead >= n)
+        return null;
+    let tail = 0;
+    while (tail < n && Math.abs(x[n - 1 - tail]) < WRAP_SILENCE)
+        tail++;
+    const gap_ms = Math.round(((lead + tail) / rate) * 10_000) / 10;
+    const w = Math.max(8, Math.round(rate * 0.01));
+    const steps = [];
+    for (let i = n - w; i < n - 1; i++)
+        steps.push(Math.abs(x[i + 1] - x[i]));
+    for (let i = 0; i < w - 1; i++)
+        steps.push(Math.abs(x[i + 1] - x[i]));
+    steps.sort((a, b) => a - b);
+    const step = steps[Math.min(steps.length - 1, Math.floor(steps.length * 0.95))] ?? 0;
+    const jump = Math.abs(x[n - 1] - x[0]);
+    const ratio = Math.round((jump / Math.max(step, 1e-4)) * 10) / 10;
+    const seam = gap_ms > WRAP_GAP_MS ? 'gap' : ratio > WRAP_CLICK_RATIO && jump > WRAP_CLICK_MIN ? 'click' : 'meets';
+    return { seam, gap_ms, jump: Math.round(jump * 1000) / 1000, step: Math.round(step * 1000) / 1000, ratio };
+}
+export function decodeMono(file) {
+    const r = spawnSync('ffmpeg', ['-hide_banner', '-v', 'error', '-i', file, '-ac', '1', '-ar', String(WRAP_RATE), '-f', 'f32le', 'pipe:1'], { timeout: 60_000, maxBuffer: WRAP_MAX_S * WRAP_RATE * 4 + 1_000_000 });
+    if (r.status !== 0 || !r.stdout?.length)
+        return null;
+    const b = r.stdout;
+    return new Float32Array(b.buffer.slice(b.byteOffset, b.byteOffset + (b.length - (b.length % 4))));
+}