@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/verify/probe.js

@@ -0,0 +1,236 @@
+import { pageScript } from '../vendor/verify/src/index.js';
+import { errors } from 'playwright-core';
+import { parseAudioFiles, parseFonts, parseFrontDoor, parseHookMap, parseLevels, parsePlay, parsePreview, parseRenderer, playInputLabel, playInputs, } from "./health.js";
+import { drivenBy, f32, judgeCheckOutcome, judgeSound, mechanicCheckArgs, parseAudio, parseRenderHealth, parseSelfTests, parseSweepRun, renderTrace, seriesSupports, summarizeTrace, sweepInputJson, sweepInputLabel, sweepInputs, } from "./judge.js";
+const SELF_TEST_MAX = 32;
+const SELF_TEST_TIMEOUT_MS = 2000;
+const CANVAS_DEFAULT = { width: 300, height: 150 };
+const SWEEP_MIN_MS = 1000, SWEEP_MAX_MS = 8000, SWEEP_SLOW_FLOOR_MS = 300;
+const PREVIEW_BUDGET_MS = 5000;
+const PLAY = { idle_samples: 10, sample_ms: 100, presses: 6 };
+export const NETWORK_IDLE_MS = 10_000;
+const FONT_TIMEOUT_MS = 3000;
+const AUDIO_FILES = { max: 16, timeout_ms: 3000 };
+const LEVELS = { max: 64, timeout_ms: 2000, budget_ms: 10_000 };
+const RENDERER_FRAMES = 30;
+const FRONT_DOOR = { timeout_ms: 3000, press_ms: 80, settle_ms: 800 };
+const FRESH_SETTLE_MS = 300;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+async function run(page, name, args) {
+    try {
+        return await page.evaluate(`(${pageScript(name, args)})()`);
+    }
+    catch {
+        return null;
+    }
+}
+export const PROBE_SEED = 1;
+async function enterDeclaredView(page) {
+    const r = await run(page, 'enter_view', { seed: PROBE_SEED });
+    return typeof r === 'string' && r.startsWith('ok:') && r.slice(3).trim() ? r.slice(3).trim() : null;
+}
+async function waitForFirstPaint(page) {
+    const r = await run(page, 'first_paint');
+    await sleep(r === null ? 1500 : 150);
+}
+async function readInventory(page) {
+    const r = await run(page, 'inventory');
+    if (typeof r !== 'string' || r.trim() === 'none')
+        return null;
+    try {
+        const v = JSON.parse(r);
+        const strings = (a) => (Array.isArray(a) ? a.filter((x) => typeof x === 'string') : []);
+        return { verbs: strings(v.verbs), fields: strings(v.fields) };
+    }
+    catch {
+        return null;
+    }
+}
+async function runOneCheck(page, c, times, settleMs) {
+    const out = {
+        mechanic: c.mechanic, verb: c.verb, field: c.field, reached: false, reason: '',
+        before: '', after: '', screen_before: '', screen_after: '', driven_by: drivenBy(c),
+        trace_frames: 0, first_moved_frame: -1, max_jump: 0, trace: '', unseen_reason: '',
+        screen_px: -1, upright_ratio: -1, sounds: -1, sound_cues: '',
+    };
+    const text = await run(page, 'mechanic_check', mechanicCheckArgs(c, times, settleMs));
+    if (text === null) {
+        out.reason = 'page evaluate failed';
+        return out;
+    }
+    let v;
+    try {
+        v = JSON.parse(String(text).trim());
+    }
+    catch {
+        out.reason = 'page evaluate returned non-JSON';
+        return out;
+    }
+    out.before = typeof v.before === 'string' ? v.before : '';
+    out.after = typeof v.after === 'string' ? v.after : '';
+    const screen = (k) => (typeof v[k] === 'number' ? String(v[k]) : '');
+    out.screen_before = screen('screen_before');
+    out.screen_after = screen('screen_after');
+    out.sounds = Number.isInteger(v.sounds) ? v.sounds : -1;
+    out.sound_cues = typeof v.sound_cues === 'string' ? v.sound_cues : '';
+    if (v.seen) {
+        const s = v.seen;
+        out.screen_px = Number.isInteger(s.px) ? s.px : -1;
+        const visible = typeof s.visible === 'boolean' ? s.visible : true;
+        const onscreen = typeof s.onscreen === 'boolean' ? s.onscreen : true;
+        out.upright_ratio = f32(typeof s.upright_ratio === 'number' ? s.upright_ratio : -1);
+        const why = typeof s.why === 'string' ? s.why : '';
+        out.unseen_reason = !visible ? (why || 'it is not visible')
+            : !onscreen ? "it is off-screen or outside the camera's near/far planes"
+                : out.screen_px === 0 ? 'it covers 0 px on screen — scaled to nothing, or its mesh is empty'
+                    : '';
+    }
+    let series = [];
+    if (c.trace > 0) {
+        series = Array.isArray(v.series) ? v.series.map((x) => (typeof x === 'number' ? x : null)) : [];
+        if (series.length > 1) {
+            const sum = summarizeTrace(series);
+            out.trace_frames = sum.frames;
+            out.first_moved_frame = sum.firstMoved === null ? -1 : sum.firstMoved;
+            out.max_jump = f32(sum.maxJump);
+            out.trace = renderTrace(series);
+        }
+    }
+    if (v.ok !== true) {
+        out.reason = typeof v.reason === 'string' ? v.reason : 'check failed';
+        return out;
+    }
+    [out.reached, out.reason] = judgeCheckOutcome(c, out.before, out.after, out.screen_before, out.screen_after);
+    if (!out.reached && series.length > 1 && seriesSupports(c.expect, series)) {
+        out.reached = true;
+        out.reason = '';
+    }
+    if (out.unseen_reason) {
+        const subject = c.subject.trim();
+        out.reason = out.reason
+            ? `${out.reason}; and \`${subject}\` CANNOT BE SEEN: ${out.unseen_reason}`
+            : `the control works, but \`${subject}\` CANNOT BE SEEN: ${out.unseen_reason}`;
+        out.reached = false;
+    }
+    const silent = judgeSound(c.sound, out.sounds);
+    if (silent) {
+        out.reason = out.reason ? `${out.reason}; and ${silent}` : silent;
+        out.reached = false;
+    }
+    return out;
+}
+async function botSweep(page, checks, sweepMs, reactionMs) {
+    sweepMs = clamp(sweepMs, SWEEP_MIN_MS, SWEEP_MAX_MS);
+    reactionMs = clamp(reactionMs, 50, 1000);
+    const inputs = sweepInputs(checks);
+    const once = async (react) => parseSweepRun(await run(page, 'bot_sweep', { inputs: inputs.map(sweepInputJson), reaction_ms: react, sweep_ms: sweepMs }));
+    if (await enterDeclaredView(page))
+        await sleep(300);
+    const fast = await once(reactionMs);
+    if (!fast)
+        return null;
+    const slowReactionMs = Math.max(SWEEP_SLOW_FLOOR_MS, reactionMs * 2);
+    let slow = null;
+    if (await enterDeclaredView(page)) {
+        await sleep(300);
+        slow = await once(slowReactionMs);
+    }
+    return {
+        inputs: inputs.map(sweepInputLabel).join(', '),
+        score_field: fast.scoreField,
+        fail_field: fast.failField,
+        reaction_ms: reactionMs,
+        windows: fast.windows,
+        softlock_windows: fast.softlock,
+        step_of_first_score: fast.firstScoreStep,
+        time_to_first_fail_ms: fast.firstFailMs,
+        slow_reaction_ms: slowReactionMs,
+        slow_windows: slow ? slow.windows : 0,
+        slow_softlock_windows: slow ? slow.softlock : 0,
+        slow_time_to_first_fail_ms: slow ? slow.firstFailMs : -1,
+        distinct_states: fast.distinctStates,
+        score_climb_fraction: fast.scoreClimbFraction,
+        slow_distinct_states: slow ? slow.distinctStates : 0,
+        slow_score_climb_fraction: slow ? slow.scoreClimbFraction : f32(-1),
+    };
+}
+async function readAudio(page, driven) {
+    const r = await run(page, 'audio', { op: 'read' });
+    return r === null ? null : parseAudio(r, driven);
+}
+async function playFor(page, checks) {
+    const inputs = playInputs(checks);
+    const play = parsePlay(await run(page, 'play', { op: 'run', ...PLAY, inputs }), inputs.map(playInputLabel).join(', '));
+    if (await enterDeclaredView(page))
+        await sleep(300);
+    return play;
+}
+async function readRenderHealth(page) {
+    const r = await run(page, 'render_health', { default_width: CANVAS_DEFAULT.width, default_height: CANVAS_DEFAULT.height });
+    return r === null ? null : parseRenderHealth(r);
+}
+export async function probe(page, url, { checks = [], settleMs = 600, sweepMs = 3000, reactionMs = 120, hooks = null, fonts = [], loadMs = 30_000, frontDoor = null } = {}) {
+    const late = (e) => { if (!(e instanceof errors.TimeoutError))
+        throw e; };
+    await page.goto(url, { waitUntil: 'load', timeout: loadMs }).catch(late);
+    await page.waitForLoadState('networkidle', { timeout: NETWORK_IDLE_MS }).catch(late);
+    const preview = parsePreview(await run(page, 'preview', { budget_ms: PREVIEW_BUDGET_MS, default_width: CANVAS_DEFAULT.width, default_height: CANVAS_DEFAULT.height }));
+    await waitForFirstPaint(page);
+    const hookMap = hooks ? parseHookMap(await run(page, 'hooks', { map: hooks })) : null;
+    const door = frontDoor?.trim() || null;
+    if (!door)
+        await enterDeclaredView(page);
+    await sleep(clamp(settleMs, 100, 5000));
+    await run(page, 'context_loss_listener');
+    await run(page, 'renderer', { op: 'install' });
+    await run(page, 'audio', { op: 'install' });
+    await run(page, 'play', { op: 'install' });
+    const front_door = door ? parseFrontDoor(await run(page, 'front_door', { selector: door, ...FRONT_DOOR }), door) : null;
+    const play = await playFor(page, checks);
+    const files = async () => ({
+        fonts: parseFonts(await run(page, 'fonts', { planned: fonts, timeout_ms: FONT_TIMEOUT_MS })),
+        audio_files: parseAudioFiles(await run(page, 'audio_files', AUDIO_FILES)),
+    });
+    const readLevels = async () => parseLevels(await run(page, 'levels', LEVELS));
+    const readRenderer = async () => parseRenderer(await run(page, 'renderer', { op: 'read', frames: RENDERER_FRAMES }));
+    const inventory = await readInventory(page);
+    if (!inventory) {
+        const levels = await readLevels();
+        const render_health = await readRenderHealth(page);
+        const renderer = await readRenderer();
+        const { fonts: fontReport, audio_files } = await files();
+        return {
+            instrumented: false, error: '', available_verbs: [], available_fields: [], results: [],
+            self_tests_declared: false, self_tests: [], sweep: null, render_health,
+            audio: null, preview, play, fonts: fontReport, audio_files, levels, hook_map: hookMap, renderer, front_door,
+        };
+    }
+    const results = [];
+    for (const [i, c] of checks.entries()) {
+        if (i > 0 && await enterDeclaredView(page))
+            await sleep(FRESH_SETTLE_MS);
+        results.push(await runOneCheck(page, c, Math.max(1, c.times), settleMs));
+    }
+    const selfTests = parseSelfTests(await run(page, 'self_test', { max: SELF_TEST_MAX, timeout_ms: SELF_TEST_TIMEOUT_MS }));
+    const levels = await readLevels();
+    const sweep = sweepMs === 0 ? null : await botSweep(page, checks, sweepMs, reactionMs);
+    const render_health = await readRenderHealth(page);
+    const renderer = await readRenderer();
+    const audio = await readAudio(page, results.length > 0 || (sweep !== null && sweep.windows > 0));
+    const { fonts: fontReport, audio_files } = await files();
+    return {
+        instrumented: true, error: '', available_verbs: inventory.verbs, available_fields: inventory.fields,
+        results, self_tests_declared: selfTests !== null, self_tests: selfTests ?? [], sweep, render_health, audio,
+        preview, play, fonts: fontReport, audio_files, levels, hook_map: hookMap, renderer, front_door,
+    };
+}
+export function normaliseCheck(c) {
+    const s = (k) => (typeof c[k] === 'string' ? c[k] : '');
+    const n = (k) => { const v = c[k]; return typeof v === 'number' && Number.isInteger(v) && v >= 0 ? v : 0; };
+    return {
+        mechanic: s('mechanic'), verb: s('verb'), field: s('field'), times: n('times'), expect: s('expect'),
+        key: s('key'), pointer: s('pointer'), subject: s('subject'), axis: s('axis'), trace: n('trace'),
+        sound: c.sound === true,
+    };
+}

