@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/variety/compare.js

@@ -0,0 +1,104 @@
+import { lab, parseHex } from "../look/readability.js";
+import { verbFamily, STILL_GRID } from "./profile.js";
+import { sameExpression } from "../wow/picks.js";
+export const LIMITS = {
+    palette: 12,
+    stillLayout: { desktop: 0.67, phone: 0.8 },
+    motifWords: 2,
+    motifs: 0.34,
+};
+const labOf = (hex) => { const c = parseHex(hex); return lab(c[0], c[1], c[2]); };
+const dE = (p, q) => Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
+const r1 = (n) => Math.round(n * 10) / 10;
+const r2 = (n) => Math.round(n * 100) / 100;
+export function paletteDistance(a, b) {
+    if (a.length < 3 || b.length < 3)
+        return null;
+    const la = a.map(labOf), lb = b.map(labOf);
+    const one = (x, y) => x.reduce((s, p) => s + Math.min(...y.map((q) => dE(p, q))), 0) / x.length;
+    return (one(la, lb) + one(lb, la)) / 2;
+}
+const cells = (s) => {
+    const out = [];
+    for (let i = 0; i + 2 <= s.length; i += 2)
+        out.push(parseInt(s.slice(i, i + 2), 16));
+    return out;
+};
+export function layoutCorrelation(a, b) {
+    const la = cells(a), lb = cells(b);
+    if (la.length !== STILL_GRID ** 2 || lb.length !== la.length || la.some(Number.isNaN) || lb.some(Number.isNaN))
+        return null;
+    const mean = (xs) => xs.reduce((s, x) => s + x, 0) / xs.length;
+    const ma = mean(la), mb = mean(lb);
+    let num = 0, da = 0, db = 0;
+    for (let i = 0; i < la.length; i++) {
+        num += (la[i] - ma) * (lb[i] - mb);
+        da += (la[i] - ma) ** 2;
+        db += (lb[i] - mb) ** 2;
+    }
+    return da < 1 || db < 1 ? null : num / Math.sqrt(da * db);
+}
+function titleScreen(a, b) {
+    let best = null;
+    for (const vp of ['desktop', 'phone']) {
+        const r = a[vp] && b[vp] ? layoutCorrelation(a[vp], b[vp]) : null;
+        if (r !== null && (!best || r - LIMITS.stillLayout[vp] > best.r - LIMITS.stillLayout[best.vp]))
+            best = { vp, r };
+    }
+    if (!best)
+        return { state: null, value: null, note: 'no title capture at one viewport for both' };
+    const close = best.r >= LIMITS.stillLayout[best.vp];
+    return { state: close ? 'close' : 'apart', value: r2(best.r), note: `${best.vp} title layout r ${r2(best.r)}${close ? ': the same screen, whatever the colours' : ''}` };
+}
+const jaccard = (a, b) => {
+    const A = new Set(a), B = new Set(b);
+    const inter = [...A].filter((x) => B.has(x));
+    return { share: A.size + B.size ? inter.length / new Set([...A, ...B]).size : 0, inter };
+};
+const words = (t) => t.toLowerCase().match(/[a-z]{4,}/g) ?? [];
+const sharedWords = (a, b) => [...new Set(a.flatMap((x) => b.filter((y) => x.startsWith(y) || y.startsWith(x)).map((y) => (y.length < x.length ? y : x))))];
+export function compare(me, other) {
+    const pd = paletteDistance(me.palette, other.palette);
+    const palette = pd === null
+        ? { state: null, value: null, note: 'fewer than three declared colours in one of them' }
+        : { state: pd < LIMITS.palette ? 'close' : 'apart', value: r1(pd), note: `palette ΔE ${r1(pd)}` };
+    let move;
+    if (!me.verb || !other.verb || !me.genre || !other.genre)
+        move = { state: null, value: null, note: 'a core verb or genre is not declared' };
+    else {
+        const fa = verbFamily(me.verb), fb = verbFamily(other.verb);
+        const same = fa === fb && me.genre === other.genre;
+        move = { state: same ? 'close' : 'apart', value: `${other.verb}/${other.genre}`, note: same ? `same move: ${fa} (${me.verb} / ${other.verb}) in ${me.genre}` : `${other.verb} in ${other.genre}` };
+    }
+    const m = jaccard(me.nouns, other.nouns);
+    const motifs = !me.nouns.length || !other.nouns.length
+        ? { state: null, value: null, note: 'no motif nouns in one of them' }
+        : { state: m.share >= LIMITS.motifs || m.inter.length >= LIMITS.motifWords ? 'close' : 'apart', value: r2(m.share), note: m.inter.length ? `shared: ${m.inter.join(', ')}` : 'nothing shared' };
+    const t = sharedWords(words(me.title), words(other.title));
+    const title = !words(me.title).length || !words(other.title).length
+        ? { state: null, value: null, note: 'a title too short to compare' }
+        : { state: t.length ? 'close' : 'apart', value: t.join(' ') || null, note: t.length ? `shares "${t.join(' ')}"` : 'no shared word' };
+    return { other: { game: other.game, title: other.title, genre: other.genre }, palette, move, titleScreen: titleScreen(me.stills, other.stills), motifs, title, hud: hudSignal(me.hud, other.hud), wow: wowSignal(me.wow, other.wow) };
+}
+export function wowSignal(a, b) {
+    if (!a || !b)
+        return { state: null, value: null, note: 'a signature wow is not picked in both (the GDD\'s ## Wow)' };
+    if (a.signature !== b.signature)
+        return { state: 'apart', value: b.signature, note: `their signature is ${b.signature}` };
+    const same = sameExpression(a.expression, b.expression);
+    return same
+        ? { state: 'close', value: a.signature, note: `the same signature, ${a.signature}, ${a.expression && b.expression ? `expressed alike ("${b.expression}")` : 'with no expression of its own'}: change the subject, the axis or the payoff` }
+        : { state: 'apart', value: a.signature, note: `the same signature, ${a.signature}, expressed apart ("${a.expression}" / "${b.expression}")` };
+}
+function hudSignal(a, b) {
+    if (!a || !b)
+        return { state: null, value: null, note: 'look --hud has not measured both' };
+    const shared = [['type', 'system', 'system type'], ['plates', 'dark', 'dark plates'], ['glyphs', 'stock', 'stock glyphs']]
+        .filter(([k, d]) => a[k] === d && b[k] === d).map(([, , w]) => w);
+    return shared.length >= 2
+        ? { state: 'close', value: shared.join(', '), note: `both HUDs wear the scaffold's clothes: ${shared.join(', ')}` }
+        : { state: 'apart', value: null, note: shared.length ? `only ${shared[0]} in common` : 'no default in common' };
+}
+export const SIGNALS = ['palette', 'move', 'titleScreen', 'motifs', 'title', 'hud', 'wow'];
+export const closeOnes = (c) => SIGNALS.filter((s) => c[s].state === 'close');
+export const observed = (c) => SIGNALS.filter((s) => c[s].state !== null);

