@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/commands/life.js

@@ -0,0 +1,134 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { pageScript } from '../vendor/verify/src/index.js';
+import { EXIT } from "./verify.js";
+import { withPage } from "./look.js";
+import { drive, evalJson, load } from "../look/look.js";
+import { armMoments, drainMoments, pageNow } from "../look/moments.js";
+import { judgeReaction, LIFE, lifeFindings, recordLife, windowOf } from "../look/life.js";
+import { hookMapOf } from "../verify/hooks.js";
+import { fingerprint } from "../verify/fingerprint.js";
+import { readsUnchanged } from "../verify/reads.js";
+import { lifeVerdicts } from "../look/anim.js";
+import { groundingChecks, groundTally, tallyGround } from "../walk/world.js";
+import { isThree } from "../progress/holds.js";
+import { ui } from "../ui.js";
+import { playerOf } from "../look/player.js";
+export const NOT_PLAY = /title|menu|splash|intro|pause|over|end|won|win|lost|lose|result|credit|settings|how|help|gallery/i;
+export function playViewOf(views) {
+    return views.find((v) => v.motion)?.name ?? views.find((v) => !v.moment && !NOT_PLAY.test(v.name))?.name ?? null;
+}
+const sampleArgs = (manifest, ms) => ({
+    player: playerOf(manifest).pattern, ms, every_ms: LIFE.everyMs, max_nodes: LIFE.maxNodes,
+});
+const animArgs = (manifest) => ({
+    op: 'install', player: playerOf(manifest).pattern, every_ms: LIFE.everyMs,
+    ...(typeof manifest.life?.people === 'string' ? { people: manifest.life.people } : {}), ...(typeof manifest.life?.creatures === 'string' ? { creatures: manifest.life.creatures } : {}),
+});
+export async function walkTravel(dir) {
+    if (!dir)
+        return null;
+    try {
+        const w = JSON.parse(await readFile(join(dir, '.funtools', 'walk.json'), 'utf8'));
+        if (w?.fingerprint && w.fingerprint !== (await fingerprint(dir)).fingerprint && !readsUnchanged(dir, w))
+            return null;
+        const routes = Array.isArray(w?.routes) ? w.routes : [];
+        const best = routes.filter((r) => r?.travel && typeof r.travel.people === 'number' && r.travel.people > 0)
+            .sort((a, b) => b.travel.people - a.travel.people || (b.seconds ?? 0) - (a.seconds ?? 0))[0];
+        return best ? { people: best.travel.people, moved: best.travel.moved ?? 0, seconds: best.seconds ?? 0, route: String(best.name ?? 'walk') } : null;
+    }
+    catch {
+        return null;
+    }
+}
+const audioRead = (page) => evalJson(page, 'audio', { op: 'read' });
+export async function audioSpan(page, since, until) {
+    if (!Number.isFinite(since) || !Number.isFinite(until))
+        return null;
+    const r = await evalJson(page, 'audio', { op: 'read', since, until });
+    if (!r?.observed || !r.between)
+        return r?.observed === false ? { observed: false, sources_started: 0, media_plays: 0 } : null;
+    return { observed: true, sources_started: Number(r.between.starts) || 0, media_plays: 0, by_cue: r.between.cues ?? {} };
+}
+export async function life(opts, io = console) {
+    const u = ui(io, 'life');
+    const r = await withPage(u, opts, async (page, t) => {
+        await page.addInitScript(`(${pageScript('audio', { op: 'install' })})()`);
+        await load(page, t.url, hookMapOf(t.manifest));
+        const declared = (await evalJson(page, 'capture_view', { view: null, verbs: [], verb_gap_ms: 0, hold_ms: 0, freeze: false }))?.views ?? [];
+        const view = opts.view ?? playViewOf(declared);
+        await drive(page, { view, verbs: [], holdMs: 600, freeze: false, click: opts.click });
+        const a0 = await audioRead(page);
+        const ground = groundTally();
+        tallyGround(ground, await evalJson(page, 'grounding', {}), 0);
+        const cast = await evalJson(page, 'world_actors', { max: 400 });
+        const contractPeople = cast?.source === 'contract' && Array.isArray(cast.actors) ? cast.actors.filter((a) => a?.kind === 'person').length : 0;
+        await evalJson(page, 'life_anim', animArgs(t.manifest));
+        const p0 = await pageNow(page);
+        const play = await evalJson(page, 'life', sampleArgs(t.manifest, LIFE.playMs));
+        const p1 = await pageNow(page);
+        const playSounds = await audioSpan(page, p0, p1);
+        const walked = await walkTravel(t.dir);
+        if (!walked)
+            await new Promise((res) => setTimeout(res, LIFE.travelMs - LIFE.playMs));
+        const animation = await evalJson(page, 'life_anim', { op: 'stop' });
+        const audio = await audioRead(page);
+        const baseline = playSounds ? windowOf(play, null, playSounds, Math.round(p1 - p0) || LIFE.playMs) : windowOf(play, a0, audio, LIFE.playMs);
+        const others = [];
+        if (!opts.view) {
+            for (const v of declared.filter((d) => d.name !== view && !d.moment && !NOT_PLAY.test(d.name)).slice(0, 5)) {
+                await drive(page, { view: v.name, verbs: [], holdMs: 300, freeze: false, click: null });
+                const s = await evalJson(page, 'life', sampleArgs(t.manifest, 1500));
+                others.push({ view: v.name, moving: s && s.engine !== 'none' ? s.moving + s.crowds.length + s.particles.length : null });
+            }
+        }
+        const moments = opts.moment ? [opts.moment] : declared.filter((v) => v.moment).map((v) => v.name).slice(0, 3);
+        const reactions = [];
+        for (const moment of moments) {
+            await armMoments(page);
+            await drive(page, { view: moment, verbs: [], holdMs: 0, freeze: false, click: null });
+            let marks = await drainMoments(page);
+            for (const until = Date.now() + LIFE.markWaitMs; !marks.length && Date.now() < until;) {
+                await new Promise((res) => setTimeout(res, 100));
+                marks = await drainMoments(page);
+            }
+            const heaviest = marks.length ? marks.reduce((b, m) => (m.weight > b.weight ? m : b)) : null;
+            const mark = heaviest?.name ?? null;
+            if (!heaviest) {
+                reactions.push({ moment, mark, reacted: 'not_observed', what: [], after: null });
+                continue;
+            }
+            const sample = await evalJson(page, 'life', sampleArgs(t.manifest, LIFE.afterMs));
+            const markAt = Number(heaviest.t) || (await pageNow(page)) - LIFE.afterMs;
+            const after = windowOf(sample, null, await audioSpan(page, markAt, markAt + LIFE.afterMs), LIFE.afterMs);
+            if (!after || !baseline) {
+                reactions.push({ moment, mark, reacted: 'not_observed', what: [], after });
+                continue;
+            }
+            reactions.push({ moment, mark, ...judgeReaction(baseline, after) });
+        }
+        const bed = audio?.observed ? (audio.loop_starts ?? 0) > 0 : null;
+        const partial = { view, play, audio, bed, baseline, reactions, animation };
+        const still = others.filter((o) => o.moving === 0).map((o) => o.view);
+        const grounded = ground.reads ? groundingChecks(ground).map((c) => ({ level: c.status === 'warn' ? 'warn' : c.status === 'not_observed' ? 'not_observed' : c.status === 'pass' ? 'pass' : 'note', text: c.text, hint: [c.hint, ...(c.items ?? [])].filter(Boolean).join(' · ') || undefined })) : [];
+        const record = { ...partial, contract_people: contractPeople, ...(others.length ? { others } : {}), grounding: ground.observed ? [...ground.things.values()].filter((g) => g.off) : null, findings: [...grounded, ...lifeFindings(partial, { three: isThree(t.manifest), player: playerOf(t.manifest) }), ...lifeVerdicts(animation, { windowMs: animation?.ms ?? null, walk: walked, acted: false, hero: typeof t.manifest.life?.hero === 'string' ? t.manifest.life.hero : null, player: playerOf(t.manifest) }).map((c) => ({ level: c.status === 'warn' ? 'warn' : c.status === 'not_observed' ? 'not_observed' : c.status === 'pass' ? 'pass' : 'note', text: c.text, hint: [c.hint, ...(c.items ?? [])].filter(Boolean).join(' · ') || undefined })), ...(still.length ? [{ level: 'warn', text: `NOTHING MOVES: nothing moves but the player in ${still.join(', ')}: ${still.length === 1 ? 'that view reads' : 'those views read'} as a still`, hint: 'something alive in every play view, not only the first (funpixel-world-and-story, references/atmosphere.md)' }] : [])] };
+        if (t.dir)
+            await recordLife(t.dir, record);
+        return record;
+    });
+    if (typeof r === 'number')
+        return r;
+    const observed = (!!r.play && r.play.engine !== 'none') || !!r.audio?.observed;
+    if (opts.json) {
+        io.log(JSON.stringify(r, null, 2));
+        return observed ? EXIT.pass : EXIT.not_observed;
+    }
+    u.heading(`life · ${r.view ?? 'as loaded'} · ${opts.viewport}`);
+    for (const f of r.findings)
+        u.item(f.level, f.text, f.hint);
+    const warned = r.findings.filter((f) => f.level === 'warn').length;
+    const answered = r.reactions.some((x) => x.reacted === 'yes');
+    const clean = answered ? 'the world moves, sounds and answers' : 'the world moves and sounds; no answer to a big moment was seen';
+    u.summary(observed ? (warned ? 'warn' : 'pass') : 'not_observed', observed ? `${warned ? `${warned} warning(s)` : clean} — a mirror, never a gate` : 'nothing to read: no scene graph and no sound log');
+    return observed ? EXIT.pass : EXIT.not_observed;
+}

