@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/owner/match.js

@@ -0,0 +1,105 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { readProgress } from "../progress/progress.js";
+import { readPipeline } from "../pipeline/pipeline.js";
+import { writePipeline } from "../commands/next.js";
+import { GAME_BAR_FILE, gameProfile, judgeLine, readBar, readGameBar, WORLD_TOPIC } from "./bar.js";
+const stamp = (d) => d.toISOString().replace(/\.\d+Z$/, 'Z');
+function writeGameBar(root, b) {
+    const p = join(root, GAME_BAR_FILE);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(b, null, 2) + '\n');
+}
+function worldAnswer(root) {
+    const q = readProgress(root).questions.filter((x) => x.topic === WORLD_TOPIC).at(-1);
+    if (!q)
+        return null;
+    return { id: q.id, open: !q.answer, pick: q.answer?.pick ?? null, ...(q.answer?.words ? { words: q.answer.words } : {}) };
+}
+export function matchBar(root, o = {}) {
+    const now = o.now ?? new Date();
+    const p = readPipeline(root);
+    const was = readGameBar(root);
+    const lines = readBar(root, o.env);
+    const res = { bar: was ?? { version: 1, at: stamp(now), world: 'unsure', world_why: '', lines: [] }, added: [], withdrawn: [], asked: null, changed: false };
+    if (!p)
+        return res;
+    const g = o.profile ?? gameProfile(root);
+    const wa = worldAnswer(root);
+    const kept = [];
+    let pipelineMoved = false;
+    const all = [...lines, ...(was?.lines ?? []).filter((l) => !lines.some((x) => x.id === l.id))];
+    for (const line of all) {
+        const prev = was?.lines.find((l) => l.id === line.id);
+        let next;
+        if (prev?.by === 'owner')
+            next = { ...prev };
+        else {
+            let { verdict, why } = judgeLine(line, g);
+            let by = 'kit';
+            if (verdict === 'asked' && wa?.pick) {
+                verdict = wa.pick === 'yes' ? 'applies' : 'skipped';
+                by = 'owner';
+                why = wa.pick === 'yes' ? `the owner said it has a world (${wa.id}${wa.words ? `: "${wa.words}"` : ''})` : `the owner said no world to fill (${wa.id}${wa.words ? `: "${wa.words}"` : ''})`;
+            }
+            next = { id: line.id, text: line.text, aspect: line.aspect, source: line.source, verdict, why, by, at: prev && prev.verdict === verdict ? prev.at : stamp(now), ...(prev?.note ? { note: prev.note } : {}) };
+        }
+        const note = next.note ? p.notes.find((n) => n.id === next.note) : p.notes.find((n) => n.from_bar === line.id);
+        if (next.verdict === 'applies') {
+            if (note)
+                next.note = note.id;
+        }
+        else if (note && note.status === 'open' && !note.closed_by && !note.verdict) {
+            note.status = 'closed';
+            note.withdrawn = { why: next.why, at: stamp(now) };
+            res.withdrawn.push(note.id);
+            pipelineMoved = true;
+        }
+        if (next.verdict === 'asked')
+            next.ask = wa?.open ? wa.id : undefined;
+        else
+            delete next.ask;
+        kept.push(next);
+    }
+    for (const l of kept)
+        if (l.verdict === 'asked' && !wa?.open) {
+            l.verdict = 'applies';
+            l.why = `the kit could not tell (${g.why}); kept; the owner can skip it (owner skip <id>)`;
+            delete l.ask;
+        }
+    const world = kept.find((l) => l.aspect === 'world' && l.by === 'owner');
+    const bar = { version: 1, at: was?.at ?? stamp(now), world: world ? (world.verdict === 'applies' ? 'yes' : world.verdict === 'skipped' ? 'no' : 'unsure') : wa?.pick ? (wa.pick === 'yes' ? 'yes' : 'no') : g.world, world_why: world?.why ?? (wa?.pick ? `the owner's answer (${wa.id})` : g.why), lines: kept };
+    const before = JSON.stringify(was ? { ...was, at: '' } : null), after = JSON.stringify({ ...bar, at: '' });
+    if (pipelineMoved)
+        writePipeline(root, p);
+    if (before !== after || !existsSync(join(root, GAME_BAR_FILE))) {
+        if (kept.length || was)
+            writeGameBar(root, bar);
+        res.changed = true;
+    }
+    res.changed ||= pipelineMoved || !!res.asked;
+    res.bar = bar;
+    return res;
+}
+export function flipBar(root, which, verdict, o = {}) {
+    const now = o.now ?? new Date();
+    let b = readGameBar(root);
+    if (!b) {
+        matchBar(root, { now, env: o.env });
+        b = readGameBar(root);
+    }
+    if (!b)
+        throw new Error('this game has no owner bar yet (the person\'s ~/.funpixel/owner.md is empty): `funtools owner add "<line>"`');
+    const n = /^\d+$/.test(which) ? Number(which) : NaN;
+    const line = b.lines.find((l, i) => l.id === which || i + 1 === n);
+    if (!line)
+        throw new Error(`no bar line ${which} (${b.lines.map((l, i) => `${i + 1} ${l.id}`).join(', ')})`);
+    line.verdict = verdict;
+    line.by = 'owner';
+    line.at = stamp(now);
+    line.why = o.why?.trim() ? `the owner: ${o.why.trim().slice(0, 200)}` : verdict === 'applies' ? 'the owner applied it to this game' : 'the owner skipped it for this game';
+    delete line.ask;
+    writeGameBar(root, b);
+    matchBar(root, { now, env: o.env });
+    return readGameBar(root).lines.find((l) => l.id === line.id);
+}