package/dist/verify/reads.js

@@ -0,0 +1,32 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { stageFiles } from "../stage/stage.js";
+export const STYLESHEET = /\.(css|scss|sass|less|styl)$/i;
+export const sceneReadsFile = (path) => !STYLESHEET.test(path);
+export function sceneReads(root) {
+    const out = {};
+    for (const path of stageFiles(root).included) {
+        if (path === 'verify.json' || !sceneReadsFile(path))
+            continue;
+        out[path] = createHash('sha256').update(readFileSync(join(root, path))).digest('hex').slice(0, 16);
+    }
+    return out;
+}
+export function sameReads(recorded, now) {
+    if (!recorded || typeof recorded !== 'object' || Array.isArray(recorded))
+        return false;
+    const r = recorded;
+    const keys = Object.keys(now);
+    return keys.length === Object.keys(r).length && keys.every((k) => r[k] === now[k]);
+}
+export function readsUnchanged(root, rec, now) {
+    if (!rec?.reads)
+        return false;
+    try {
+        return sameReads(rec.reads, now ?? sceneReads(root));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/verify/run.js

@@ -0,0 +1,56 @@
+import { overallVerdict } from "./judge.js";
+import { probe } from "./probe.js";
+import { engine, glTrouble, launch, viewportOptions, webglAvailable } from "./browser.js";
+import { rendererOf } from "./gpu.js";
+export function browserPool() {
+    const open = {};
+    let chrome = false;
+    return {
+        async get(software) {
+            const k = software ? 'sw' : 'hw';
+            const launched = await (open[k] ??= launch(software));
+            chrome ||= launched.chrome;
+            return launched.browser;
+        },
+        usedChrome: () => chrome,
+        async close() {
+            await Promise.all(Object.values(open).map((b) => b.then((l) => l.browser.close()).catch(() => { })));
+        },
+    };
+}
+export function combineVerdicts(verdicts) {
+    if (verdicts.includes('fail'))
+        return 'fail';
+    if (verdicts.includes('pass'))
+        return 'pass';
+    return 'not_observed';
+}
+async function once(pool, software, url, viewport, opts) {
+    const context = await (await pool.get(software)).newContext(viewportOptions(viewport, opts.orientation));
+    try {
+        const page = await context.newPage();
+        opts.onPage?.(page, viewport);
+        const report = await probe(page, url, { checks: opts.checks, sweepMs: opts.sweepMs, hooks: opts.hooks, fonts: opts.fonts, frontDoor: opts.frontDoor });
+        const webgl = await webglAvailable(page);
+        const renderer = await rendererOf(page);
+        await opts.afterProbe?.(page, viewport, report);
+        return { report, webgl, renderer };
+    }
+    finally {
+        await context.close();
+    }
+}
+export async function runUrl(pool, url, opts) {
+    const runs = [];
+    for (const viewport of opts.viewports) {
+        let { report, webgl, renderer } = await once(pool, false, url, viewport, opts);
+        const trouble = engine() === 'chromium' ? glTrouble(report, webgl) : null;
+        let softwareGl;
+        if (trouble) {
+            ({ report, renderer } = await once(pool, true, url, viewport, opts));
+            softwareGl = trouble;
+        }
+        runs.push({ viewport, verdict: overallVerdict(report), report, renderer, ...(softwareGl ? { softwareGl } : {}) });
+    }
+    return { verdict: combineVerdicts(runs.map((r) => r.verdict)), runs };
+}

package/dist/verify/serve.js

@@ -0,0 +1,36 @@
+import { createServer } from 'node:http';
+import { readFile, stat } from 'node:fs/promises';
+import { extname, join, resolve, sep } from 'node:path';
+export const TYPES = {
+    '.html': 'text/html; charset=utf-8', '.js': 'text/javascript', '.mjs': 'text/javascript',
+    '.css': 'text/css', '.json': 'application/json', '.png': 'image/png', '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.gif': 'image/gif', '.svg': 'image/svg+xml',
+    '.mp3': 'audio/mpeg', '.m4a': 'audio/mp4', '.ogg': 'audio/ogg', '.wav': 'audio/wav',
+    '.glb': 'model/gltf-binary', '.gltf': 'model/gltf+json', '.wasm': 'application/wasm',
+    '.woff2': 'font/woff2', '.ttf': 'font/ttf',
+};
+export async function serveDir(root, extra) {
+    const base = resolve(root);
+    const server = createServer(async (req, res) => {
+        try {
+            if (extra && (await extra(req, res)))
+                return;
+            const path = decodeURIComponent(new URL(req.url ?? '/', 'http://x').pathname);
+            let file = resolve(join(base, path));
+            if (file !== base && !file.startsWith(base + sep))
+                throw new Error('outside root');
+            if ((await stat(file)).isDirectory())
+                file = join(file, 'index.html');
+            const body = await readFile(file);
+            res.writeHead(200, { 'Content-Type': TYPES[extname(file).toLowerCase()] ?? 'application/octet-stream' });
+            res.end(body);
+        }
+        catch {
+            res.writeHead(404);
+            res.end();
+        }
+    });
+    await new Promise((ok) => server.listen(0, '127.0.0.1', ok));
+    const { port } = server.address();
+    return { url: `http://127.0.0.1:${port}/`, close: () => new Promise((ok) => server.close(() => ok())) };
+}

package/dist/walk/film.js

@@ -0,0 +1,37 @@
+import { spawnSync } from 'node:child_process';
+import { renameSync, rmSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { evalJson } from "../look/look.js";
+export const startFilm = async (page, fps = 30, bps = 2_500_000) => (await evalJson(page, 'recorder', { op: 'start', fps, bps })) ?? { ok: false, error: 'the page refused the recorder' };
+export async function stopFilm(page, file) {
+    const stop = await evalJson(page, 'recorder', { op: 'stop' });
+    if (!stop?.ok)
+        return { file: null, bytes: 0, ms: 0, error: stop?.error ?? 'the recorder did not stop' };
+    let b64 = '';
+    for (let off = 0; off < 400_000_000; off += 1_000_000) {
+        const c = await evalJson(page, 'recorder', { op: 'read', offset: off, length: 1_000_000 });
+        if (!c?.ok || !c.data)
+            break;
+        b64 += c.data;
+        if (b64.length >= c.total)
+            break;
+    }
+    await evalJson(page, 'recorder', { op: 'drop' });
+    const bytes = Buffer.from(b64, 'base64');
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, bytes);
+    remux(file);
+    return { file, bytes: bytes.length, ms: stop.ms ?? 0 };
+}
+function remux(file) {
+    const tmp = `${file}.tmp.webm`;
+    const r = spawnSync('ffmpeg', ['-y', '-loglevel', 'error', '-i', file, '-c', 'copy', tmp], { stdio: 'ignore', timeout: 60_000 });
+    try {
+        if (r.status === 0)
+            renameSync(tmp, file);
+        else
+            rmSync(tmp, { force: true });
+    }
+    catch { }
+}