@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/export/export.js

@@ -0,0 +1,165 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { stageFiles } from "../stage/stage.js";
+import { scanFile } from "../pack/leaks.js";
+import { buildStaged } from "../pack/build.js";
+import { evidenceFiles, GITIGNORE, HARNESSIGNORE, select, trimManifest, trimScripts } from "./select.js";
+import { loadTypescript, MEANINGFUL, SCRIPT, STYLE, stripCss, stripScript } from "./strip.js";
+import { lockHosts, mobileFindings, mobileStatic, relativeBase, scanAbsoluteUrls, scanNames } from "./scan.js";
+import { runtimeChecks } from "./runtime.js";
+import { stripPngMetadata } from "./metadata.js";
+const strippable = (p) => (p.startsWith('src/') || /^vite\.config\./.test(p)) && (SCRIPT.test(p) || STYLE.test(p)) && !/\.d\.ts$/.test(p);
+function compare(a, b) {
+    const keys = [...new Set([...Object.keys(a), ...Object.keys(b)])].sort();
+    return keys.filter((k) => a[k] !== b[k]).map((k) => (!(k in a) ? `${k} (only after)` : !(k in b) ? `${k} (only before)` : k));
+}
+async function sync(out, dest, files) {
+    if (existsSync(dest)) {
+        const names = readdirSync(dest);
+        if (names.length && !names.includes('funpixel.json'))
+            throw new Error(`${dest} is not empty and is not a game folder (no funpixel.json) — refusing to replace it`);
+        for (const n of names)
+            if (n !== 'node_modules' && n !== '.git')
+                await rm(join(dest, n), { recursive: true, force: true });
+    }
+    for (const f of files) {
+        await mkdir(dirname(join(dest, f)), { recursive: true });
+        await cp(join(out, f), join(dest, f));
+    }
+}
+export async function exportGame(opts) {
+    const dir = resolve(opts.dir);
+    const dest = opts.dest ? resolve(opts.dest) : null;
+    const say = opts.progress ?? (() => { });
+    if (!existsSync(join(dir, 'package.json')) || !existsSync(join(dir, 'index.html')))
+        throw new Error(`${dir} is not a game folder (no package.json and index.html)`);
+    if (dest && (dest === dir || dest.startsWith(dir + '/')))
+        throw new Error('the destination is inside the game folder');
+    const sel = select(dir);
+    const findings = [];
+    const out = await mkdtemp(join(tmpdir(), 'funtools-export-'));
+    try {
+        for (const f of sel.files) {
+            await mkdir(dirname(join(out, f)), { recursive: true });
+            await cp(join(dir, f), join(out, f));
+        }
+        const ev = evidenceFiles(dir);
+        for (const f of ev.files) {
+            await mkdir(dirname(join(out, f)), { recursive: true });
+            await cp(join(dir, f), join(out, f));
+        }
+        await writeFile(join(out, '.gitignore'), GITIGNORE);
+        await writeFile(join(out, '.harnessignore'), HARNESSIGNORE);
+        let manifestRemoved = [];
+        if (sel.files.includes('funpixel.json')) {
+            const t = trimManifest(await readFile(join(out, 'funpixel.json'), 'utf8'));
+            manifestRemoved = t.removed;
+            await writeFile(join(out, 'funpixel.json'), t.text);
+        }
+        const droppedTop = [...new Set(sel.dropped.map((d) => d.path.split('/')[0]))];
+        const scripts = trimScripts(await readFile(join(out, 'package.json'), 'utf8'), droppedTop);
+        await writeFile(join(out, 'package.json'), scripts.text);
+        for (const s of scripts.broken)
+            findings.push({ path: 'package.json', level: 'problem', what: `the "${s}" script runs something the export leaves behind` });
+        const ts = loadTypescript(dir);
+        const stripped = [];
+        for (const f of sel.files.filter(strippable)) {
+            const text = await readFile(join(out, f), 'utf8');
+            if (MEANINGFUL.test(text))
+                findings.push({ path: f, level: 'warn', what: 'a comment the bundler reads (pure/licence/vite-ignore) — removed; the bundle comparison shows whether it mattered' });
+            let next;
+            if (STYLE.test(f))
+                next = stripCss(text);
+            else if (!ts) {
+                findings.push({ path: f, level: 'problem', what: 'comments not removed: no typescript to parse it (npm install in the game first)' });
+                continue;
+            }
+            else {
+                try {
+                    next = stripScript(ts, f, text);
+                }
+                catch (e) {
+                    findings.push({ path: f, level: 'problem', what: `comments not removed: ${e.message}` });
+                    continue;
+                }
+            }
+            if (next !== text) {
+                await writeFile(join(out, f), next);
+                stripped.push({ path: f, before: Buffer.byteLength(text), after: Buffer.byteLength(next) });
+            }
+        }
+        const metadataStripped = [];
+        if (opts.stripMetadata) {
+            for (const f of sel.files.filter((p) => p.startsWith('public/') && /\.png$/i.test(p))) {
+                const r = stripPngMetadata(await readFile(join(out, f)));
+                if (r?.removed.length) {
+                    await writeFile(join(out, f), r.bytes);
+                    metadataStripped.push({ path: f, chunks: r.removed });
+                }
+            }
+        }
+        const exported = [...sel.files, '.gitignore', '.harnessignore'].sort();
+        const publicDirs = [...new Set(sel.files.filter((f) => f.startsWith('public/') && f.split('/').length > 2).map((f) => f.split('/')[1]))];
+        const viteConfig = sel.files.find((f) => /^vite\.config\./.test(f));
+        const relative = viteConfig ? relativeBase(await readFile(join(out, viteConfig), 'utf8')) : false;
+        const texts = [];
+        for (const f of exported) {
+            const bytes = await readFile(join(out, f));
+            for (const l of scanFile(f, bytes))
+                findings.push({ path: l.path, level: l.level === 'leak' ? 'problem' : 'warn', what: l.what, sample: l.sample });
+            if (!/^\.(git|harness)ignore$/.test(f))
+                findings.push(...scanNames(f, bytes));
+            if (/\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|css|html)$/.test(f)) {
+                const text = bytes.toString('utf8');
+                texts.push({ path: f, text });
+                findings.push(...scanAbsoluteUrls(f, text, publicDirs, relative));
+            }
+            if (/(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock)$/.test(f)) {
+                for (const h of lockHosts(bytes.toString('utf8')))
+                    findings.push({ path: f, level: 'problem', what: 'a package resolved from somewhere other than the public registry — it installs only here', sample: h });
+            }
+        }
+        for (const f of ev.files)
+            for (const l of scanFile(f, await readFile(join(out, f))))
+                findings.push({ path: l.path, level: l.level === 'leak' ? 'problem' : 'warn', what: l.what, sample: l.sample });
+        const html = texts.find((t) => t.path === 'index.html')?.text ?? '';
+        findings.push(...mobileFindings(mobileStatic(html, texts)));
+        const shipped = new Set(stageFiles(out).included);
+        for (const f of sel.files)
+            if (!shipped.has(f))
+                findings.push({ path: f, level: 'problem', what: 'the written .harnessignore excludes a build input' });
+        say('building the dev folder as it is');
+        const before = await buildStaged(dir, stageFiles(dir, { own: false }).included, { hashes: true });
+        say('building the clean folder from what an upload carries');
+        const after = await buildStaged(out, [...shipped], { hashes: true, keepDistIn: out });
+        const onPurpose = new Set(metadataStripped.map((m) => m.path.slice('public/'.length)));
+        const differ = before.dist && after.dist ? compare(before.dist, after.dist).filter((k) => !onPurpose.has(k)) : [];
+        const build = { before, after, same: before.ok && after.ok && differ.length === 0, differ };
+        let runtime = null;
+        if (opts.browser && after.ok) {
+            say('running the built game: verify at both sizes, audit-screens portrait and landscape, every request');
+            runtime = await runtimeChecks(out);
+        }
+        const problems = [
+            ...findings.filter((f) => f.level === 'problem').map((f) => `${f.path}: ${f.what}${f.sample ? ` (${f.sample})` : ''}`),
+            ...(!before.ok ? [`the dev folder does not build: ${before.detail.split('\n')[0]}`] : []),
+            ...(!after.ok ? [`the clean folder does not build: ${after.detail.split('\n')[0]}`] : []),
+            ...(before.ok && after.ok && differ.length ? [`the bundle changed: ${differ.slice(0, 5).join(', ')}${differ.length > 5 ? ` and ${differ.length - 5} more` : ''}`] : []),
+            ...(runtime?.missing ?? []).map((m) => `the game requested ${m.url} (${m.status}, ${m.viewport}, ${m.view}) — not in the build`),
+        ];
+        let wrote = false;
+        if (dest && !opts.check && !problems.length) {
+            await sync(out, dest, [...exported, ...ev.files]);
+            wrote = true;
+        }
+        return {
+            dir, dest, wrote, files: exported, evidence: ev.files, evidenceLeft: ev.left, dropped: sel.dropped, ignoreFixes: sel.ignoreFixes, manifestRemoved,
+            scriptsRemoved: scripts.removed, stripped, metadataStripped, findings, build, runtime, problems,
+        };
+    }
+    finally {
+        await rm(out, { recursive: true, force: true });
+    }
+}