package/dist/pack/build.js

@@ -0,0 +1,97 @@
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { cp, mkdir, mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { scanFile } from "./leaks.js";
+import { absoluteRefs } from "./deps.js";
+const WIN = process.platform === 'win32';
+function run(cmd, args, cwd) {
+    const r = spawnSync(cmd, args, { cwd, encoding: 'utf8', shell: WIN, timeout: 10 * 60_000 });
+    const out = `${r.stdout ?? ''}${r.stderr ?? ''}${r.error ? String(r.error) : ''}`;
+    return { ok: r.status === 0, out };
+}
+export function hashTree(dir, rel = '') {
+    const out = {};
+    for (const e of readdirSync(join(dir, rel), { withFileTypes: true })) {
+        const p = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory())
+            Object.assign(out, hashTree(dir, p));
+        else
+            out[p] = createHash('sha256').update(readFileSync(join(dir, p))).digest('hex');
+    }
+    return out;
+}
+const tail = (s, n = 6) => s.trim().split(/\r?\n/).slice(-n).join('\n');
+function dirBytes(dir) {
+    let n = 0;
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+        const p = join(dir, e.name);
+        n += e.isDirectory() ? dirBytes(p) : statSync(p).size;
+    }
+    return n;
+}
+export function scanDist(dist) {
+    const out = [];
+    const files = readdirSync(dist, { recursive: true }).map((p) => p.split('\\').join('/')).filter((p) => statSync(join(dist, p)).isFile());
+    for (const f of files) {
+        for (const x of scanFile(f, readFileSync(join(dist, f))))
+            out.push({ ...x, path: `dist/${f}`, level: 'warn' });
+    }
+    if (files.includes('index.html')) {
+        const abs = absoluteRefs(readFileSync(join(dist, 'index.html'), 'utf8'));
+        if (abs.length)
+            out.push({ path: 'dist/index.html', level: 'warn', what: `${abs.length} root-absolute URL(s) — a published game is served under a path, so these 404 there; set vite \`base: './'\``, sample: abs[0] });
+    }
+    return out;
+}
+export function localDependencies(pkg) {
+    const all = { ...pkg.dependencies, ...pkg.devDependencies };
+    return Object.entries(all)
+        .filter(([, v]) => typeof v === 'string' && /^(file|link|portal):/.test(v))
+        .map(([k, v]) => `${k}@${v}`);
+}
+function installer() {
+    if (run('pnpm', ['--version'], tmpdir()).ok) {
+        return { cmd: 'pnpm', args: ['install', '--ignore-scripts', '--no-frozen-lockfile', '--prefer-offline'] };
+    }
+    return { cmd: 'npm', args: ['install', '--ignore-scripts', '--no-audit', '--no-fund', '--prefer-offline', '--loglevel=error'] };
+}
+export async function buildStaged(dir, files, opts = {}) {
+    if (!files.includes('package.json')) {
+        return { ok: true, skipped: 'no package.json', detail: 'nothing to build — the platform installs and builds every upload, and a payload without package.json has failed there (ERR_PNPM_NO_PKG_MANIFEST)' };
+    }
+    const pkg = JSON.parse(await readFile(join(dir, 'package.json'), 'utf8'));
+    const local = localDependencies(pkg);
+    if (local.length)
+        return { ok: false, detail: `${local.join(', ')} resolves only on this machine — the server install fails` };
+    const work = await mkdtemp(join(tmpdir(), 'funtools-pack-'));
+    try {
+        for (const f of files) {
+            await mkdir(dirname(join(work, f)), { recursive: true });
+            await cp(join(dir, f), join(work, f));
+        }
+        const { cmd, args } = installer();
+        const installed = run(cmd, args, work);
+        if (!installed.ok)
+            return { ok: false, detail: `${cmd} install failed in the staged copy:\n${tail(installed.out)}` };
+        const vite = join(work, 'node_modules', '.bin', WIN ? 'vite.cmd' : 'vite');
+        if (!existsSync(vite))
+            return { ok: false, detail: 'vite is not in the dependencies — the platform builds with vite' };
+        const built = run(vite, ['build', '--base', './', '--logLevel', 'error'], work);
+        if (!built.ok)
+            return { ok: false, detail: `vite build failed in the staged copy:\n${tail(built.out)}` };
+        if (!existsSync(join(work, 'dist', 'index.html')))
+            return { ok: false, detail: 'the build wrote no dist/index.html' };
+        const dist = join(work, 'dist');
+        if (opts.keepDistIn) {
+            await rm(join(opts.keepDistIn, 'dist'), { recursive: true, force: true });
+            await cp(dist, join(opts.keepDistIn, 'dist'), { recursive: true });
+        }
+        return { ok: true, detail: `${cmd} install + vite build`, distBytes: dirBytes(dist), distFindings: scanDist(dist), ...(opts.hashes ? { dist: hashTree(dist) } : {}) };
+    }
+    finally {
+        await rm(work, { recursive: true, force: true });
+    }
+}