package/dist/commands/login.js

@@ -0,0 +1,134 @@
+import { hostname } from 'node:os';
+import { ApiError, apiOptions, sendJson } from "../api/http.js";
+import { authorizeLink, deviceSignIn, mintKey, oauthConfig, realDeps, SignInError } from "../keys/device.js";
+import { apiHost, apiKey, KEY_SHAPE, osStore, saveApiUrl } from "../keys/store.js";
+import { ui } from "../ui.js";
+async function readStdin() {
+    const chunks = [];
+    for await (const c of process.stdin)
+        chunks.push(c);
+    return Buffer.concat(chunks).toString('utf8');
+}
+const NO_STORE = 'no OS credential store here';
+const NO_STORE_NEXT = 'install secret-tool (libsecret), or set FUNPIXEL_API_KEY in the environment';
+export async function login(opts, io = console, store = osStore(), stdin = readStdin) {
+    const u = ui(io, 'login');
+    const key = (opts.key === undefined || opts.key === '-' ? await stdin() : opts.key).trim();
+    if (!KEY_SHAPE.test(key)) {
+        u.error('that is not an API key', 'they start fp_live_ (Settings › Developers, paid plans)');
+        return 3;
+    }
+    if (!store) {
+        u.error(NO_STORE, NO_STORE_NEXT);
+        return 3;
+    }
+    if (opts.api !== undefined) {
+        if (!/^https?:\/\/\S+$/.test(opts.api)) {
+            u.error(`--api ${opts.api}`, 'a plain http(s) address, such as http://localhost:7360');
+            return 3;
+        }
+        saveApiUrl(opts.api);
+    }
+    try {
+        store.set(apiHost(), key);
+    }
+    catch (e) {
+        u.error(`could not store the key: ${e instanceof Error ? e.message : String(e)}`, 'set FUNPIXEL_API_KEY in the environment instead');
+        return 3;
+    }
+    if (process.env.FUNPIXEL_API_KEY)
+        u.item('note', 'FUNPIXEL_API_KEY is set in this environment, and it wins over the stored key');
+    u.summary('pass', `stored the key for ${apiHost()} in ${store.name} (${key.slice(0, 12)}…); gen and publish will use it`);
+    return 0;
+}
+function report(u, e) {
+    const m = e instanceof Error ? e.message : String(e);
+    const at = m.indexOf(' — ');
+    if (at < 0)
+        u.error(m);
+    else
+        u.error(m.slice(0, at), m.slice(at + 3));
+}
+export async function browserLogin(io = console, store = osStore(), deps = realDeps, host = hostname(), scopes) {
+    const u = ui(io, 'login');
+    const cfg = oauthConfig();
+    if (!cfg) {
+        u.error('browser sign-in is off in this funtools (FUNPIXEL_OAUTH_CLIENT_ID=off)', 'make a key in Settings › Developers and run `funtools login --key -` (paste it, then Ctrl-D)');
+        return 3;
+    }
+    if (!store) {
+        u.error(NO_STORE, NO_STORE_NEXT);
+        return 3;
+    }
+    let minted;
+    try {
+        const token = await deviceSignIn(cfg, (p) => {
+            if (cfg.authorizePage) {
+                const link = authorizeLink(cfg.authorizePage, p.userCode, host);
+                const opened = deps.open?.(link) ?? false;
+                u.item('note', `${opened ? 'opened' : 'open'} ${link}`, `check the code reads ${p.userCode}`);
+            }
+            else {
+                u.item('note', `open ${p.complete ?? p.uri}`, p.complete ? `check the code reads ${p.userCode}` : `and enter the code ${p.userCode}`);
+            }
+            u.line('waiting for the browser…');
+        }, deps);
+        minted = await mintKey(token, host, deps, undefined, scopes);
+    }
+    catch (e) {
+        report(u, e);
+        return e instanceof SignInError && e.declined ? 1 : 3;
+    }
+    try {
+        store.set(apiHost(), minted.secret);
+    }
+    catch (e) {
+        u.error(`could not store the key: ${e instanceof Error ? e.message : String(e)}`, 'revoke it in Settings › Developers, then use FUNPIXEL_API_KEY with a key you make there');
+        return 3;
+    }
+    if (process.env.FUNPIXEL_API_KEY)
+        u.item('note', 'FUNPIXEL_API_KEY is set in this environment, and it wins over the stored key');
+    if (minted.scopes.length)
+        u.item('note', `the key may: ${minted.scopes.join(' ')}`);
+    u.summary('pass', `signed in: stored a new key "${minted.name}" for ${apiHost()} in ${store.name} (${minted.secret.slice(0, 12)}…)`);
+    return 0;
+}
+export async function whoami(io = console, store = osStore()) {
+    const u = ui(io, 'whoami');
+    const key = apiKey(store);
+    const api = key ? apiOptions({ key, retries: 1 }) : null;
+    if (!api) {
+        u.error('not signed in', 'run `funtools login` (or `funtools login --key -`)');
+        return 3;
+    }
+    try {
+        const { json: me } = await sendJson(api, 'GET', '/v1/me/key');
+        const from = process.env.FUNPIXEL_API_KEY?.trim() ? 'FUNPIXEL_API_KEY' : store?.name ?? 'the key store';
+        u.item('pass', `${me.username}`, me.plan ? `${me.plan} plan` : undefined);
+        if (me.key)
+            u.item('note', `key "${me.key.name}" (${me.key.display_prefix}…) from ${from}`, me.key.scopes.join(' '));
+        u.summary('pass', `${apiHost()} knows this key as ${me.username}`);
+        return 0;
+    }
+    catch (e) {
+        if (e instanceof ApiError && (e.status === 401 || e.status === 403)) {
+            const next = e.code === 'insufficient_scope' ? 'whoami needs the usage:read scope; `funtools login` makes a key with every scope' : 'run `funtools login` for a new key';
+            u.error(`${apiHost()} refused the key (${e.status} ${e.code}): ${e.message}`, next);
+            return 1;
+        }
+        report(u, e);
+        return 3;
+    }
+}
+export async function logout(io = console, store = osStore()) {
+    const u = ui(io, 'logout');
+    if (!store) {
+        u.error(NO_STORE, NO_STORE_NEXT);
+        return 3;
+    }
+    const removed = store.remove(apiHost());
+    if (process.env.FUNPIXEL_API_KEY)
+        u.item('note', 'FUNPIXEL_API_KEY is still set in this environment');
+    u.summary(removed ? 'pass' : 'skip', removed ? `removed the key for ${apiHost()} from ${store.name}` : `no key stored for ${apiHost()}`);
+    return 0;
+}