package/dist/export/metadata.js

@@ -0,0 +1,25 @@
+const DROP = new Set(['tEXt', 'iTXt', 'zTXt', 'eXIf', 'caBX']);
+const SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+export function stripPngMetadata(bytes) {
+    if (bytes.length < 8 || !bytes.subarray(0, 8).equals(SIGNATURE))
+        return null;
+    const keep = [SIGNATURE];
+    const removed = [];
+    for (let i = 8; i < bytes.length;) {
+        if (i + 12 > bytes.length)
+            return null;
+        const len = bytes.readUInt32BE(i);
+        const end = i + 12 + len;
+        if (end > bytes.length)
+            return null;
+        const type = bytes.toString('latin1', i + 4, i + 8);
+        if (DROP.has(type))
+            removed.push(type);
+        else
+            keep.push(bytes.subarray(i, end));
+        i = end;
+        if (type === 'IEND')
+            break;
+    }
+    return { bytes: removed.length ? Buffer.concat(keep) : bytes, removed };
+}

package/dist/export/runtime.js

@@ -0,0 +1,119 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { auditScreens } from "../commands/look.js";
+import { drive, evalJson, load, openTarget } from "../look/look.js";
+import { launch, lookPage, viewportUrl } from "../verify/browser.js";
+import { browserPool, runUrl } from "../verify/run.js";
+import { gateVerdicts } from "../verify/judge.js";
+import { normaliseCheck } from "../verify/probe.js";
+import { hookMapOf } from "../verify/hooks.js";
+import { plannedFonts } from "../verify/health.js";
+async function manifestOf(dir) {
+    try {
+        return JSON.parse(await readFile(join(dir, 'funpixel.json'), 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+async function verifyBoth(dir, url, manifest) {
+    const pool = browserPool();
+    try {
+        const { runs } = await runUrl(pool, url, {
+            checks: (Array.isArray(manifest.checks) ? manifest.checks : []).map(normaliseCheck),
+            sweepMs: 3000,
+            viewports: ['desktop', 'phone'],
+            orientation: typeof manifest.metadata?.orientation === 'string' ? manifest.metadata.orientation : '',
+            hooks: hookMapOf(manifest),
+            fonts: plannedFonts(manifest),
+            frontDoor: null,
+        });
+        return runs.map((r) => ({
+            viewport: r.viewport,
+            verdict: r.verdict,
+            failed: gateVerdicts(r.report).filter((g) => !g.pass).map((g) => ({ what: g.what, reason: g.reason })),
+            unreachableKeys: r.report.render_health?.key_parity_observed ? r.report.render_health.unreachable_keys : [],
+            touchControls: r.report.render_health?.touch_controls_found ?? 0,
+        }));
+    }
+    finally {
+        await pool.close();
+    }
+}
+async function audit(dir, orientation) {
+    const lines = [];
+    const io = { log: (m) => lines.push(m), error: (m) => lines.push(m) };
+    await auditScreens({ target: dir, viewport: 'phone', orientation, views: [], json: true, click: null }, io);
+    try {
+        const r = JSON.parse(lines.join('\n'));
+        return {
+            orientation, verdict: r.verdict,
+            views: (r.views ?? []).map((v) => ({
+                view: v.view, verdict: v.verdict, failed: v.failed ?? [],
+                items: (v.failed ?? []).flatMap((k) => (v.layout?.[k]?.items ?? []).slice(0, 3).map((i) => `${k}: ${i.name ?? `${i.a} × ${i.b}`}`)),
+            })),
+        };
+    }
+    catch {
+        return { orientation, verdict: 'not_observed', views: [{ view: '(page)', verdict: 'not_observed', failed: [], items: [lines.join(' ').slice(0, 200)] }] };
+    }
+}
+async function requests(dir, manifest) {
+    const t = await openTarget(dir);
+    if (typeof t === 'string')
+        return [{ url: '(dist)', status: t, viewport: '-', view: '-' }];
+    const origin = new URL(t.url).origin;
+    const hooks = hookMapOf(manifest);
+    const missing = [];
+    const { browser } = await launch();
+    try {
+        for (const viewport of ['desktop', 'phone']) {
+            const page = await lookPage(browser, viewport, typeof manifest.metadata?.orientation === 'string' ? manifest.metadata.orientation : '');
+            let view = '(as loaded)';
+            page.on('response', (res) => {
+                if (res.url().startsWith(origin) && res.status() >= 400)
+                    missing.push({ url: res.url().slice(origin.length), status: res.status(), viewport, view });
+            });
+            page.on('requestfailed', (req) => {
+                if (req.url().startsWith(origin) && !/ERR_ABORTED/.test(req.failure()?.errorText ?? ''))
+                    missing.push({ url: req.url().slice(origin.length), status: req.failure()?.errorText ?? 'failed', viewport, view });
+            });
+            const url = viewportUrl(t.url, viewport);
+            await load(page, url, hooks);
+            const declared = ((await evalJson(page, 'capture_view', { view: null, verbs: [], verb_gap_ms: 0, hold_ms: 0, freeze: false }))?.views ?? []).map((v) => v.name);
+            for (const name of declared) {
+                view = name;
+                await load(page, url, hooks);
+                await drive(page, { view: name, verbs: [], holdMs: 900, freeze: false, click: null });
+            }
+            await page.context().close();
+        }
+    }
+    finally {
+        await browser.close().catch(() => { });
+        await t.close();
+    }
+    const seen = new Set();
+    return missing.filter((m) => {
+        const k = `${m.url} ${m.viewport}`;
+        if (seen.has(k) || /\/favicon\.ico$/.test(m.url))
+            return false;
+        seen.add(k);
+        return true;
+    });
+}
+export async function runtimeChecks(dir) {
+    const manifest = await manifestOf(dir);
+    const t = await openTarget(dir);
+    if (typeof t === 'string')
+        throw new Error(t);
+    let verify;
+    try {
+        verify = await verifyBoth(dir, t.url, manifest);
+    }
+    finally {
+        await t.close();
+    }
+    const audits = [await audit(dir, 'portrait'), await audit(dir, 'landscape')];
+    return { verify, audit: audits, missing: await requests(dir, manifest) };
+}

package/dist/export/scan.js

@@ -0,0 +1,78 @@
+import { isText } from "../pack/leaks.js";
+const MAKERS_TEXT = /\b(openrouter|anthropic|claude|openai|chatgpt|gpt-image|gpt-[45]|gemini|elevenlabs|lyria|fal\.ai|hunyuan|meshy|tripo|midjourney|stable[- ]diffusion|dall-?e|flux\.[12]|suno|funtools|gdk|codex|kiro)\b/i;
+const MAKERS_BINARY = /(openrouter|anthropic|openai|chatgpt|gpt-image|c2pa|elevenlabs|hunyuan|midjourney|stable diffusion|funtools)/i;
+const TEXTLIKE = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|css|html|json|svg|txt|csv|xml)$/i;
+function makerIn(path, text) {
+    const body = path === 'package.json' || /(^|\/)package-lock\.json$/.test(path) ? '' : text;
+    return body.match(MAKERS_TEXT)?.[0] ?? null;
+}
+export function scanNames(path, bytes) {
+    if (TEXTLIKE.test(path) && isText(bytes)) {
+        const hit = makerIn(path, bytes.toString('utf8'));
+        return hit ? [{ path, level: 'problem', what: 'names a tool or provider that made the game', sample: hit }] : [];
+    }
+    const hit = bytes.toString('latin1').match(MAKERS_BINARY)?.[0];
+    return hit ? [{ path, level: 'problem', what: 'names a tool or provider inside the file (metadata)', sample: hit }] : [];
+}
+const SCRIPT_OR_HTML = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|html)$/;
+export function scanAbsoluteUrls(path, text, publicDirs, relativeBase) {
+    if (!publicDirs.length)
+        return [];
+    const names = publicDirs.map((d) => d.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+    const out = [];
+    if (SCRIPT_OR_HTML.test(path)) {
+        const re = new RegExp(`(["'\`]|url\\(\\s*["']?)/(${names})(/[^"'\`)\\s]*)?`, 'g');
+        for (const m of text.matchAll(re)) {
+            out.push({ path, level: 'problem', what: 'an absolute URL to a public file — it breaks when the game is served from a folder', sample: m[0].replace(/^url\(\s*/, '') });
+        }
+    }
+    else if (/\.css$/.test(path)) {
+        const re = new RegExp(`url\\(\\s*["']?/(${names})(/[^"')\\s]*)?`, 'g');
+        for (const m of text.matchAll(re)) {
+            out.push({
+                path, level: relativeBase ? 'warn' : 'problem', sample: m[0].replace(/^url\(\s*["']?/, ''),
+                what: relativeBase ? 'an absolute url() to a public file (Vite makes it relative, base is ./)' : 'an absolute url() to a public file, and vite.config has no base: \'./\' — the build keeps it absolute',
+            });
+        }
+    }
+    return out;
+}
+export const relativeBase = (viteConfig) => /\bbase\s*:\s*['"`]\.\/?['"`]/.test(viteConfig);
+export function mobileStatic(html, sources) {
+    const meta = html.match(/<meta[^>]+name=["']viewport["'][^>]*>/i)?.[0] ?? null;
+    const content = meta?.match(/content=["']([^"']*)["']/i)?.[1] ?? null;
+    const safeArea = sources.some(({ text }) => /env\(\s*safe-area-inset-|\bsafeArea\b/.test(text));
+    const hoverOnly = [];
+    for (const { path, text } of sources) {
+        if (!/\.css$/.test(path))
+            continue;
+        for (const m of text.matchAll(/([^{}]*:hover[^{}]*)\{([^}]*)\}/g)) {
+            const selector = m[1].trim();
+            const reveals = /\b(display|visibility|opacity)\s*:/.test(m[2]);
+            const descendant = /:hover\s*[^,\s{][^,{]*$|:hover\s*[>+~]/.test(selector);
+            if (reveals && descendant && !/(:active|:focus)/.test(selector))
+                hoverOnly.push(`${path}: ${selector}`);
+        }
+    }
+    return { viewportMeta: content, viewportFitCover: !!content && /viewport-fit\s*=\s*cover/.test(content), safeArea, hoverOnly };
+}
+export function mobileFindings(m) {
+    const out = [];
+    if (!m.viewportMeta)
+        out.push({ path: 'index.html', level: 'warn', what: 'no viewport meta — a phone renders it zoomed out' });
+    else if (!/width\s*=\s*device-width/.test(m.viewportMeta))
+        out.push({ path: 'index.html', level: 'warn', what: 'the viewport meta has no width=device-width', sample: m.viewportMeta });
+    if (m.viewportMeta && !m.viewportFitCover)
+        out.push({ path: 'index.html', level: 'warn', what: 'no viewport-fit=cover — the game letterboxes around a notch', sample: m.viewportMeta });
+    if (!m.safeArea)
+        out.push({ path: 'src', level: 'warn', what: 'no safe-area inset anywhere (env(safe-area-inset-*) or the SDK\'s safeArea) — HUD can sit under a notch' });
+    for (const h of m.hoverOnly)
+        out.push({ path: h.split(': ')[0], level: 'warn', what: 'shows or hides something on :hover only — a phone never hovers', sample: h.split(': ').slice(1).join(': ') });
+    return out;
+}
+export function lockHosts(text) {
+    const hosts = new Set();
+    for (const m of text.matchAll(/"resolved":\s*"([a-z+]+:\/\/[^/"]+|file:[^"]*|[a-z]+:[^"]*)/g))
+        hosts.add(m[1]);
+    return [...hosts].filter((h) => !/^https:\/\/registry\.(npmjs\.org|yarnpkg\.com)$/.test(h));
+}

package/dist/export/select.js

@@ -0,0 +1,193 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { PRIVATE, SPLASH_FUNPIXEL, stageFiles } from "../stage/stage.js";
+import { makeDecider, parseHarnessIgnore } from "../stage/harnessignore.js";
+const TOP_FILES = /^(index\.html|package\.json|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|tsconfig(\.[\w-]+)?\.json|vite\.config\.(ts|js|mjs|mts|cjs)|funpixel\.json)$/;
+const TOP_DIRS = new Set(['src', 'public']);
+const INNER_DROP = [
+    [/\.md$/i, 'notes'],
+    [/(^|\/)(__tests__|tests?)\//, 'tests'],
+    [/\.(test|spec)\.[cm]?[jt]sx?$/, 'tests'],
+    [/\.map$/i, 'a source map'],
+    [/\.funtools-new$/, 'a kit offer funtools upgrade left'],
+];
+export const MANIFEST_KEEP = ['name', 'splash', 'metadata', 'checks', 'hooks'];
+export const HARNESSIGNORE = '/.gitignore\n/.harnessignore\n';
+export const GITIGNORE = 'node_modules\ndist\nverify.json\n*.funtools-new\n# .funtools/: the evidence the game earned (reports, scores, small frames) stays in git; clips do not\n.funtools/**/*.mp4\n.funtools/**/*.webm\n.funtools/**/*.burst/\n';
+export const EVIDENCE = { textMax: 1_000_000, imageMax: 300_000, totalMax: 25_000_000 };
+const EVIDENCE_TEXT = /\.(json|jsonl|md|txt|csv)$/i, EVIDENCE_IMAGE = /\.(png|jpe?g|webp)$/i;
+export function evidenceFiles(dir) {
+    const found = [];
+    let left = 0;
+    const walk = (rel) => {
+        let ents = [];
+        try {
+            ents = readdirSync(join(dir, rel), { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of ents) {
+            const child = `${rel}/${e.name}`;
+            if (e.isSymbolicLink())
+                continue;
+            if (e.isDirectory()) {
+                if (e.name !== 'node_modules' && !e.name.endsWith('.burst'))
+                    walk(child);
+                continue;
+            }
+            if (!e.isFile())
+                continue;
+            const size = statSync(join(dir, child)).size;
+            const text = EVIDENCE_TEXT.test(e.name), image = EVIDENCE_IMAGE.test(e.name);
+            if ((text && size <= EVIDENCE.textMax) || (image && size <= EVIDENCE.imageMax))
+                found.push({ path: child, size, text });
+            else
+                left++;
+        }
+    };
+    if (existsSync(join(dir, '.funtools')))
+        walk('.funtools');
+    found.sort((a, b) => Number(b.text) - Number(a.text) || (a.path < b.path ? -1 : 1));
+    const files = [];
+    let bytes = 0;
+    for (const f of found) {
+        if (bytes + f.size > EVIDENCE.totalMax) {
+            left++;
+            continue;
+        }
+        files.push(f.path);
+        bytes += f.size;
+    }
+    return { files: files.sort(), left, bytes };
+}
+const topWhy = (name, isDir) => {
+    if (/^(AGENTS|CLAUDE)\.md$|^\.(agents|claude|funtools|funpixel|cursor|kiro|codex)$/.test(name))
+        return 'agent files';
+    if (/\.md$/i.test(name))
+        return 'notes';
+    if (name === 'verify.json')
+        return 'a local verify record';
+    if (name === '.harnessignore' || name === '.gitignore')
+        return 'rewritten for the clean folder';
+    if (isDir && /^(tests?|__tests__)$/.test(name))
+        return 'tests';
+    if (isDir && /^(scripts|tools)$/.test(name))
+        return 'local scripts';
+    if (isDir && /^(design|docs|evidence|shots|captures|assets)$/.test(name))
+        return 'design and evidence';
+    return 'not a build input';
+};
+export function select(dir) {
+    const staged = stageFiles(dir, { own: false });
+    const dropped = [];
+    const topSeen = new Set();
+    const files = [];
+    for (const path of staged.included) {
+        const [top] = path.split('/');
+        const nested = path.includes('/');
+        if (nested ? !TOP_DIRS.has(top) : !TOP_FILES.test(path)) {
+            if (!topSeen.has(top)) {
+                topSeen.add(top);
+                dropped.push({ path: top, isDir: nested, why: topWhy(top, nested) });
+            }
+            continue;
+        }
+        const inner = INNER_DROP.find(([re]) => re.test(path));
+        if (inner) {
+            dropped.push({ path, isDir: false, why: inner[1] });
+            continue;
+        }
+        files.push(path);
+    }
+    for (const path of staged.skippedEmpty)
+        dropped.push({ path, isDir: false, why: 'empty' });
+    for (const e of staged.excluded) {
+        if (PRIVATE.includes(e.rule.pattern))
+            dropped.push({ path: e.path, isDir: e.isDir, why: 'agent files' });
+        else if (e.rule.pattern === SPLASH_FUNPIXEL && e.rule.line === 0)
+            dropped.push({ path: e.path, isDir: e.isDir, why: 'the Funpixel splash card, not chosen (funpixel.json "splash")' });
+    }
+    const ignoreFile = join(dir, '.harnessignore');
+    const ignoreFixes = [];
+    if (existsSync(ignoreFile)) {
+        const decide = makeDecider(parseHarnessIgnore(readFileSync(ignoreFile, 'utf8')));
+        for (const path of files) {
+            const parts = path.split('/');
+            for (let i = 1; i <= parts.length; i++) {
+                const rule = decide(parts.slice(0, i).join('/'), i < parts.length);
+                if (rule && !rule.negated) {
+                    ignoreFixes.push({ path, rule: rule.pattern, line: rule.line });
+                    break;
+                }
+            }
+        }
+    }
+    const unused = unreached(dir, files);
+    for (const path of unused)
+        dropped.push({ path, isDir: false, why: 'not imported by the game' });
+    return { files: files.filter((f) => !unused.includes(f)).sort(), dropped, ignoreFixes };
+}
+const CODE = /\.(ts|tsx|js|jsx|mjs|mts)$/;
+const SPEC = /\b(?:from\s*|import\s*\(\s*|import\s+)['"](\.{1,2}\/[^'"]+|\/src\/[^'"]+)['"]/g;
+const GLOB_ONE = /import\.meta\.glob\b[^(]*\(\s*(['"])([^'"]+)\1/g;
+export function unreached(dir, files) {
+    const code = files.filter((f) => f.startsWith('src/') && CODE.test(f) && !f.endsWith('.d.ts'));
+    const html = existsSync(join(dir, 'index.html')) ? readFileSync(join(dir, 'index.html'), 'utf8') : '';
+    const entries = [...html.matchAll(/<script[^>]*\bsrc=["']\.?\/?([^"']+)["']/g)].map((m) => m[1]).filter((f) => files.includes(f));
+    if (!entries.length)
+        return [];
+    const have = new Set(files);
+    const resolve = (from, spec) => {
+        const base = spec.startsWith('/') ? spec.slice(1) : join(from, '..', spec).replace(/\\/g, '/');
+        for (const c of [base, ...['.ts', '.tsx', '.js', '.jsx', '.mjs'].map((x) => base + x), `${base}/index.ts`, `${base}/index.tsx`])
+            if (have.has(c))
+                return c;
+        return null;
+    };
+    const seen = new Set();
+    const todo = [...entries];
+    while (todo.length) {
+        const f = todo.pop();
+        if (seen.has(f))
+            continue;
+        seen.add(f);
+        if (!CODE.test(f))
+            continue;
+        const text = readFileSync(join(dir, f), 'utf8');
+        if (/import\s*\(\s*[^'"\s)]/.test(text))
+            return [];
+        const globs = [...text.matchAll(/import\.meta\.glob\b/g)].length;
+        const named = [...text.matchAll(GLOB_ONE)].map((m) => m[2]);
+        if (globs !== named.length || named.some((p) => /[*?{}[\]!]/.test(p)))
+            return [];
+        for (const spec of [...[...text.matchAll(SPEC)].map((m) => m[1]), ...named]) {
+            const t = resolve(f, spec);
+            if (t)
+                todo.push(t);
+        }
+    }
+    return code.filter((f) => !seen.has(f));
+}
+export function trimManifest(text) {
+    const m = JSON.parse(text);
+    const kept = Object.fromEntries(MANIFEST_KEEP.filter((k) => k in m).map((k) => [k, m[k]]));
+    return { text: JSON.stringify(kept, null, 2) + '\n', removed: Object.keys(m).filter((k) => !(k in kept)) };
+}
+const BUILD_SCRIPTS = new Set(['dev', 'build', 'preview']);
+export function trimScripts(text, droppedTop) {
+    const pkg = JSON.parse(text);
+    const scripts = pkg.scripts;
+    if (!scripts || !droppedTop.length)
+        return { text, removed: [], broken: [] };
+    const escaped = droppedTop.map((d) => d.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    const gone = new RegExp(`(^|[\\s"'=])(\\./)?(${escaped.join('|')})/`);
+    const hits = Object.keys(scripts).filter((k) => gone.test(scripts[k]));
+    const broken = hits.filter((k) => BUILD_SCRIPTS.has(k));
+    const removed = hits.filter((k) => !BUILD_SCRIPTS.has(k));
+    if (!removed.length)
+        return { text, removed, broken };
+    for (const k of removed)
+        delete scripts[k];
+    return { text: JSON.stringify(pkg, null, 2) + '\n', removed, broken };
+}

package/dist/export/strip.js

@@ -0,0 +1,42 @@
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+export const SCRIPT = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+export const STYLE = /\.css$/;
+export function loadTypescript(gameDir) {
+    for (const from of [join(gameDir, 'package.json'), import.meta.filename]) {
+        try {
+            return createRequire(from)('typescript');
+        }
+        catch { }
+    }
+    return null;
+}
+const kindOf = (ts, path) => /\.tsx$/.test(path) ? ts.ScriptKind.TSX : /\.jsx$/.test(path) ? ts.ScriptKind.JSX : /\.[cm]?js$/.test(path) ? ts.ScriptKind.JS : ts.ScriptKind.TS;
+export function stripScript(ts, path, text) {
+    const sf = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, kindOf(ts, path));
+    const diags = sf.parseDiagnostics ?? [];
+    if (diags.length)
+        throw new Error(`${path} does not parse (${diags.length} error(s)); left as it is`);
+    return ts.createPrinter({ removeComments: true, newLine: ts.NewLineKind.LineFeed }).printFile(sf);
+}
+export function stripCss(text) {
+    let out = '';
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === '"' || c === "'") {
+            let j = i + 1;
+            while (j < text.length && text[j] !== c && text[j] !== '\n')
+                j += text[j] === '\\' ? 2 : 1;
+            out += text.slice(i, j + 1);
+            i = j;
+        }
+        else if (c === '/' && text[i + 1] === '*') {
+            const end = text.indexOf('*/', i + 2);
+            i = end < 0 ? text.length : end + 1;
+        }
+        else
+            out += c;
+    }
+    return out.replace(/[ \t]+$/gm, '').replace(/\n{3,}/g, '\n\n').replace(/^\n+/, '');
+}
+export const MEANINGFUL = /\/\*\s*[#@]__(PURE|NO_SIDE_EFFECTS)__|\/\*!|@license|@preserve|@vite-ignore|webpackChunkName/;