package/dist/pack/deps.js

@@ -0,0 +1,28 @@
+export const BANNED_DEPS = ['sharp', 'playwright', 'playwright-core', '@playwright/test', 'puppeteer', 'puppeteer-core', 'custom-pixi-particles'];
+const FIELDS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies', 'overrides', 'resolutions'];
+const SEMVER_OK = /^[A-Za-z0-9.^~<>=|\-+* \t]+$/;
+const NOT_PINNED = /^\s*(\*|x|latest|next)\s*$/i;
+export function checkDeps(pkg) {
+    const out = [];
+    for (const field of FIELDS) {
+        const block = pkg[field];
+        if (!block || typeof block !== 'object')
+            continue;
+        for (const [name, spec] of Object.entries(block)) {
+            const shown = (typeof spec === 'string' ? spec : JSON.stringify(spec)).slice(0, 60);
+            if (typeof spec !== 'string' || !SEMVER_OK.test(spec)) {
+                out.push({ path: 'package.json', level: 'warn', what: `${field}.${name} is not a plain semver range (git:, file:, link:, a URL or a workspace) — the server install refuses it`, sample: shown });
+            }
+            else if (NOT_PINNED.test(spec)) {
+                out.push({ path: 'package.json', level: 'warn', what: `${field}.${name} pins nothing — the next install can pull a breaking major`, sample: shown });
+            }
+            if (BANNED_DEPS.includes(name)) {
+                out.push({ path: 'package.json', level: 'warn', what: `${field}.${name} is tooling, not game code — keep it in a tools/ package the upload leaves out` });
+            }
+        }
+    }
+    return out;
+}
+export function absoluteRefs(html) {
+    return [...html.matchAll(/\b(?:src|href)\s*=\s*["'](\/(?!\/)[^"']*)["']/g)].map((m) => m[1]);
+}

package/dist/pack/leaks.js