package/dist/variety/places.js

@@ -0,0 +1,109 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, extname, join } from 'node:path';
+import { decodePng } from "../look/png.js";
+import { shrink } from "../assets/pixels.js";
+import { layoutOf } from "./profile.js";
+import { layoutCorrelation } from "./compare.js";
+export const LIMITS = { COLOUR: 16, LAYOUT: 0.55, SAME_COLOUR: 12, SET_MEDIAN: 15 };
+const IMAGE = /\.(png|jpe?g|webp)$/i;
+export function placePictures(root, gdd) {
+    const out = new Map();
+    const placesBody = /^##\s+(the\s+)?places\b[^\n]*\n([\s\S]*?)(?=^##\s|(?![\s\S]))/im.exec(gdd)?.[2] ?? '';
+    for (const m of placesBody.matchAll(/[\w./-]+\.(?:png|jpe?g|webp)/gi)) {
+        const rel = m[0].replace(/^\.\//, '');
+        const p = [rel, join('design', 'first-look', rel)].find((x) => existsSync(join(root, x)));
+        if (p && !out.has(p))
+            out.set(p, nameOf(p));
+    }
+    for (const d of [join('design', 'first-look'), join('design', 'places'), join('design', 'greenlight')]) {
+        if (!existsSync(join(root, d)))
+            continue;
+        for (const f of readdirSync(join(root, d)).sort()) {
+            const p = join(d, f).split('\\').join('/');
+            if (IMAGE.test(f) && /^place[-_]/i.test(f) && !out.has(p))
+                out.set(p, nameOf(p));
+        }
+    }
+    return [...out].map(([file, name]) => ({ name, file }));
+}
+const nameOf = (p) => basename(p, extname(p)).replace(/^place[-_]/i, '');
+export function readPicture(file) {
+    try {
+        const buf = readFileSync(file);
+        if (buf[0] === 0x89 && buf[1] === 0x50)
+            return decodePng(buf);
+    }
+    catch {
+        return null;
+    }
+    const dir = mkdtempSync(join(tmpdir(), 'fpx-places-'));
+    const out = join(dir, 'p.png');
+    try {
+        for (const [cmd, args] of [['sips', ['-s', 'format', 'png', file, '--out', out]], ['ffmpeg', ['-v', 'quiet', '-y', '-i', file, '-frames:v', '1', out]]]) {
+            try {
+                execFileSync(cmd, [...args], { stdio: 'ignore', timeout: 20_000 });
+                if (existsSync(out))
+                    return decodePng(readFileSync(out));
+            }
+            catch { }
+        }
+        return null;
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+const lab = (r, g, b) => {
+    const lin = (c) => { c /= 255; return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4; };
+    const R = lin(r), G = lin(g), B = lin(b);
+    const f = (t) => (t > 216 / 24389 ? Math.cbrt(t) : (24389 / 27 * t + 16) / 116);
+    const X = f((0.4124 * R + 0.3576 * G + 0.1805 * B) / 0.95047), Y = f(0.2126 * R + 0.7152 * G + 0.0722 * B), Z = f((0.0193 * R + 0.1192 * G + 0.9505 * B) / 1.08883);
+    return [116 * Y - 16, 500 * (X - Y), 200 * (Y - Z)];
+};
+export function shotOf(name, file, img) {
+    const g = shrink(img, 4, 4);
+    const grid = [];
+    for (let i = 0; i < 16; i++)
+        grid.push(lab(g.data[i * 4], g.data[i * 4 + 1], g.data[i * 4 + 2]));
+    return { name, file, grid, layout: layoutOf(img) };
+}
+export function comparePlaces(a, b) {
+    const colour = Math.round((a.grid.reduce((s, p, i) => s + Math.hypot(p[0] - b.grid[i][0], p[1] - b.grid[i][1], p[2] - b.grid[i][2]), 0) / a.grid.length) * 10) / 10;
+    const lc = layoutCorrelation(a.layout, b.layout);
+    const layout = lc === null ? null : Math.round(lc * 100) / 100;
+    const same = colour < LIMITS.SAME_COLOUR;
+    const shaped = colour < LIMITS.COLOUR && layout !== null && layout > LIMITS.LAYOUT;
+    const why = same ? `the same walls, floor and light (colour ΔE ${colour})` : shaped ? `one room's shape in close colours (layout ${layout}, colour ΔE ${colour})` : '';
+    return { a: a.name, b: b.name, colour, layout, alike: same || shaped, why };
+}
+export function readPlaces(root, gdd) {
+    const pictures = placePictures(root, gdd);
+    const unreadable = [];
+    const shots = [];
+    for (const p of pictures) {
+        const img = readPicture(join(root, p.file));
+        if (img)
+            shots.push(shotOf(p.name, p.file, img));
+        else
+            unreadable.push(p.file);
+    }
+    const pairs = [];
+    for (let i = 0; i < shots.length; i++)
+        for (let j = i + 1; j < shots.length; j++)
+            pairs.push(comparePlaces(shots[i], shots[j]));
+    const alike = pairs.filter((p) => p.alike);
+    const twins = [...new Set(alike.flatMap((p) => [p.a, p.b]))];
+    const sorted = pairs.map((p) => p.colour).sort((a, b) => a - b);
+    const median = sorted.length ? sorted[Math.floor((sorted.length - 1) / 2)] : null;
+    if (shots.length < 2)
+        return { verdict: 'not_observed', median, pictures, unreadable, pairs, twins, why: shots.length ? 'one place picture: nothing to compare (one place on purpose is an answer)' : 'no place pictures (design/first-look/place-*.png, or pictures named in ## Places)' };
+    const onePalette = shots.length >= 3 && median !== null && median < LIMITS.SET_MEDIAN;
+    return {
+        verdict: alike.length || onePalette ? 'warn' : 'pass', median, pictures, unreadable, pairs, twins,
+        why: alike.length || onePalette
+            ? `${alike.length ? `${twins.length} of ${shots.length} places read as another place repainted` : `the ${shots.length} places share one palette`} (median colour ΔE ${median}; apart starts near ${LIMITS.SET_MEDIAN}): give each its own plan shape, material, era and light (skill funpixel-gdd, references/level-and-fun.md)`
+            : `${shots.length} places apart (median colour ΔE ${median})`,
+    };
+}

package/dist/variety/profile.js

@@ -0,0 +1,127 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, isAbsolute, join, resolve } from 'node:path';
+import { nounsOf } from "../lessons/motifs.js";
+import { decodePng } from "../look/png.js";
+import { shrink } from "../assets/pixels.js";
+import { signatureOf } from "../wow/picks.js";
+export const STILL_GRID = 16;
+const field = (note, label) => new RegExp(`\\*\\*${label}:\\*\\*\\s*(.+)`, 'i').exec(note)?.[1].trim() ?? '';
+const section = (note, heading) => new RegExp(`^##\\s*${heading}\\s*\\n+([^\\n]+)`, 'im').exec(note)?.[1].trim() ?? '';
+export const cleanTitle = (t) => t.split(/\s+[—–-]\s+|:\s/)[0].replace(/\s*\((?:v\d[^)]*|draft[^)]*)\)\s*$/i, '').trim();
+const FAMILIES = {
+    fling: ['fling', 'aim', 'launch', 'sling', 'slingshot', 'pull', 'flick', 'throw', 'shoot', 'fire', 'lob', 'toss'],
+    slide: ['slide', 'swipe', 'glide', 'skate', 'push', 'shove'],
+    steer: ['steer', 'dodge', 'weave', 'drive', 'fly', 'swim', 'race', 'surf'],
+    jump: ['jump', 'hop', 'leap', 'bounce', 'climb', 'vault'],
+    drop: ['drop', 'stack', 'merge', 'fuse', 'combine'],
+    match: ['match', 'swap', 'connect', 'link', 'chain', 'pop'],
+    tap: ['tap', 'flip', 'press', 'toggle', 'click', 'poke'],
+    draw: ['draw', 'trace', 'paint', 'sketch', 'line'],
+    place: ['place', 'build', 'plant', 'arrange', 'fit', 'pack'],
+    turn: ['rotate', 'turn', 'spin', 'twist', 'fold'],
+    catch: ['catch', 'collect', 'gather', 'grab', 'string', 'herd'],
+    fight: ['fight', 'slash', 'strike', 'hit', 'punch', 'attack', 'stomp', 'bite'],
+};
+const FAMILY_OF = new Map(Object.entries(FAMILIES).flatMap(([f, vs]) => vs.map((v) => [v, f])));
+const base = (w) => (FAMILY_OF.has(w) ? w : w.replace(/ing$/, 'e').replace(/(?<=[^s])s$/, ''));
+export const verbFamily = (verb) => FAMILY_OF.get(base(verb)) ?? FAMILY_OF.get(verb.replace(/ing$/, '')) ?? base(verb);
+const NOT_VERBS = new Set(['a', 'an', 'the', 'one', 'you', 'your', 'are', 'can', 'play', 'this', 'every', 'each']);
+export function verbOf(note) {
+    const declared = field(note, 'Core verb').toLowerCase().match(/[a-z]+/)?.[0];
+    if (declared)
+        return declared;
+    for (const text of [field(note, 'Core loop') || section(note, 'Core loop'), field(note, 'Pitch')]) {
+        const you = /\byou(?:'re)?\s+([a-z]+)/i.exec(text)?.[1]?.toLowerCase();
+        if (you && !NOT_VERBS.has(you) && !/ly$/.test(you))
+            return you;
+        const first = /^[A-Za-z]+/.exec(text)?.[0].toLowerCase();
+        if (first && !NOT_VERBS.has(first) && FAMILY_OF.has(base(first)))
+            return first;
+    }
+    return '';
+}
+const HEX = /#[0-9a-f]{6}\b/gi;
+export function paletteOf(roles, note) {
+    const fromRoles = Object.values(roles).filter((v) => /^#[0-9a-f]{6}$/i.test(v));
+    const all = fromRoles.length ? fromRoles : note.match(HEX) ?? [];
+    return [...new Set(all.map((h) => h.toLowerCase()))].slice(0, 12);
+}
+export function layoutOf(img) {
+    const n = STILL_GRID * 4;
+    const s = shrink({ ...img, data: opaque(img) }, n, n);
+    const l = new Float64Array(n * n);
+    for (let i = 0; i < l.length; i++)
+        l[i] = 0.2126 * s.data[i * 4] + 0.7152 * s.data[i * 4 + 1] + 0.0722 * s.data[i * 4 + 2];
+    const cell = new Float64Array(STILL_GRID * STILL_GRID);
+    for (let y = 1; y < n - 1; y++) {
+        for (let x = 1; x < n - 1; x++) {
+            cell[(y >> 2) * STILL_GRID + (x >> 2)] += Math.hypot(l[y * n + x + 1] - l[y * n + x - 1], l[(y + 1) * n + x] - l[(y - 1) * n + x]);
+        }
+    }
+    const max = Math.max(...cell) || 1;
+    return [...cell].map((v) => Math.round((v / max) * 255).toString(16).padStart(2, '0')).join('');
+}
+const opaque = (img) => { const d = new Uint8Array(img.data); for (let i = 3; i < d.length; i += 4)
+    d[i] = 255; return d; };
+export function stillsOf(root) {
+    const out = {};
+    let index = {};
+    try {
+        index = JSON.parse(readFileSync(join(root, '.funtools', 'capture', 'index.json'), 'utf8'));
+    }
+    catch {
+        return out;
+    }
+    for (const vp of ['desktop', 'phone']) {
+        const e = ['title', 'menu', 'start'].map((v) => index[`${v}-${vp}`]).find((x) => x?.file);
+        if (!e?.file)
+            continue;
+        const file = isAbsolute(e.file) ? e.file : join(root, e.file);
+        try {
+            out[vp] = layoutOf(decodePng(readFileSync(file)));
+        }
+        catch { }
+    }
+    return out;
+}
+export function hudDressOf(root) {
+    const dir = join(root, '.funtools', 'look');
+    let files = [];
+    try {
+        files = readdirSync(dir).filter((f) => /^hud-[\w-]+\.json$/.test(f)).map((f) => join(dir, f)).sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
+    }
+    catch {
+        return null;
+    }
+    for (const f of files) {
+        const play = readJson(f).ui_style?.play;
+        if (!play || typeof play.default_plates !== 'number')
+            continue;
+        return { type: (play.system_type_share ?? 0) >= 0.6 ? 'system' : 'own', plates: play.default_plates >= 2 ? 'dark' : 'own', glyphs: (play.stock_glyphs?.length ?? 0) + (play.text_glyphs?.length ?? 0) >= 2 ? 'stock' : 'own' };
+    }
+    return null;
+}
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return {};
+} };
+export function profileOf(root) {
+    const notePath = ['GDD.md', 'README.md'].map((f) => join(root, 'design', f)).find((p) => existsSync(p));
+    if (!notePath)
+        return null;
+    const note = readFileSync(notePath, 'utf8');
+    const manifest = readJson(join(root, 'funpixel.json')), style = readJson(join(root, 'assets', 'style.json'));
+    const title = cleanTitle((/^#\s+(.+)$/m.exec(note)?.[1] ?? manifest.name ?? basename(root)).trim());
+    const roles = {};
+    for (const [k, v] of Object.entries(style.roles ?? {}))
+        if (typeof v === 'string')
+            roles[k] = v;
+    const look = section(note, 'Look') || section(note, 'Art direction') || field(note, 'Look');
+    return {
+        game: resolve(root), title, genre: String(manifest.metadata?.genre ?? '').toLowerCase(), verb: verbOf(note),
+        palette: paletteOf(roles, note), nouns: nounsOf([title, field(note, 'Pitch'), field(note, 'The 6-second ad'), look].join(' ')),
+        stills: stillsOf(root), hud: hudDressOf(root), wow: (() => { const s = signatureOf(note); return s ? { signature: s.id, expression: s.expression } : null; })(),
+    };
+}

package/dist/vendor/verify/README.md

@@ -0,0 +1,19 @@
+# @funpixel/verify
+
+The in-page probe that decides whether a game works: mechanic checks (verb, key,
+pointer, trace, visibility), the game's own self-tests, render health, and the
+bot sweep.
+
+One implementation, two callers:
+
+- `funpixel-browser` loads `src/page/*.js` with `include_str!` for the hosted probe.
+- `funtools verify` loads them through `src/index.js` for local, free runs.
+
+Each page script is a single function expression of one argument. Both callers
+wrap it the same way, `async () => (SCRIPT)(ARGS_JSON)`, so arguments are data and
+never spliced into the source.
+
+Proof that it matches: `funpixel-mono/scripts/probe-fixture.sh` against
+`games/probe-fixture` gives the same report before and after a change.
+
+    npm test    # every script parses as a one-argument function

package/dist/vendor/verify/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@funpixel/verify",
+  "version": "0.1.0",
+  "private": true,
+  "description": "The in-page game probe: mechanic checks, self-tests, render health, bot sweep. One implementation for the hosted probe and local funtools verify.",
+  "type": "module",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "files": ["src"],
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "engines": { "node": ">=20" }
+}

package/dist/vendor/verify/src/index.d.ts

@@ -0,0 +1,105 @@
+// Types for @funpixel/verify. The page scripts stay plain JS (they are injected
+// as source text, and funpixel-browser include_str!s them); their argument
+// shapes are pinned here instead, so a Node caller cannot send the wrong one.
+
+export interface MechanicCheckArgs {
+  drive: 'key' | 'pointer' | 'verb';
+  key: string;
+  code: string;
+  selector: string;
+  verb: string;
+  mode: 'verb' | 'input';
+  subject: string;
+  axis: 'x' | 'y';
+  field: string;
+  times: number;
+  hold: number;
+  trace: number;
+  settle: number;
+}
+
+export type SweepInputArg =
+  | { kind: 'key'; code: string }
+  | { kind: 'pointer'; sel: string }
+  | { kind: 'verb'; name: string };
+
+/** One step of the hosted blind player's act (play_act.js), coordinates in CSS pixels. */
+export type PlayActStep =
+  | { kind: 'tap'; x: number; y: number }
+  | { kind: 'drag'; x1: number; y1: number; x2: number; y2: number; ms: number }
+  | { kind: 'hold_at'; x: number; y: number; ms: number }
+  | { kind: 'hold_key'; key: string; ms: number }
+  | { kind: 'press'; key: string; times: number }
+  | { kind: 'wait'; ms: number };
+
+export interface ScriptArgs {
+  mechanic_check: MechanicCheckArgs;
+  context_loss_listener: Record<string, never>;
+  render_health: { default_width: number; default_height: number };
+  self_test: { max: number; timeout_ms: number };
+  bot_sweep: { inputs: SweepInputArg[]; reaction_ms: number; sweep_ms: number };
+  inventory: Record<string, never>;
+  first_paint: Record<string, never>;
+  /** seed: set as window.__FPX_SEED__ unless the page already has one. */
+  enter_view: { seed?: number };
+  audio: { op: 'install' | 'read'; since?: number; until?: number };
+  audio_cues: { op: 'install' | 'drain' };
+  moments: { op: 'install' | 'drain' };
+  hooks: { map: Record<string, string | Record<string, string>> };
+  preview: { budget_ms: number; default_width: number; default_height: number };
+  play:
+    | { op: 'install' }
+    | { op: 'run'; idle_samples: number; sample_ms: number; presses: number; inputs: Array<Exclude<SweepInputArg, { kind: 'verb' }>> };
+  fonts: { planned: string[]; timeout_ms: number };
+  audio_files: { max: number; timeout_ms: number };
+  renderer: { op: 'install' } | { op: 'read'; frames: number };
+  levels: { max: number; timeout_ms: number; budget_ms: number };
+  phone_check: { press: boolean; settle_ms: number; press_ms: number; max_controls: number; fps_ms: number; min_target: number };
+  front_door: { selector: string; timeout_ms: number; press_ms: number; settle_ms: number };
+  capture_view: { view: string | null; verbs: string[]; verb_gap_ms: number; hold_ms: number; freeze: boolean; settle_ms?: number };
+  /** The held clock, run as an init script before the game's code (step_clock.js). */
+  step_clock: { seed?: number; frame_ms?: number };
+  layout: { min_text_px: number; min_target: number; safe: { top: number; right: number; bottom: number; left: number }; max_items: number; pieces?: 'hud' | 'text' };
+  scene: { max_nodes: number; max_listed: number; phone_max_side: number };
+  actors: { player: string; threats: string; max: number };
+  motion: { player: string; threats: string; pickups: string; ms: number; every_ms: number; max: number };
+  perf: { view: string | null; frames: number; warmup: number; samples?: boolean; gpu?: boolean };
+  hud: { max: number };
+  play_act: { nonce: string; load: boolean; touch: boolean; steps: PlayActStep[] };
+  feel: { op: 'install'; player?: string; max?: number } | { op: 'input'; label: string } | { op: 'drain' };
+  made_of: { heroes: string; max: number };
+  life: { player: string; ms: number; every_ms: number; max_nodes: number };
+  world_actors: { ids?: string[]; player?: string; people?: string; creatures?: string; machines?: string; props?: string; max?: number };
+  life_anim:
+    | { op: 'install'; player?: string; people?: string; creatures?: string; every_ms?: number; max?: number; react_m?: number }
+    | { op: 'read' } | { op: 'stop' };
+  recorder: { op: 'start'; fps?: number; bps?: number } | { op: 'stop' } | { op: 'read'; offset: number; length: number } | { op: 'drop' };
+  frame_honesty: { cover?: number };
+  surfaces: { cells?: number; big?: number; max_tris?: number; backdrop?: string };
+  grounding: { min_size?: number; vehicles?: string; flyers?: string; ground?: string; max?: number; ignore?: string[] };
+  dressing: { radius?: number; max_size?: number; player?: string };
+  feel_sweep: {
+    cue?: string; anchor: FeelExpect; press?: string; offset_ms: number; lead_ms?: number;
+    success: FeelExpect; within_ms: number; timeout_ms: number;
+  };
+}
+
+/** A state condition a feel sweep watches: a dotted field (`threats.0.phase`), an operator, a value. */
+export interface FeelExpect { field: string; op: '=' | '!=' | '>' | '<' | '>=' | '<='; value: string | number | boolean }
+
+export type ScriptName = keyof ScriptArgs;
+
+/** The source of one page script: a single function expression of one argument. */
+export function scriptSource(name: ScriptName): string;
+
+/**
+ * A zero-argument function source for Playwright's evaluate, calling the named
+ * script with `args` as JSON. Every script answers with a string (usually
+ * JSON) or nothing; the caller parses it.
+ */
+export function pageScript<N extends ScriptName>(name: N, args?: ScriptArgs[N]): string;
+
+export const scripts: readonly ScriptName[];
+
+/** The Studio preview shim's source (touch emulation on `?funpixel_touch=1`), to inject first in <head>. */
+export function previewShim(): string;

package/dist/vendor/verify/src/index.js

@@ -0,0 +1,78 @@
+// @funpixel/verify — the in-page probe scripts, for Node callers (funtools).
+//
+// funpixel-browser loads the same files with Rust `include_str!` and builds the
+// same string as `pageScript` below, so the hosted probe and local verify run
+// one implementation. Don't fork a script into either caller.
+
+import { readFileSync } from 'node:fs';
+
+const SCRIPTS = [
+  'mechanic_check',
+  'context_loss_listener',
+  'render_health',
+  'self_test',
+  'bot_sweep',
+  'inventory',
+  'first_paint',
+  'enter_view',
+  'audio',
+  'audio_cues',
+  'hooks',
+  'preview',
+  'play',
+  'fonts',
+  'audio_files',
+  'levels',
+  'phone_check',
+  'moments',
+  'renderer',
+  'front_door',
+  'capture_view',
+  'layout',
+  'scene',
+  'actors',
+  'motion',
+  'perf',
+  'hud',
+  'play_act',
+  'feel',
+  'feel_sweep',
+  'made_of',
+  'life',
+  'world_actors',
+  'life_anim',
+  'recorder',
+  'frame_honesty',
+  'surfaces',
+  'grounding',
+  'dressing',
+  'step_clock',
+];
+
+/** The source of one page script: a single function expression of one argument. */
+export function scriptSource(name) {
+  if (!SCRIPTS.includes(name)) throw new Error(`unknown page script: ${name}`);
+  return readFileSync(new URL(`./page/${name}.js`, import.meta.url), 'utf8');
+}
+
+/**
+ * A zero-argument function source for Playwright's evaluate, calling the named
+ * script with `args` as JSON — the exact shape funpixel-browser's `page_script`
+ * builds. Arguments are data, never spliced into the source.
+ */
+export function pageScript(name, args = {}) {
+  return `async () => (${scriptSource(name).trim()})(${JSON.stringify(args)})`;
+}
+
+export const scripts = SCRIPTS;
+
+/**
+ * The Studio preview shim (touch emulation on `?funpixel_touch=1`, and the
+ * auto-resizer), to inject first in a page's <head>, before the game's own
+ * code. A byte-for-byte copy of build-plugins/funpixel-preview-shim.js, which
+ * the builder injects into every preview (a test pins the two), so a local
+ * phone look (funtools lookPage) sees the touch layout the hosted phone probe sees.
+ */
+export function previewShim() {
+  return readFileSync(new URL('./init/preview_shim.js', import.meta.url), 'utf8');
+}

package/dist/vendor/verify/src/init/preview_shim.js

@@ -0,0 +1,63 @@
+// Funpixel preview shim — injected at the TOP of every generated game's <head>,
+// BEFORE any game module runs. Two host→game bridges, both best-effort (a throw
+// here must never break the game). Single source of truth: this file is
+// include_str!'d by BOTH funpixel-edge (services/inspector.rs, the make-dev/
+// in-process build) AND funpixel-builder (src/inject.rs, the sandbox build).
+//
+// (a) TOUCH EMULATION (#23): when the page loads with ?funpixel_touch=1 (the
+//     Studio mobile-viewport preview), patch ontouchstart / navigator.maxTouchPoints
+//     / matchMedia('(pointer: coarse)') so a game's touch controls (dpad/HUD/
+//     safe-area) appear in the phone-sized preview. No-op on desktop preview +
+//     the shipped game (the param isn't set there).
+//
+// (b) AUTO-RESIZER (#34): games define window.__GAME_RESIZE__(w,h) but never
+//     reliably CALL it when the iframe ELEMENT is resized (an iframe-element resize
+//     does NOT fire a window 'resize' inside the iframe). So we drive it ourselves,
+//     like the inspector/profiler self-init — zero game code needed. On ANY size
+//     change (ResizeObserver on the doc + window resize/orientationchange + the
+//     host's FUNPIXEL_VIEWPORT_CHANGE postMessage) we call __GAME_RESIZE__(w,h) if
+//     the game defined it AND dispatch a synthetic window 'resize'. Deduped +
+//     0×0-guarded; fires once via rAF after boot. Works for EVERY game — SDK or
+//     not, new or already-built — so a panel resize / fullscreen / rotation always
+//     reflows the game to fill the frame.
+(function () {
+  try {
+    var p = new URLSearchParams(location.search);
+    if (p.get('funpixel_touch') === '1') {
+      if (!('ontouchstart' in window)) { try { window.ontouchstart = null; } catch (e) {} }
+      try { Object.defineProperty(navigator, 'maxTouchPoints', { get: function () { return 5; }, configurable: true }); } catch (e) {}
+      var mm = window.matchMedia ? window.matchMedia.bind(window) : null;
+      if (mm) {
+        window.matchMedia = function (q) {
+          var r = mm(q);
+          if (typeof q === 'string' && /pointer\s*:\s*coarse|hover\s*:\s*none|any-pointer\s*:\s*coarse/i.test(q)) {
+            return { media: q, matches: true, onchange: null, addEventListener: function () {}, removeEventListener: function () {}, addListener: function () {}, removeListener: function () {}, dispatchEvent: function () { return false; } };
+          }
+          return r;
+        };
+      }
+      document.documentElement.setAttribute('data-funpixel-touch', '1');
+    }
+  } catch (e) { /* touch emulation is best-effort — never break the game */ }
+
+  try {
+    var lastW = -1, lastH = -1;
+    function fpFireResize(w, h) {
+      if (!(w > 0) || !(h > 0) || (w === lastW && h === lastH)) return;
+      lastW = w; lastH = h;
+      try { if (typeof window.__GAME_RESIZE__ === 'function') window.__GAME_RESIZE__(w, h); } catch (e) {}
+      try { window.dispatchEvent(new Event('resize')); } catch (e) {}
+    }
+    var fpFromWindow = function () { fpFireResize(window.innerWidth, window.innerHeight); };
+    window.addEventListener('resize', fpFromWindow);
+    window.addEventListener('orientationchange', fpFromWindow);
+    window.addEventListener('message', function (e) {
+      var d = e && e.data;
+      if (d && d.type === 'FUNPIXEL_VIEWPORT_CHANGE' && typeof d.width === 'number' && typeof d.height === 'number') fpFireResize(d.width, d.height);
+    });
+    if (typeof ResizeObserver === 'function' && document.documentElement) {
+      try { new ResizeObserver(fpFromWindow).observe(document.documentElement); } catch (e) {}
+    }
+    try { requestAnimationFrame(fpFromWindow); } catch (e) { setTimeout(fpFromWindow, 0); }
+  } catch (e) { /* auto-resizer is best-effort */ }
+})();