package/dist/commands/look-3d.js

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { EXIT } from "./verify.js";
+import { launch, viewportOptions } from "../verify/browser.js";
+import { hookMapOf } from "../verify/hooks.js";
+import { fingerprint } from "../verify/fingerprint.js";
+import { drive, evalJson, load, openTarget } from "../look/look.js";
+import { HERO_WORDS, madeOf } from "../look/made-of.js";
+import { ui } from "../ui.js";
+export const MADE_OF_RECORD = join('.funtools', 'look', '3d.json');
+export function liveLine(g) {
+    const kinds = Object.entries(g.types).sort((a, b) => b[1] - a[1]).slice(0, 4).map(([k, n]) => `${k} ${n}`).join(', ');
+    const parts = [`${g.primitive} primitive${kinds ? `: ${kinds}` : ''}`, g.buffer ? `${g.buffer} buffer` : '', g.skinned ? `${g.skinned} skinned` : '', g.textured ? `${g.textured} textured` : ''].filter(Boolean);
+    const tris = g.tris >= 1000 ? `${(g.tris / 1000).toFixed(1)}K` : String(g.tris);
+    return `${g.name}: ${g.meshes} mesh${g.meshes === 1 ? '' : 'es'} (${parts.join(', ')}), ${tris} triangles, ${Math.round(g.share * 100)}% of the screen`;
+}
+async function readLive(dir, opts, heroes) {
+    if (!existsSync(join(dir, 'dist', 'index.html')))
+        return 'no build (dist/index.html): the source pass only';
+    const t = await openTarget(dir);
+    if (typeof t === 'string')
+        return t;
+    let browser;
+    try {
+        browser = (await launch()).browser;
+        const orientation = typeof t.manifest.metadata?.orientation === 'string' ? t.manifest.metadata.orientation : '';
+        const page = await (await browser.newContext(viewportOptions('phone', orientation))).newPage();
+        await load(page, t.url, hookMapOf(t.manifest));
+        const declared = ((await evalJson(page, 'capture_view', { view: null, verbs: [], verb_gap_ms: 0, hold_ms: 0, freeze: false }))?.views ?? []).map((v) => v.name);
+        const view = opts.view ?? (declared.includes('playing') ? 'playing' : null);
+        const driven = await drive(page, { view, verbs: [], holdMs: 1200, freeze: true, click: opts.click });
+        if (view && driven.view?.entered !== true)
+            return `could not enter the view "${view}"`;
+        const r = await evalJson(page, 'made_of', { heroes, max: 8 });
+        return r ? { ...r, view } : 'the page refused the scene walk';
+    }
+    catch (e) {
+        return `no browser run: ${e instanceof Error ? e.message.split('\n')[0] : String(e)}`;
+    }
+    finally {
+        await browser?.close().catch(() => { });
+        await t.close();
+    }
+}
+function heroPattern(manifest) {
+    const own = ['player', 'threats'].map((k) => manifest?.actors?.[k]).filter((v) => typeof v === 'string' && !!v);
+    return [...own, `(^|[^a-z])(${HERO_WORDS.join('|')})`].join('|');
+}
+export async function look3d(opts, io = console) {
+    const u = ui(io, 'look');
+    const dir = resolve(opts.target ?? '.');
+    if (!existsSync(join(dir, 'src'))) {
+        if (opts.json)
+            io.log(JSON.stringify({ verdict: 'not_observed', says: `no src/ in ${dir}` }, null, 2));
+        else
+            u.summary('not_observed', `no src/ in ${dir}: nothing to read`);
+        return EXIT.not_observed;
+    }
+    let manifest = {};
+    try {
+        manifest = JSON.parse(readFileSync(join(dir, 'funpixel.json'), 'utf8'));
+    }
+    catch { }
+    const m = madeOf(dir, { manifest });
+    const live = opts.static || !m.three ? null : await readLive(dir, opts, heroPattern(manifest));
+    await recordMadeOf(dir, m, live);
+    if (opts.json) {
+        io.log(JSON.stringify({ ...m, live: typeof live === 'string' ? { observed: false, why: live } : live }, null, 2));
+        return EXIT[m.verdict];
+    }
+    report(u, m, live, dir);
+    return EXIT[m.verdict];
+}
+export async function recordMadeOf(dir, m, live = null) {
+    const path = join(dir, MADE_OF_RECORD);
+    await mkdir(dirname(path), { recursive: true }).catch(() => { });
+    const fp = await fingerprint(dir).catch(() => null);
+    const rec = { verdict: m.verdict, says: m.says, heroes: m.heroes.map((h) => h.file), unnamed: m.unnamed, declared: m.declared, live: live && typeof live !== 'string' ? { heroes: live.heroes, totals: live.totals } : null, fingerprint: fp?.fingerprint ?? null, at: new Date().toISOString() };
+    await writeFile(path, JSON.stringify(rec, null, 2) + '\n').catch(() => { });
+}
+function report(u, m, live, dir) {
+    u.heading(`look --3d · ${dir}`);
+    u.line(`source: ${m.reached} of ${m.files} files reached from ${m.entry ?? '(no entry found: every file counted)'}; ${m.totals.primitive_count} primitives, ${m.totals.built} hand-built meshes, ${m.totals.model_files.length} file(s) loading a model`);
+    for (const h of m.heroes)
+        u.item(h.model ? 'pass' : 'fail', h.file, h.model ? `loads a model (${h.model})` : `code: ${Object.entries(h.primitives).sort((a, b) => b[1] - a[1]).map(([k, n]) => `${k} ${n}`).join(', ') || 'no primitives'}${h.built ? `; ${h.built} hand-built` : ''}`);
+    for (const s of m.models)
+        u.item(s.used ? 'note' : 'warn', s.file, `${Math.round(s.bytes / 1024)} KB${s.used ? '' : ', named nowhere in the code the game runs'}`);
+    if (typeof live === 'string')
+        u.item('not_observed', 'live scene', live);
+    else if (live) {
+        if (live.error)
+            u.item('note', 'live scene', live.error);
+        for (const g of live.heroes)
+            u.item(g.primitive > g.buffer ? 'fail' : 'note', `live ${liveLine(g)}`);
+        if (!live.heroes.length)
+            u.item('note', 'live', `no hero node by name in view${live.view ? ` of ${live.view}` : ''}; biggest on screen: ${live.top.slice(0, 3).map(liveLine).join('; ') || 'nothing'}`);
+        if (live.totals)
+            u.line(`in view: ${liveLine({ ...live.totals, name: 'everything' })}`);
+    }
+    if (m.verdict === 'fail') {
+        u.line('next: the hero route (skill funpixel-3d, references/hero-route.md) — concept image, generate_3d_model, bench, judge identity — or declare the style in funpixel.json "art3d" { "heroes": "procedural", "why", "proof" }, and name every stand-in under "art3d.stand_ins"');
+    }
+    u.summary(m.verdict, m.says);
+}