@@ -0,0 +1,77 @@
+import { basename } from 'node:path';
+const SECRETS = [
+    [/-----BEGIN (?:RSA |EC |DSA |OPENSSH |ENCRYPTED |PGP )?PRIVATE KEY(?: BLOCK)?-----/, 'a private key'],
+    [/\bfp_live_[A-Za-z0-9_-]{16,}/, 'a Funpixel API key (fp_live_)'],
+    [/\bsk-(?:ant-|proj-|or-v1-)?[A-Za-z0-9_-]{20,}/, 'an API secret key (sk-…)'],
+    [/\b(?:sk|rk)_live_[A-Za-z0-9]{16,}/, 'a Stripe live key'],
+    [/\bAKIA[0-9A-Z]{16}\b/, 'an AWS access key id (AKIA…)'],
+    [/\bgh[pousr]_[A-Za-z0-9]{36,}\b/, 'a GitHub token'],
+    [/\bxox[abposr]-[A-Za-z0-9-]{10,}/, 'a Slack token'],
+    [/\bAIza[0-9A-Za-z_-]{35}\b/, 'a Google API key'],
+];
+const HOME_PATH = /(?<![\w./-])(?:\/Users\/|\/home\/|[A-Za-z]:[\\/]{1,2}Users[\\/]{1,2})[A-Za-z0-9._-]+[\\/]/;
+const GLB_VENDORS = /\b(tripo|meshy|hunyuan|mixamo)[:_-]{1,2}/i;
+const VENDOR_WORDS = /\b(OpenRouter|ElevenLabs|Lyria|gpt-image-\d[\w.-]*|Hunyuan|Meshy|Tripo|Mixamo|fal\.ai)\b/;
+const SCRATCH = /scratchpad|claude-501|\.claude\/worktrees|\/private\/tmp\/|\/private\/var\/folders\//i;
+const TOOLING = /harness-upload|X-Harness-Token|FUNPIXEL_HARNESS_/;
+const WORDS = [
+    [VENDOR_WORDS, 'a generator vendor named in shipped text — say what the game is, not who made its parts'],
+    [SCRATCH, 'an agent scratch, worktree or temp path'],
+    [TOOLING, 'internal upload tooling named in the game'],
+];
+const VENDORED = /(^|\/)(vendor|third[-_]party|draco|basis)\//i;
+const mask = (s) => (s.length <= 12 ? s : `${s.slice(0, 8)}…${s.slice(-2)}`);
+export const isText = (bytes) => !bytes.subarray(0, 8192).includes(0);
+export function glbJson(bytes) {
+    if (bytes.length < 20 || bytes.toString('latin1', 0, 4) !== 'glTF')
+        return null;
+    const len = bytes.readUInt32LE(12);
+    if (bytes.toString('latin1', 16, 20) !== 'JSON' || 20 + len > bytes.length)
+        return null;
+    return bytes.toString('utf8', 20, 20 + len);
+}
+function byName(path) {
+    const name = basename(path);
+    if (/^\.env(\..+)?$/.test(name) && !/^\.env\.(example|sample|template)$/.test(name)) {
+        return [{ path, level: 'leak', what: 'an environment file (.env) — it holds secrets by convention' }];
+    }
+    if (/\.(pem|p12|pfx|key)$/i.test(name) || /^id_(rsa|ecdsa|ed25519|dsa)$/.test(name)) {
+        return [{ path, level: 'leak', what: 'a key or certificate file' }];
+    }
+    if (/\.map$/i.test(name)) {
+        return [{ path, level: 'leak', what: 'a source map — it publishes the original source and the paths it was built from' }];
+    }
+    return [];
+}
+export function scanFile(path, bytes) {
+    const out = byName(path);
+    const glb = /\.glb$/i.test(path) ? glbJson(bytes) : null;
+    const text = glb ?? (isText(bytes) && bytes.length <= 8 * 1024 * 1024 ? bytes.toString('utf8') : null);
+    if (text === null)
+        return out;
+    for (const [re, what] of SECRETS) {
+        const m = text.match(re);
+        if (m)
+            out.push({ path, level: 'leak', what, sample: mask(m[0]) });
+    }
+    if (!VENDORED.test(path)) {
+        const m = text.match(HOME_PATH);
+        if (m)
+            out.push({ path, level: 'leak', what: 'an absolute path into a home directory', sample: m[0] });
+        if (/sourceMappingURL=data:/.test(text))
+            out.push({ path, level: 'leak', what: 'an inline source map' });
+        if (!glb && basename(path) !== '.harnessignore') {
+            for (const [re, what] of WORDS) {
+                const w = text.match(re);
+                if (w)
+                    out.push({ path, level: 'warn', what, sample: w[0].slice(0, 40) });
+            }
+        }
+    }
+    if (glb) {
+        const m = glb.match(GLB_VENDORS);
+        if (m)
+            out.push({ path, level: 'warn', what: 'a 3D vendor name inside the model (node/bone names)', sample: m[0] });
+    }
+    return out;
+}

