@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/commands/dev.js

@@ -0,0 +1,138 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { clearPreview, DEV_FILE, setPreview } from "../status/status.js";
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { devtoolsPlugin, findDevtools } from "../dev/devtools.js";
+import { handleBridge, PLAY_PATH } from "../relay/bridge.js";
+import { devGameId, startRelay } from "../relay/local.js";
+import { botLine, startBots } from "../relay/bots.js";
+import { launch } from "../verify/browser.js";
+import { LAN_WARNING, lanAddress } from "../dev/lan.js";
+import { holdReloads } from "../dev/hold.js";
+import { qr, qrLines } from "../dev/qr.js";
+import { openTarget } from "../dev/open.js";
+import { ui } from "../ui.js";
+export function serverOptions(host) {
+    return { port: 5317, host: host ?? 'localhost' };
+}
+export async function gameVite(dir) {
+    try {
+        const pkg = createRequire(join(dir, 'package.json')).resolve('vite/package.json');
+        const entry = join(dirname(pkg), 'dist', 'node', 'index.js');
+        return existsSync(entry) ? await import(__rewriteRelativeImportExtension(pathToFileURL(entry).href)) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function dev(opts, io = console) {
+    const dir = resolve(opts.target ?? '.');
+    const u = ui(io, 'dev');
+    const vite = await gameVite(dir);
+    if (!vite) {
+        u.error(`vite is not installed in ${dir}`, 'run npm install first');
+        return 3;
+    }
+    const plugins = [];
+    if (opts.devtools !== false) {
+        let pkg = null;
+        try {
+            pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+        }
+        catch { }
+        const tools = findDevtools(pkg, dir);
+        if (typeof tools === 'string')
+            u.item('skip', 'devtools', tools);
+        else {
+            plugins.push(devtoolsPlugin(tools, [vite.searchForWorkspaceRoot(dir)]));
+            const also = [tools.scripts.some((s) => s.src.includes('-profiler.')) && 'profiler', tools.scripts.some((s) => s.src.includes('-kapture.')) && 'Kapture capture driver'].filter(Boolean);
+            u.item('pass', 'devtools', `the ${tools.engine.importName} inspector${also.length ? ` and ${also.join(' and ')}` : ''}, as a preview carries them`);
+        }
+    }
+    let relay = null;
+    if (opts.relay) {
+        relay = await startRelay();
+        const { redisUrl } = relay, gameId = devGameId(dir);
+        plugins.push({
+            name: 'funtools-relay-bridge',
+            configureServer(s) { s.middlewares.use((req, res, next) => { handleBridge(req, res, redisUrl, gameId).then((done) => done || next(), next); }); },
+        });
+        u.item('pass', 'relay', `${relay.reused ? 'the relay already on :7370' : 'a local relay on :7370'}, dev tickets for dev-${gameId}`);
+        if (opts.holdReloads !== false) {
+            plugins.push(holdReloads({ log: (l) => u.item('note', 'reload', l) }));
+            u.item('note', 'reloads', 'held while two or more pages are in the dev room, so a code change never ends a match (--no-hold turns it off)');
+        }
+    }
+    let host;
+    if (opts.phone) {
+        host = opts.host ?? lanAddress() ?? undefined;
+        if (!host) {
+            u.error('no local-network address found (Wi-Fi or Ethernet)', 'join a network, or pass --host <address>');
+            await relay?.stop();
+            return 3;
+        }
+    }
+    let bots = null;
+    let browser = null;
+    try {
+        const server = await vite.createServer({ root: dir, plugins, server: serverOptions(host) });
+        await server.listen();
+        server.printUrls();
+        try {
+            const url = server.resolvedUrls?.local?.[0] ?? 'http://localhost:5317/';
+            mkdirSync(join(dir, '.funtools'), { recursive: true });
+            writeFileSync(join(dir, DEV_FILE), JSON.stringify({ url, pid: process.pid, at: new Date().toISOString() }, null, 2) + '\n');
+            setPreview(dir, url);
+        }
+        catch { }
+        if (host) {
+            const port = new URL(server.resolvedUrls?.network?.[0] ?? server.resolvedUrls?.local?.[0] ?? 'http://x:5317').port;
+            const url = `http://${host === '0.0.0.0' ? lanAddress() ?? host : host}:${port}/`;
+            u.item('warn', 'on the local network', LAN_WARNING);
+            const code = qr(url);
+            if (code)
+                for (const line of qrLines(code))
+                    io.log(`  ${line}`);
+            u.item('note', 'on your phone', `scan the code or open ${url} on the same Wi-Fi; every save rebuilds there too`);
+        }
+        if (opts.open) {
+            const local = server.resolvedUrls?.local?.[0] ?? 'http://localhost:5317/';
+            const opened = openTarget(local);
+            u.item(opened ? 'pass' : 'note', opened ? 'opened' : 'open it', opened ? `the preview at ${local}, in your browser` : `${local} (nothing opens here: CI, FUNPIXEL_NO_OPEN, or no display)`);
+        }
+        const stopped = new Promise((done) => process.once('SIGINT', () => done()));
+        const play = `${server.resolvedUrls?.local?.[0]?.replace(/\/$/, '') ?? 'http://localhost:5317'}${PLAY_PATH}`;
+        if (relay && opts.bots) {
+            browser = (await launch(false, true)).browser;
+            bots = await startBots(browser, play, opts.bots);
+            for (const b of bots.bots) {
+                const [status, text] = botLine(b);
+                u.item(status, b.name, text);
+            }
+        }
+        if (relay)
+            u.item('note', bots ? `play with the bots: open ${play}` : `two players: open ${play} in two tabs`);
+        u.item('note', 'in another terminal, `npx @funpixel/tools verify --watch` re-verifies on every change');
+        await stopped;
+        await server.close();
+    }
+    finally {
+        try {
+            clearPreview(dir, process.pid);
+        }
+        catch { }
+        await bots?.stop();
+        await browser?.close();
+        await relay?.stop();
+    }
+    return 0;
+}

package/dist/commands/directions.js

@@ -0,0 +1,106 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { basename, join, relative, resolve } from 'node:path';
+import { EXIT } from "./verify.js";
+import { decodePng } from "../look/png.js";
+import { keyed, parseKey } from "./parts.js";
+import { cropTo, fitInside, pack, unionBox, writeSheet } from "../frames/sheet.js";
+import { ui } from "../ui.js";
+export const COMPASS8 = ['S', 'SW', 'W', 'NW', 'N', 'NE', 'E', 'SE'];
+export const COMPASS4 = ['S', 'W', 'N', 'E'];
+export function viewsIn(dir) {
+    for (const r of ['result.json', 'job.json']) {
+        const p = join(dir, r);
+        if (!existsSync(p))
+            continue;
+        try {
+            const j = JSON.parse(readFileSync(p, 'utf8'));
+            const fr = (j.result?.frames ?? j.frames);
+            if (Array.isArray(fr) && fr.length)
+                return fr.filter((f) => existsSync(join(dir, basename(f.file)))).map((f) => ({ file: join(dir, basename(f.file)), angle: Number(f.angle_deg) || 0 }));
+        }
+        catch { }
+    }
+    const turns = readdirSync(dir).filter((f) => /^turn_\d+\.png$/i.test(f)).sort();
+    return turns.map((f, i) => ({ file: join(dir, f), angle: (360 * i) / turns.length }));
+}
+export function assign(views, dirs, reverse = false) {
+    const names = dirs === 8 ? COMPASS8 : COMPASS4;
+    return names.map((d, k) => {
+        const want = ((reverse ? -1 : 1) * (360 / dirs) * k + 360) % 360;
+        let best = views[0], off = Infinity;
+        for (const v of views) {
+            const a = Math.abs(((v.angle - want + 540) % 360) - 180);
+            if (a < off) {
+                off = a;
+                best = v;
+            }
+        }
+        return { dir: d, view: best, off: Math.round(off) };
+    });
+}
+export async function directions(opts, io = console) {
+    const u = ui(io, 'directions');
+    const root = resolve(opts.dir ?? '.');
+    if (!opts.source) {
+        u.error('directions needs a render folder', 'funtools gen render --asset <model id> --out design/gen/hero-turn, then funtools directions design/gen/hero-turn');
+        return EXIT.error;
+    }
+    const src = resolve(root, opts.source);
+    if (!existsSync(src) || !statSync(src).isDirectory()) {
+        u.error(`no folder ${opts.source}`);
+        return EXIT.error;
+    }
+    const dirs = opts.dirs ?? 8;
+    if (dirs !== 8 && dirs !== 4) {
+        u.error(`--dirs ${dirs}`, '--dirs is 8 or 4');
+        return EXIT.error;
+    }
+    const key = parseKey(opts.key ?? 'auto');
+    if (!key) {
+        u.error(`--key ${opts.key}`, '--key is auto, none or a colour like #7a746c');
+        return EXIT.error;
+    }
+    const views = viewsIn(src);
+    if (views.length < dirs) {
+        u.summary('not_observed', `${views.length} view(s) in ${opts.source}: ${dirs} directions need at least ${dirs} (render with --frames ${dirs} or more)`);
+        return EXIT.not_observed;
+    }
+    const picked = assign(views, dirs, !!opts.reverse);
+    const imgs = [];
+    const keys = [];
+    for (const p of picked) {
+        const k = keyed(decodePng(await readFile(p.view.file)), key);
+        imgs.push(k.img);
+        keys.push(k.keyed);
+    }
+    if (imgs.some((f) => f.width !== imgs[0].width || f.height !== imgs[0].height)) {
+        u.error('the views are not all one size');
+        return EXIT.error;
+    }
+    const box = unionBox(imgs);
+    if (!box) {
+        u.error('every view keyed to nothing (pass --key none, or the stage colour)');
+        return EXIT.error;
+    }
+    const name = opts.name ?? basename(src).replace(/[^a-z0-9_-]+/gi, '-').toLowerCase();
+    const cut = imgs.map((f) => fitInside(cropTo(f, box), opts.size ?? 128));
+    const names = picked.map((p) => `${name}_${p.dir}`);
+    const out = resolve(root, opts.out ?? join('assets', 'sprites', `${name}-directions.png`));
+    const anims = Object.fromEntries(picked.map((p, i) => [`${name}_${p.dir}`, [names[i]]]));
+    const files = await writeSheet(out, pack(cut, names, dirs, anims, basename(out), { directions: picked.map((p) => ({ dir: p.dir, angle: p.view.angle, from: relative(root, p.view.file), off_deg: p.off })), keyed: keys[0] }));
+    const far = picked.filter((p) => p.off > 360 / dirs / 4);
+    const result = { verdict: far.length ? 'warn' : 'pass', directions: picked.map((p) => ({ dir: p.dir, view: relative(root, p.view.file), angle: p.view.angle, off_deg: p.off })), frame: { w: cut[0].width, h: cut[0].height }, png: relative(root, files.png), json: relative(root, files.json) };
+    if (opts.json) {
+        io.log(JSON.stringify(result, null, 2));
+        return EXIT.pass;
+    }
+    u.heading(`directions · ${views.length} views → ${dirs} directions`);
+    for (const p of picked)
+        u.item(p.off > 360 / dirs / 4 ? 'warn' : 'pass', p.dir, `${relative(root, p.view.file)} (${p.view.angle}°${p.off ? `, ${p.off}° off` : ''})`);
+    u.item('note', 'keyed', keys[0]);
+    u.line(`${result.png} + ${result.json} (${dirs} frames, ${cut[0].width}×${cut[0].height}, one animation per direction)`);
+    u.line(`in your game's 2D style (paid, one image edit per view; run only when wanted): ${picked.slice(0, 2).map((p) => `funtools gen edit --asset ${relative(root, p.view.file)} "the same figure, same pose and angle, painted in <the game's style>"`).join(' ; ')} …`);
+    u.summary(result.verdict, far.length ? `${far.length} direction(s) had no view near their angle: render with more --frames` : 'every direction has its view; check the walk reads in each before wiring it');
+    return EXIT.pass;
+}

package/dist/commands/doctor.js

@@ -0,0 +1,281 @@
+import { existsSync } from 'node:fs';
+import { copyFile, readFile } from 'node:fs/promises';
+import { isAbsolute, join, resolve } from 'node:path';
+import { stageFiles } from "../stage/stage.js";
+import { loadGame } from "../smoke/sources.js";
+import { assetUses } from "../smoke/orphans.js";
+import { makeIgnoreMatcher, parseHarnessIgnore } from "../stage/harnessignore.js";
+import { TEMPLATES } from "./init.js";
+import { guidanceHash } from "../guidance.js";
+import { CRITERIA_RANGE, criteriaOf } from "../criteria.js";
+import { browserCheck, webkitCheck } from "../verify/browser.js";
+import { phoneCheck } from "../phone/baguette.js";
+import { ui } from "../ui.js";
+import { hookMapOf, hookMapProblems } from "../verify/hooks.js";
+import { detectHost, HOST_LABEL, HOSTS, hostReport } from "../doctor/host.js";
+import { findLfsPointers, gitLfsInstalled, isUnityProject, pullHint, shown } from "../doctor/unity.js";
+import { readUnityProject, TARGET_NAME } from "../doctor/unity-project.js";
+import { projectChecks } from "../doctor/unity-checks.js";
+import { checkBuildModules, checkIosRelease, defaultHost } from "../doctor/unity-host.js";
+import { HISTORY_HEADING, historyChecks } from "../doctor/unity-history.js";
+import { LOCAL_HEADING, localModelLines } from "../gen/local/doctor.js";
+const HOOKS = [
+    { global: '__FPX_STATE__', field: 'state', hook: 'state', required: true },
+    { global: '__FPX_VERBS__', field: 'verbs', hook: 'verbs', required: true },
+    { global: '__FPX_VIEWS__', field: 'views', hook: 'views', required: false },
+    { global: '__FPX_KEYS__', field: 'keys', hook: 'keys', required: false },
+];
+const PRIVATE = ['AGENTS.md', 'CLAUDE.md', '.agents', '.claude', 'verify.json'];
+const DROP_IN = 'fpx-hooks.ts';
+const ENGINES = ['pixi.js', 'three', 'phaser'];
+const VITE_CONFIGS = ['vite.config.ts', 'vite.config.mts', 'vite.config.js', 'vite.config.mjs', 'vite.config.cjs'];
+const lf = (text) => text.replace(/\r\n/g, '\n');
+const NOT_HOOKS = /^__(FPX_\w*|PIXI_\w*|THREE\w*|REACT_\w*|VUE_\w*|FUNPIXEL_\w*)__$/;
+export const foreignGlobals = (code) => [...new Set([...code.matchAll(/\b(?:window|globalThis)\.(__[A-Z][A-Z0-9_]*__)\s*=/g)].map((m) => m[1]))].filter((g) => !NOT_HOOKS.test(g));
+async function addHooks(dir, u, code) {
+    const rel = existsSync(join(dir, 'src')) ? `src/${DROP_IN}` : DROP_IN;
+    u.heading(`doctor --add-hooks · ${dir}`);
+    if (existsSync(join(dir, rel)))
+        u.item('skip', `${rel} is already there`);
+    else {
+        await copyFile(join(TEMPLATES, 'common', 'src', DROP_IN), join(dir, rel));
+        u.item('pass', `wrote ${rel}`);
+    }
+    if (!existsSync(join(dir, 'package.json')))
+        u.item('warn', 'this game has no build step, so it cannot import a .ts file', 'set the window.__FPX_* globals directly (HOOKS.md), or map your own with "hooks" in funpixel.json');
+    u.heading('wire it where the game has started — three lines:');
+    u.line("import { exposeHooks } from './fpx-hooks';");
+    u.line('exposeHooks({ state: () => ({ score, lives, x: player.x }) });            // what checks read');
+    u.line("exposeHooks({ verbs: { jump: () => player.jump() }, keys: ['Space'] });  // what verify presses");
+    for (const g of foreignGlobals(code)) {
+        u.item('note', `found window.${g} — or map it with no code change, in funpixel.json:`, `"hooks": { "state": "${g}.state", "verbs": "${g}.actions" }`);
+    }
+}
+export function guidanceNote(recorded, madeByInit, installed = guidanceHash(join(TEMPLATES, 'common'))) {
+    if (recorded === installed)
+        return ['pass', `agent guidance is this funtools' GDK (${installed})`];
+    if (typeof recorded === 'string')
+        return ['warn', `agent guidance (${recorded}) is older than this funtools' GDK (${installed}) — run \`funtools upgrade\` for current skills`];
+    return madeByInit ? ['warn', 'funpixel.json records no guidance_hash — run `funtools upgrade` to bring the agent guidance up to date and record it'] : null;
+}
+export function doctorUnity(dir, opts, io = console) {
+    const u = ui(io, 'doctor');
+    const project = readUnityProject(dir);
+    const host = { ...defaultHost(), ...opts.unityHost };
+    const results = [];
+    const targets = [...project.targets].map(([t, why]) => `${TARGET_NAME[t]} (${why.join(', ')})`);
+    results.push(['note', `Unity project${project.version ? `, saved with ${project.version}` : ''}: the Unity pre-flight (the web checks do not apply); builds for ${targets.length ? targets.join(', ') : 'no platform it names'}`]);
+    const report = findLfsPointers(dir);
+    for (const p of report.missingPackages)
+        results.push(['warn', `Packages/manifest.json names a local package that is not here: ${p}`, 'Unity cannot resolve it; check out the repository it lives in, or fix the file: path']);
+    if (!report.groups.length) {
+        const places = report.scanned.map((p) => shown(dir, p)).filter((p) => !isAbsolute(p));
+        const outside = report.scanned.length - places.length;
+        if (outside)
+            places.push(`${outside} local package(s) outside the project`);
+        results.push(['pass', `no Git LFS pointer files where binaries belong (read ${places.join(', ') || 'nothing: no Assets or Packages'})`]);
+    }
+    else {
+        const lfs = (opts.lfsInstalled ?? gitLfsInstalled)();
+        for (const g of report.groups) {
+            const names = g.files.map((f) => shown(dir, f));
+            results.push(['fail', `${g.files.length} Git LFS pointer file(s) instead of their content, from ${shown(dir, g.root)}: ${names.slice(0, 4).join(', ')}${names.length > 4 ? ', …' : ''}`, pullHint(dir, g, lfs)]);
+        }
+        results.push(['note', 'Unity imports a pointer as the file it stands for and only says so in passing: "FSBTool ERROR: Failed decoding audio clip" for each sound, textures that draw as nothing; pull, then build']);
+    }
+    results.push(...projectChecks(project));
+    const sections = [{ heading: `doctor · ${dir}`, items: results }];
+    for (const s of [{ heading: HISTORY_HEADING, findings: historyChecks(project, host) }, checkBuildModules(project, host), checkIosRelease(project, host)]) {
+        if (!s.findings.length)
+            continue;
+        if (s.heading)
+            sections.push({ heading: s.heading, items: s.findings });
+        else
+            results.push(...s.findings);
+    }
+    for (const s of sections) {
+        u.heading(s.heading);
+        for (const [status, msg, detail] of s.items)
+            u.item(status, msg, detail);
+    }
+    const all = sections.flatMap((s) => s.items);
+    const failed = all.filter(([s]) => s === 'fail').length;
+    const warned = all.filter(([s]) => s === 'warn').length;
+    if (failed)
+        u.summary('fail', `${failed} problem(s) will break the Unity build${warned ? ` (and ${warned} warning(s))` : ''}`);
+    else
+        u.summary('pass', `ready to build${warned ? ` (${warned} warning(s))` : ''}`);
+    return failed ? 1 : 0;
+}
+export async function doctor(opts, io = console) {
+    const dir = resolve(opts.target ?? '.');
+    if (isUnityProject(dir))
+        return doctorUnity(dir, opts, io);
+    const results = [];
+    const ok = (m) => results.push(['pass', m]);
+    const warn = (m) => results.push(['warn', m]);
+    const fail = (m) => results.push(['fail', m]);
+    const read = async (rel) => (existsSync(join(dir, rel)) ? readFile(join(dir, rel), 'utf8') : null);
+    const json = async (rel) => { const t = await read(rel); try {
+        return t && JSON.parse(t);
+    }
+    catch {
+        return undefined;
+    } };
+    const [major, minor] = process.versions.node.split('.').map(Number);
+    major > 20 || (major === 20 && minor >= 11) ? ok(`node ${process.versions.node}`) : fail(`node ${process.versions.node} — 20.11 or newer is required`);
+    const madeByInit = existsSync(join(dir, '.funtools', 'managed.json'));
+    const sources = stageFiles(dir).included.filter((f) => /\.(t|j)sx?$/.test(f) && !f.endsWith(DROP_IN) && !/(^|\/)(vite|vitest)\.config\./.test(f));
+    const code = (await Promise.all(sources.map((f) => read(f)))).join('\n');
+    const manifest = await json('funpixel.json');
+    if (manifest === null)
+        warn('no funpixel.json — the upload is named after the folder, with no genre or framework (funtools init writes one)');
+    else if (manifest === undefined)
+        fail('funpixel.json is not valid JSON');
+    else {
+        manifest.name ? ok(`funpixel.json: "${manifest.name}"`) : fail('funpixel.json has no "name"');
+        const fw = manifest.metadata?.framework;
+        ['pixi', 'threejs'].includes(fw) ? ok(`framework: ${fw}`) : warn(`metadata.framework is "${fw ?? ''}" — pixi or threejs`);
+        Array.isArray(manifest.checks) && manifest.checks.length
+            ? ok(`${manifest.checks.length} check(s) for verify`)
+            : warn('no "checks" in funpixel.json — verify can only run self-tests and render health');
+        const { criteria, problems } = criteriaOf(manifest);
+        if (criteria.length)
+            ok(`${criteria.length} criteria for the player agent and the panel`);
+        else if (madeByInit || existsSync(join(dir, 'verify.json')))
+            warn(`no "criteria" in funpixel.json — write ${CRITERIA_RANGE[0]}–${CRITERIA_RANGE[1]} behaviours a player can check from outside (skill funpixel-gdd); the player agent and the panel judge them`);
+        for (const p of problems)
+            warn(p);
+        for (const p of hookMapProblems(manifest.hooks))
+            fail(p);
+        const guidance = guidanceNote(manifest.guidance_hash, madeByInit);
+        if (guidance)
+            results.push(guidance);
+    }
+    const pkg = await json('package.json');
+    const noBuildStep = pkg === null && existsSync(join(dir, 'index.html'));
+    if (noBuildStep)
+        results.push(['note', 'no package.json: no build step — publish uploads the folder as it is']);
+    else if (!pkg)
+        fail(pkg === null ? 'no package.json at the root — the platform installs and builds there' : 'package.json is not valid JSON');
+    else {
+        const deps = { ...pkg.dependencies };
+        const engine = ENGINES.find((e) => deps[e]);
+        const imported = ENGINES.filter((e) => new RegExp(`from\\s+['"]${e.replace('.', '\\.')}['"]`).test(code));
+        const undeclared = imported.filter((e) => !deps[e]);
+        if (undeclared.length)
+            fail(`${undeclared.join(', ')} is imported but not in "dependencies" — the platform's clean install won't have it`);
+        else
+            engine ? ok(`engine: ${engine}`) : results.push(['note', 'no engine package (pixi.js, three, phaser) — a canvas or DOM game']);
+        const sdk = deps['@funpixel/sdk'];
+        if (sdk && /^[~^]/.test(sdk))
+            warn(`@funpixel/sdk is "${sdk}" — pin it exactly, as the platform does`);
+    }
+    if (!noBuildStep) {
+        const typescript = sources.some((f) => /\.tsx?$/.test(f));
+        const tsconfig = await read('tsconfig.json');
+        const platform = async (rel) => lf(await readFile(join(TEMPLATES, 'common', rel), 'utf8'));
+        if (tsconfig !== null)
+            lf(tsconfig) === (await platform('tsconfig.json')) ? ok("tsconfig.json is the platform's") : warn("tsconfig.json differs from the platform's — the platform builds with its own");
+        else if (typescript)
+            warn('TypeScript with no tsconfig.json — the platform type-checks only a game that has one');
+        const viteConfig = VITE_CONFIGS.find((f) => existsSync(join(dir, f)));
+        if (viteConfig === 'vite.config.ts')
+            lf((await read(viteConfig))) === (await platform(viteConfig)) ? ok("vite.config.ts is the platform's") : warn("vite.config.ts differs from the platform's — the platform builds with its own");
+        else if (viteConfig)
+            ok(`${viteConfig} (the platform runs vite build at the root)`);
+        else
+            results.push(['note', 'no vite config — the platform runs vite build at the root with its defaults']);
+    }
+    const html = await read('index.html');
+    if (!html)
+        fail('no index.html at the root — vite builds from it there (a game in a subfolder: move it to the root)');
+    else {
+        /viewport-fit=cover/.test(html) ? ok('viewport meta covers the notch') : warn('index.html viewport meta lacks viewport-fit=cover');
+        /id=["']app["']/.test(html) ? ok('#app mount') : warn('no #app mount in index.html');
+    }
+    const u = ui(io, 'doctor');
+    if (opts.addHooks)
+        await addHooks(dir, u, code);
+    const viaDropIn = /\bexposeHooks\s*\(/.test(code);
+    const mapped = manifest ? hookMapOf(manifest) ?? {} : {};
+    const missing = HOOKS.filter((h) => !code.includes(h.global) && !(viaDropIn && new RegExp(`\\b${h.field}\\s*:`).test(code)) && !mapped[h.hook]);
+    if (Object.keys(mapped).length)
+        ok(`funpixel.json maps ${Object.keys(mapped).join(', ')} to the game's own globals`);
+    missing.length === 0
+        ? ok('the __FPX_* hooks are declared')
+        : (madeByInit && missing.some((h) => h.required) ? fail : warn)(`hooks not found: ${missing.map((h) => h.global).join(', ')} — verify cannot see what they cover (funtools doctor --add-hooks)`);
+    const ignoreText = await read('.harnessignore');
+    const ignored = makeIgnoreMatcher(parseHarnessIgnore(ignoreText ?? ''));
+    const leaking = PRIVATE.filter((p) => existsSync(join(dir, p)) && !ignored(p, p === '.agents' || p === '.claude'));
+    leaking.length === 0 ? ok('agent files stay out of uploads') : fail(`.harnessignore does not exclude: ${leaking.join(', ')} — they would ship with the game`);
+    const uses = assetUses(await loadGame(dir));
+    const orphans = uses.filter((a) => a.use === 'unreferenced').map((a) => a.path);
+    if (orphans.length)
+        warn(`${orphans.length} shipped asset(s) nothing names: ${orphans.slice(0, 3).join(', ')}${orphans.length > 3 ? ', …' : ''} — wire or remove them (funtools smoke lists all)`);
+    else if (uses.length)
+        ok(`every shipped asset is named (${uses.filter((a) => a.use === 'pattern').length} by a name built in code)`);
+    results.push((opts.browserCheck ?? browserCheck)());
+    results.push((opts.webkitCheck ?? webkitCheck)());
+    const phoneLine = (opts.phoneCheck ?? phoneCheck)();
+    if (phoneLine)
+        results.push(phoneLine);
+    u.heading(`doctor · ${dir}`);
+    for (const [status, msg] of results)
+        u.item(status, msg);
+    const locals = (opts.localModels ?? localModelLines)();
+    if (locals.length) {
+        u.heading(LOCAL_HEADING);
+        for (const l of locals)
+            u.item(l.state, `${l.check}: ${l.says}`, l.next);
+    }
+    const failed = results.filter(([s]) => s === 'fail').length;
+    const warned = results.filter(([s]) => s === 'warn').length;
+    if (failed)
+        u.summary('fail', `${failed} problem(s) will break the build or verify`);
+    else
+        u.summary('pass', `ready${warned ? ` (${warned} warning(s))` : ''}`);
+    return failed ? 1 : 0;
+}
+const MARK = { allowed: 'pass', denied: 'fail', 'not covered': 'warn', unknown: 'note' };
+export async function doctorHost(opts, io = console) {
+    const u = ui(io, 'doctor');
+    const dir = resolve(opts.target ?? '.');
+    const env = opts.env ?? process.env;
+    if (opts.host !== undefined && !HOSTS.includes(opts.host)) {
+        u.error(`unknown host: ${opts.host}`, `--host is ${HOSTS.join(', ')}, or nothing to detect it`);
+        return 3;
+    }
+    const found = opts.host ? null : detectHost(env);
+    const hosts = opts.host ? [opts.host] : found ? [found.host] : [...HOSTS];
+    const reports = hosts.map((h) => hostReport(h, dir, env, opts.home));
+    if (opts.json) {
+        io.log(JSON.stringify({ detected: found, reports }, null, 2));
+        return 0;
+    }
+    if (!opts.host)
+        u.item('note', found ? `running under ${HOST_LABEL[found.host]} (${found.why})` : 'no host detected: every host below', found ? undefined : 'name yours: --host claude|codex|cursor|kiro');
+    for (const r of reports) {
+        u.heading(`doctor --host ${r.host} · ${r.label}`);
+        for (const f of r.files)
+            u.item(f.found ? (f.problem ? 'warn' : 'pass') : 'skip', `${f.found ? 'read' : 'none'}: ${f.path}`, f.problem);
+        for (const n of r.notes)
+            u.item('note', n);
+        u.line('commands the kit runs:');
+        for (const c of r.commands)
+            u.item(MARK[c.status], `${c.status}: ${c.cmd}`, c.what);
+        u.line('shapes hosts often refuse, and a plain call that does the same job:');
+        for (const s of r.shapes)
+            u.item(MARK[s.status], `${s.status}: ${s.what} (${s.cmd})`, `${s.status === 'unknown' ? `${s.why}; ` : ''}instead: ${s.instead}`);
+        if (r.add) {
+            u.line(`to let the kit's commands through, you could add to ${r.add.where}:`);
+            for (const l of r.add.lines)
+                u.line(l, 2);
+        }
+        else
+            u.item('pass', 'every kit command is covered by these settings');
+        u.item('note', `a reading of these files, not the host's decision: ${r.caveat}`);
+    }
+    u.summary('pass', 'nothing was changed; the settings are yours to edit');
+    return 0;
+}

package/dist/commands/export.js

@@ -0,0 +1,88 @@
+import { resolve } from 'node:path';
+import { exportGame } from "../export/export.js";
+import { kb } from "../pack/limits.js";
+import { ui } from "../ui.js";
+function print(u, r) {
+    u.heading(`export · ${r.dir}${r.dest ? ` → ${r.dest}` : ''}`);
+    u.heading(`keeps (${r.files.length} file(s))`);
+    const tops = new Map();
+    for (const f of r.files)
+        tops.set(f.includes('/') ? `${f.split('/')[0]}/` : f, (tops.get(f.includes('/') ? `${f.split('/')[0]}/` : f) ?? 0) + 1);
+    u.line([...tops].map(([k, n]) => (k.endsWith('/') ? `${k} (${n})` : k)).join('  '));
+    if (r.evidence.length)
+        u.item('pass', `keeps ${r.evidence.length} evidence file(s) from .funtools/ in git (reports, scores, small frames)${r.evidenceLeft ? `; ${r.evidenceLeft} left behind (clips, bursts, big frames)` : ''}`, 'never uploaded: .funtools/ is private to every upload; push the folder so they survive');
+    if (r.dropped.length)
+        u.heading('leaves behind');
+    for (const d of r.dropped)
+        u.line(`${d.path}${d.isDir ? '/' : ''}  — ${d.why}`);
+    u.heading('changes');
+    const sum = (k) => r.stripped.reduce((n, s) => n + s[k], 0);
+    if (r.stripped.length)
+        u.item('pass', `comments removed from ${r.stripped.length} file(s)`, `${kb(sum('before'))} → ${kb(sum('after'))}, reprinted`);
+    for (const m of r.metadataStripped)
+        u.item('note', `metadata removed: ${m.path}`, `${m.chunks.join(', ')} (pixels untouched; its bundle copy differs on purpose)`);
+    if (r.manifestRemoved.length)
+        u.item('note', `funpixel.json: dropped ${r.manifestRemoved.join(', ')}`);
+    if (r.scriptsRemoved.length)
+        u.item('note', `package.json: dropped script(s) ${r.scriptsRemoved.join(', ')} (they run what was left behind)`);
+    for (const f of r.ignoreFixes)
+        u.item('warn', `ignore fix: ${f.path}`, `the old .harnessignore excluded it ("${f.rule}"${f.line ? `, line ${f.line}` : ''}) — an upload would have shipped without it; kept`);
+    u.heading('checks');
+    for (const f of r.findings)
+        u.item(f.level === 'problem' ? 'fail' : 'warn', f.path, `${f.what}${f.sample ? ` (${f.sample})` : ''}`);
+    if (!r.findings.some((f) => f.level === 'problem'))
+        u.item('pass', 'no leaks, no absolute public URLs in code, the .harnessignore keeps every build input');
+    const b = r.build;
+    if (b) {
+        if (!b.before.ok)
+            u.item('fail', 'the dev folder builds', b.before.detail);
+        if (!b.after.ok)
+            u.item('fail', 'the clean folder builds from what an upload carries', b.after.detail);
+        if (b.before.ok && b.after.ok) {
+            u.item(b.same ? 'pass' : 'fail', b.same ? `same bundle: ${Object.keys(b.after.dist ?? {}).length - r.metadataStripped.length} file(s) byte-identical before and after${r.metadataStripped.length ? `, ${r.metadataStripped.length} changed on purpose (metadata)` : ''}` : 'the bundle changed', b.same ? undefined : b.differ.slice(0, 8).join(', '));
+        }
+    }
+    const rt = r.runtime;
+    if (rt) {
+        u.heading('mobile and runtime (the game\'s to fix — never blocks the export)');
+        for (const v of rt.verify) {
+            u.item(v.verdict === 'pass' ? 'pass' : v.verdict === 'fail' ? 'warn' : 'not_observed', `verify ${v.viewport}: ${v.verdict}`, v.failed.map((f) => f.what).join(' · ') || undefined);
+            if (v.viewport === 'phone') {
+                if (v.unreachableKeys.length)
+                    u.item('warn', `phone: keys with no touch route: ${v.unreachableKeys.join(', ')}`);
+                u.item('note', `phone: ${v.touchControls} touch control(s) found`);
+            }
+        }
+        for (const a of rt.audit) {
+            u.item(a.verdict === 'pass' ? 'pass' : a.verdict === 'fail' ? 'warn' : 'not_observed', `audit-screens phone ${a.orientation}: ${a.verdict}`);
+            for (const v of a.views.filter((x) => x.verdict !== 'pass'))
+                u.line(`${v.view}: ${v.verdict}${v.items.length ? ` — ${v.items.join(' · ')}` : ''}`, 2);
+        }
+        if (!rt.missing.length)
+            u.item('pass', 'every request the game made was in the build');
+        for (const m of rt.missing)
+            u.item('fail', `requested ${m.url}`, `${m.status} on ${m.viewport}, view ${m.view} — not in the build`);
+    }
+    if (r.problems.length)
+        u.summary('fail', `${r.problems.length} problem(s)${r.dest ? ' — nothing written' : ''}`);
+    else if (r.wrote)
+        u.summary('pass', `clean — written to ${r.dest}`);
+    else
+        u.summary('pass', 'clean');
+}
+export async function exportCmd(opts, io = console) {
+    const u = ui(io, 'export');
+    if (!opts.dest && !opts.check) {
+        u.error('where to? funtools export <dest>', 'or --check to only report');
+        return 3;
+    }
+    const report = await exportGame({
+        dir: resolve(opts.dir ?? '.'), dest: opts.dest, check: opts.check, browser: opts.browser, stripMetadata: opts.stripMetadata,
+        progress: opts.json ? undefined : (line) => u.line(`… ${line}`, 0),
+    });
+    if (opts.json)
+        io.log(JSON.stringify(report, null, 2));
+    else
+        print(u, report);
+    return report.problems.length ? 1 : 0;
+}