package/dist/commands/look-fit.js

@@ -0,0 +1,116 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { EXIT } from "./verify.js";
+import { launch, lookPage, viewportUrl } from "../verify/browser.js";
+import { hookMapOf } from "../verify/hooks.js";
+import { drive, load, openTarget } from "../look/look.js";
+import { decodePng } from "../look/png.js";
+import { shrink } from "../playtest/sheet.js";
+import { FIT, FIT_VIEWPORTS, fitLine, fitOf, judgeFit, WINDOW_MS } from "../look/fit.js";
+import { playViewOf } from "../playtest/mobile-qa.js";
+import { ui } from "../ui.js";
+async function blankFor(page, url) {
+    const t0 = Date.now();
+    await page.goto(url, { waitUntil: 'commit', timeout: 30_000 }).catch(() => { });
+    while (Date.now() - t0 < FIT.watchMs) {
+        const png = await page.screenshot({ type: 'png', scale: 'css', timeout: 5_000 }).catch(() => null);
+        if (png && !fitOf(shrink(decodePng(png), 320)).blank)
+            return Date.now() - t0;
+        await page.waitForTimeout(FIT.everyMs);
+    }
+    return null;
+}
+const CANVAS_SHARE = `(() => {
+  const W = innerWidth, H = innerHeight; let best = null;
+  for (const c of document.querySelectorAll('canvas')) {
+    const r = c.getBoundingClientRect(), s = getComputedStyle(c);
+    if (s.display === 'none' || s.visibility === 'hidden') continue;
+    const w = Math.max(0, Math.min(r.right, W) - Math.max(r.left, 0)), h = Math.max(0, Math.min(r.bottom, H) - Math.max(r.top, 0));
+    const share = (w * h) / (W * H);
+    if (best === null || share > best) best = share;
+  }
+  return best;
+})()`;
+export async function measureFit(target, opts) {
+    const t = await openTarget(target);
+    if (typeof t === 'string')
+        return t;
+    const out = opts.out ?? (t.dir ? join(t.dir, '.funtools', 'look') : resolve('.funtools', 'look'));
+    await mkdir(out, { recursive: true });
+    const hooks = hookMapOf(t.manifest);
+    let browser;
+    const rows = [];
+    try {
+        browser = (await launch()).browser;
+        for (const vp of opts.viewports ?? FIT_VIEWPORTS) {
+            let context = null;
+            let timer;
+            const one = async () => {
+                let page;
+                if (vp.kind === 'phone') {
+                    page = await lookPage(browser, 'phone', vp.orientation ?? 'portrait');
+                    context = page.context();
+                    await page.setViewportSize({ width: vp.width, height: vp.height });
+                }
+                else {
+                    context = await browser.newContext({ viewport: { width: vp.width, height: vp.height } });
+                    page = await context.newPage();
+                }
+                const url = vp.kind === 'phone' ? viewportUrl(t.url, 'phone') : t.url;
+                const first = await blankFor(page, url);
+                await load(page, url, hooks);
+                const loadedPng = await page.screenshot({ type: 'png', scale: 'css' });
+                const loadedFrame = join(out, `fit-${vp.name}-loaded.png`);
+                await writeFile(loadedFrame, loadedPng);
+                const listed = await drive(page, { view: null, verbs: [], holdMs: 0, freeze: false, click: null });
+                const view = opts.view ?? playViewOf((listed.view?.views ?? []).map((v) => v.name));
+                const driven = view ? await drive(page, { view, verbs: [], holdMs: 600, freeze: true, click: opts.click }) : null;
+                const entered = !!view && driven?.view?.entered === true;
+                const png = entered ? await page.screenshot({ type: 'png', scale: 'css' }) : loadedPng;
+                const frame = join(out, `fit-${vp.name}.png`);
+                await writeFile(frame, png);
+                const canvas = await page.evaluate(CANVAS_SHARE).catch(() => null);
+                return judgeFit({ viewport: vp, view: entered ? view : null, entered, fit: fitOf(decodePng(png)), loaded: fitOf(decodePng(loadedPng)), loaded_frame: loadedFrame, canvas_share: canvas, first_content_ms: first, frame });
+            };
+            const budget = new Promise((done) => { timer = setTimeout(() => done(judgeFit({ viewport: vp, view: null, entered: false, fit: null, canvas_share: null, first_content_ms: null, why: `the window took over ${WINDOW_MS / 1000} s (a heavy page on this machine)` })), WINDOW_MS); });
+            try {
+                const running = one();
+                running.catch(() => { });
+                rows.push(await Promise.race([running, budget]));
+            }
+            catch (e) {
+                rows.push(judgeFit({ viewport: vp, view: null, entered: false, fit: null, canvas_share: null, first_content_ms: null, why: e.message.split('\n')[0].slice(0, 160) }));
+            }
+            finally {
+                clearTimeout(timer);
+                await context?.close().catch(() => { });
+            }
+        }
+    }
+    finally {
+        await browser?.close().catch(() => { });
+        await t.close();
+    }
+    return rows;
+}
+export async function lookFit(opts, io = console) {
+    const u = ui(io, 'look');
+    const rows = await measureFit(opts.target ?? '.', { view: opts.view, click: opts.click, viewports: opts.viewports });
+    if (typeof rows === 'string') {
+        u.error(rows, 'build the game first (npm run build)');
+        return EXIT.error;
+    }
+    const verdict = rows.some((r) => r.verdict === 'fail') ? 'fail' : rows.some((r) => r.verdict === 'pass') ? 'pass' : 'not_observed';
+    if (opts.json) {
+        io.log(JSON.stringify({ verdict, windows: rows }, null, 2));
+        return EXIT[verdict];
+    }
+    u.heading('look --fit · does it fill the window?');
+    for (const r of rows) {
+        u.item(r.verdict, `${r.viewport.name} ${r.viewport.width}x${r.viewport.height}`, fitLine(r).replace(/^[^:]+: /, ''));
+        if (r.frame)
+            u.line(r.frame, 4);
+    }
+    u.summary(verdict, verdict === 'fail' ? 'a window is left mostly empty, barred, bunched or blank too long — look at its frame' : verdict === 'pass' ? 'every window observed is filled' : 'no window could be read');
+    return EXIT[verdict];
+}