package/dist/pack/limits.js

@@ -0,0 +1,51 @@
+export const SERVER = {
+    totalBytes: 200 * 1024 * 1024,
+    entryBytes: 14 * 1024 * 1024,
+    entries: 2000,
+};
+export const BUDGET = {
+    totalBytes: 50 * 1024 * 1024,
+    audioBytes: 1024 * 1024,
+    imageBytes: 2 * 1024 * 1024,
+    modelBytes: 10 * 1024 * 1024,
+};
+const AUDIO = /\.(mp3|m4a|ogg|wav|aac|flac)$/i;
+const IMAGE = /\.(png|jpe?g|webp|gif|avif|ktx2|basis|hdr|exr)$/i;
+const MODEL = /\.(glb|gltf|fbx|obj)$/i;
+export const kb = (n) => (n >= 1024 * 1024 ? `${(n / 1024 / 1024).toFixed(1)} MB` : `${Math.ceil(n / 1024)} kB`);
+export function badPath(path) {
+    if (path.includes('\\'))
+        return 'a backslash in the name';
+    if (/[\u0000-\u001f\u007f]/.test(path))
+        return 'a control character in the name';
+    if (path.split('/').includes('..'))
+        return 'a .. segment';
+    if (path.startsWith('/'))
+        return 'an absolute path';
+    return null;
+}
+export function checkLimits(files) {
+    const out = [];
+    let total = 0;
+    for (const { path, size } of files) {
+        total += size;
+        const bad = badPath(path);
+        if (bad)
+            out.push({ path, level: 'refused', what: `the server refuses ${bad}` });
+        if (size > SERVER.entryBytes)
+            out.push({ path, level: 'refused', what: `${kb(size)} is over the ${kb(SERVER.entryBytes)} per-file limit` });
+        else if (AUDIO.test(path) && size > BUDGET.audioBytes)
+            out.push({ path, level: 'warn', what: `audio is ${kb(size)} (budget ${kb(BUDGET.audioBytes)} per track)` });
+        else if (IMAGE.test(path) && size > BUDGET.imageBytes)
+            out.push({ path, level: 'warn', what: `image is ${kb(size)} (budget ${kb(BUDGET.imageBytes)})` });
+        else if (MODEL.test(path) && size > BUDGET.modelBytes)
+            out.push({ path, level: 'warn', what: `model is ${kb(size)} (budget ${kb(BUDGET.modelBytes)})` });
+    }
+    if (files.length > SERVER.entries)
+        out.push({ path: '', level: 'refused', what: `${files.length} files is over the ${SERVER.entries}-file limit` });
+    if (total > SERVER.totalBytes)
+        out.push({ path: '', level: 'refused', what: `${kb(total)} in total is over the ${kb(SERVER.totalBytes)} limit` });
+    else if (total > BUDGET.totalBytes)
+        out.push({ path: '', level: 'warn', what: `${kb(total)} in total (budget ${kb(BUDGET.totalBytes)}) — a phone downloads all of it` });
+    return out;
+}

package/dist/pack/report.js

@@ -0,0 +1,35 @@
+import { readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { stageFiles } from "../stage/stage.js";
+import { scanFile } from "./leaks.js";
+import { checkLimits } from "./limits.js";
+import { checkDeps } from "./deps.js";
+import { buildStaged } from "./build.js";
+import { loadGame } from "../smoke/sources.js";
+import { assetUses } from "../smoke/orphans.js";
+export async function packReport(dir, { build = true } = {}) {
+    const staged = stageFiles(dir);
+    const files = await Promise.all(staged.included.map(async (path) => ({ path, size: (await stat(join(dir, path))).size })));
+    const leaks = [];
+    for (const { path } of files)
+        leaks.push(...scanFile(path, await readFile(join(dir, path))));
+    const limits = checkLimits(files);
+    let deps = [];
+    if (staged.included.includes('package.json')) {
+        try {
+            deps = checkDeps(JSON.parse(await readFile(join(dir, 'package.json'), 'utf8')));
+        }
+        catch {
+            deps = [{ path: 'package.json', level: 'warn', what: 'package.json is not valid JSON' }];
+        }
+    }
+    const built = build ? await buildStaged(dir, staged.included) : null;
+    const orphans = assetUses(await loadGame(dir)).filter((a) => a.use === 'unreferenced').map((a) => a.path);
+    const dead = staged.dead.map((p) => staged.rules.find((r) => r.pattern === p && !r.negated) ?? { pattern: p, negated: false });
+    const blocked = [
+        ...leaks.filter((l) => l.level === 'leak').map((l) => `leak: ${l.path} — ${l.what}`),
+        ...limits.filter((l) => l.level === 'refused').map((l) => `refused: ${l.path ? `${l.path} — ` : ''}${l.what}`),
+        ...(built && !built.ok ? [`build: ${built.detail.split('\n')[0]}`] : []),
+    ];
+    return { dir, files, excluded: staged.excluded, dead, skippedEmpty: staged.skippedEmpty, leaks, deps, limits, build: built, orphans, blocked };
+}

package/dist/phone/baguette.js

@@ -0,0 +1,139 @@
+import { execFile, execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+export const INSTALL = 'brew install baguette';
+export function findBaguette(env = process.env) {
+    const dirs = ['/opt/homebrew/bin', ...(env.PATH ?? '').split(':')].filter(Boolean);
+    for (const d of dirs)
+        if (existsSync(join(d, 'baguette')))
+            return join(d, 'baguette');
+    return null;
+}
+export function runner(bin) {
+    return (args, timeoutMs = 120_000) => new Promise((ok, fail) => {
+        execFile(bin, args, { timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err)
+                fail(new Error(`baguette ${args[0]}: ${String(stderr || err.message).trim().split('\n').slice(-2).join(' ')}`));
+            else
+                ok(String(stdout));
+        });
+    });
+}
+export function phoneSupport(platform = process.platform, arch = process.arch, env = process.env) {
+    if (platform !== 'darwin')
+        return { ok: false, why: 'the iOS Simulator runs only on macOS', install: null };
+    if (arch !== 'arm64')
+        return { ok: false, why: 'baguette needs an Apple Silicon Mac', install: null };
+    const bin = findBaguette(env);
+    if (!bin)
+        return { ok: false, why: 'baguette is not installed', install: INSTALL };
+    return { ok: true, bin };
+}
+export function phoneCheck(support = phoneSupport(), version = (bin) => {
+    try {
+        return execFileSync(bin, ['--version'], { timeout: 5000 }).toString().trim();
+    }
+    catch {
+        return '';
+    }
+}) {
+    if (support.ok) {
+        const v = version(support.bin);
+        return ['pass', `baguette${v ? ` ${v}` : ''}: \`funtools phone\` opens the game in the iOS Simulator's Safari (real WebKit), taps it and reads its frames`];
+    }
+    if (support.install)
+        return ['note', `real iPhone Safari (WebKit), optional: ${support.install} — then \`funtools phone\` opens the game in the iOS Simulator`];
+    return null;
+}
+export function parseDevices(json) {
+    try {
+        const d = JSON.parse(json);
+        return [...(d.running ?? []), ...(d.available ?? [])].filter((x) => x && typeof x.udid === 'string');
+    }
+    catch {
+        return [];
+    }
+}
+const version = (runtime) => (runtime.match(/[\d.]+/)?.[0] ?? '0').split('.').map(Number);
+const newer = (a, b) => {
+    const x = version(a.runtime), y = version(b.runtime);
+    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 pickDevice(devices, want) {
+    if (want) {
+        const hit = devices.filter((d) => d.udid === want || d.name.toLowerCase() === want.toLowerCase()).sort(newer);
+        return hit[0] ?? null;
+    }
+    const phones = devices.filter((d) => /^iPhone\b/.test(d.name)).sort(newer);
+    return phones.find((d) => d.state === 'Booted') ?? phones.find((d) => d.name === 'iPhone 17 Pro') ?? phones[0] ?? null;
+}
+export function parseAx(json) {
+    try {
+        const n = JSON.parse(json);
+        return n && typeof n === 'object' ? n : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function flattenAx(root) {
+    const out = [];
+    const walk = (n) => { out.push(n); for (const c of n.children ?? [])
+        walk(c); };
+    if (root)
+        walk(root);
+    return out;
+}
+export const START_WORDS = /^(?:▶\s*)?(play|start|tap to (?:start|play)|go|begin|new game|let'?s go|fight|continue)\b/i;
+const CONTROL = /^AX(Button|Link|MenuItem|CheckBox|Switch|Slider|TextField|PopUpButton)$/;
+export function controlOf(n) {
+    if (!n.role || !CONTROL.test(n.role) || !n.frame)
+        return null;
+    return { role: n.role.replace(/^AX/, '').toLowerCase(), label: String(n.label ?? n.value ?? '').trim(), ...n.frame };
+}
+export function sweepPoints(size, step = 44, top = 60, bottom = 110) {
+    const out = [];
+    for (let y = top; y <= size.height - bottom; y += step)
+        for (let x = step / 2; x < size.width; x += step)
+            out.push({ x: Math.round(x), y: Math.round(y) });
+    return out;
+}
+export function distinctControls(nodes) {
+    const seen = new Map();
+    for (const n of nodes) {
+        const c = controlOf(n);
+        if (!c)
+            continue;
+        const key = `${c.label}@${Math.round(c.x)},${Math.round(c.y)}`;
+        if (!seen.has(key))
+            seen.set(key, c);
+    }
+    return [...seen.values()].sort((a, b) => a.y - b.y || a.x - b.x);
+}
+export function popupClose(root) {
+    const all = flattenAx(root);
+    if (!all.some((n) => /dismiss popup/i.test(String(n.label ?? ''))))
+        return null;
+    for (const n of all) {
+        const c = controlOf(n);
+        if (c && /^close$/i.test(c.label))
+            return c;
+    }
+    return null;
+}
+export function landscapeOf(root) {
+    const f = root?.frame;
+    if (!f || !(f.width > 0) || !(f.height > 0) || f.height >= f.width)
+        return null;
+    const k = f.height / f.width;
+    return { size: { width: Math.round(f.width / k), height: Math.round(f.width) }, k, ox: f.x, oy: f.y };
+}
+export function toLandscape(c, g) {
+    return { ...c, x: (c.x - g.ox) / g.k, y: (c.y - g.oy) / g.k, width: c.width / g.k, height: c.height / g.k };
+}
+export function landscapeTap(x, y, g) {
+    return { x: Math.round(y), y: Math.round(g.size.width - x), width: g.size.height, height: g.size.width };
+}

package/dist/phone/listen.js

@@ -0,0 +1,65 @@
+export const REPORT_PATH = '/__funtools/phone';
+export const REPORTER = `(function(){
+  var P=${JSON.stringify(REPORT_PATH)};
+  function send(o){try{o.t=Math.round(performance.now());var b=JSON.stringify(o);fetch(P,{method:'POST',body:b,keepalive:true}).then(function(r){return r.text();}).then(function(t){if(t==='leave')location.replace('about:blank');}).catch(function(){});}catch(e){}}
+  function state(){try{return typeof window.__FPX_STATE__==='function'?window.__FPX_STATE__():null;}catch(e){return null;}}
+  addEventListener('error',function(e){send({kind:'error',message:String(e.message),file:e.filename||'',line:e.lineno||0,col:e.colno||0,stack:e.error&&e.error.stack?String(e.error.stack):''});});
+  addEventListener('unhandledrejection',function(e){var r=e.reason;send({kind:'rejection',message:String(r&&r.message||r),stack:r&&r.stack?String(r.stack):''});});
+  var ce=console.error;console.error=function(){try{send({kind:'console',message:Array.prototype.map.call(arguments,function(a){return a&&a.message?a.message:String(a);}).join(' ')});}catch(e){}return ce.apply(console,arguments);};
+  ['pointerdown','pointerup','pointercancel','click'].forEach(function(k){addEventListener(k,function(e){var el=e.target;send({kind:'input',type:k,x:Math.round(e.clientX||0),y:Math.round(e.clientY||0),target:el&&el.tagName?String(el.tagName).toLowerCase()+(el.getAttribute&&el.getAttribute('aria-label')?'['+el.getAttribute('aria-label')+']':''):''});},true);});
+  var last=0,xs=[];function f(t){if(last)xs.push(Math.round((t-last)*100)/100);last=t;requestAnimationFrame(f);}requestAnimationFrame(f);
+  function insets(){try{var d=document.createElement('div');d.style.cssText='position:fixed;visibility:hidden;padding:env(safe-area-inset-top) env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left)';document.documentElement.appendChild(d);var s=getComputedStyle(d),o=[s.paddingTop,s.paddingRight,s.paddingBottom,s.paddingLeft].map(parseFloat);d.remove();return o;}catch(e){return null;}}
+  function start(){try{var es=document.querySelectorAll('[data-fpx-start]');for(var i=0;i<es.length;i++){var r=es[i].getBoundingClientRect();if(r.width>0&&r.height>0&&getComputedStyle(es[i]).visibility!=='hidden')return{x:Math.round(r.left),y:Math.round(r.top),w:Math.round(r.width),h:Math.round(r.height),label:String(es[i].getAttribute('aria-label')||es[i].textContent||'').trim().slice(0,40),text:String(es[i].innerText||es[i].textContent||'').replace(/\s+/g,' ').trim().slice(0,40)};}}catch(e){}return null;}
+  function hello(){send({kind:'hello',ua:navigator.userAgent,w:innerWidth,h:innerHeight,dpr:devicePixelRatio,insets:insets(),state:state(),start:start()});}
+  if(document.readyState==='loading'){addEventListener('DOMContentLoaded',hello);}else{hello();}
+  setInterval(function(){send({kind:'frames',ms:xs.splice(0),hidden:document.hidden,state:state(),start:start()});},1000);
+})();`;
+export function withReporter(html) {
+    const tag = `<script id="funtools-phone">${REPORTER}</script>`;
+    const head = /<head[^>]*>/i.exec(html);
+    return head ? html.slice(0, head.index + head[0].length) + tag + html.slice(head.index + head[0].length) : tag + html;
+}
+export function phoneRoutes(readIndex, into, control = { leave: false, left: false }) {
+    return async (req, res) => {
+        const path = new URL(req.url ?? '/', 'http://x').pathname;
+        if (req.method === 'POST' && path === REPORT_PATH) {
+            let body = '';
+            for await (const chunk of req) {
+                body += chunk;
+                if (body.length > 1_000_000)
+                    break;
+            }
+            try {
+                into.push({ ...JSON.parse(body), at: Date.now() });
+            }
+            catch { }
+            if (control.leave) {
+                control.left = true;
+                res.writeHead(200, { 'Content-Type': 'text/plain' });
+                res.end('leave');
+                return true;
+            }
+            res.writeHead(204);
+            res.end();
+            return true;
+        }
+        if (req.method === 'GET' && (path === '/' || path === '/index.html')) {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store' });
+            res.end(withReporter(await readIndex()));
+            return true;
+        }
+        return false;
+    };
+}
+export function tapSeen(reports, since) {
+    const xs = reports.filter((r) => r.kind === 'input' && r.at >= since).map((r) => String(r.type));
+    return { down: xs.includes('pointerdown'), up: xs.includes('pointerup'), click: xs.includes('click') };
+}
+export function frameStats(ms) {
+    const xs = ms.filter((x) => x > 0 && x < 5000).sort((a, b) => a - b);
+    if (xs.length < 5)
+        return null;
+    const q = (p) => xs[Math.min(xs.length - 1, Math.floor(p * xs.length))];
+    const r = (x) => Math.round(x * 10) / 10;
+    return { frames: xs.length, p50: r(q(0.5)), p95: r(q(0.95)), max: r(xs[xs.length - 1]), fps_p95: r(1000 / q(0.95)), long: xs.filter((x) => x > 33.4).length };
+}