@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/play/steps.js

@@ -0,0 +1,192 @@
+import { expectText, parseExpect } from "./condition.js";
+const POINTER = new Set(['tap', 'drag', 'hold_at', 'look']);
+export const STEP_LIMITS = { perAct: 20, perRound: 200, perRound3d: 400, maxMs: 10_000, untilMs: 10_000, maxUntilMs: 30_000, lookPx: 4000, perLongMinute: 64, maxLongMinutes: 30 };
+export function roundBudget(manifest, longMinutes = 0) {
+    const base = manifest?.metadata?.dimension === '3d' ? STEP_LIMITS.perRound3d : STEP_LIMITS.perRound;
+    return Math.max(base, Math.ceil(longMinutes * STEP_LIMITS.perLongMinute));
+}
+const KEY = /^(?:[A-Za-z0-9]|Space|Enter|Escape|Tab|Backspace|(?:Shift|Control|Alt|Meta)(?:Left|Right)?|Arrow(?:Up|Down|Left|Right)|Key[A-Z]|Digit[0-9]|F[1-9]|F1[0-2])$/;
+const DIRS = { up: 'ArrowUp', down: 'ArrowDown', left: 'ArrowLeft', right: 'ArrowRight' };
+const keyOf = (k) => DIRS[k] ?? (KEY.test(k) ? k : null);
+export const isModifier = (key) => /^(?:Shift|Control|Alt|Meta)(?:Left|Right)?$/.test(key);
+function coord(s) {
+    if (s === undefined || !/^\d+(\.\d+)?$/.test(s))
+        return `"${s ?? ''}" is not a coordinate`;
+    const v = Number(s);
+    const fraction = s.includes('.');
+    if (fraction && v > 1)
+        return `${s}: a fraction runs 0 to 1 (whole numbers are pixels)`;
+    return { v, fraction };
+}
+function ms(s, dflt) {
+    if (s === undefined && dflt !== undefined)
+        return dflt;
+    const n = Number(s);
+    return Number.isInteger(n) && n >= 0 && n <= STEP_LIMITS.maxMs ? n : `"${s ?? ''}" is not milliseconds from 0 to ${STEP_LIMITS.maxMs}`;
+}
+function maxOf(s) {
+    const m = /^(\d+(?:\.\d+)?)(s|ms)?$/.exec(s ?? '');
+    const v = m ? Math.round(Number(m[1]) * (m[2] === 's' ? 1000 : 1)) : NaN;
+    return Number.isFinite(v) && v >= 100 && v <= STEP_LIMITS.maxUntilMs ? v : `max "${s ?? ''}": 100ms to ${STEP_LIMITS.maxUntilMs / 1000}s (4s, 2500ms)`;
+}
+function untilOf(words) {
+    let maxMs = STEP_LIMITS.untilMs;
+    const mi = words.indexOf('max');
+    if (mi >= 0) {
+        if (mi !== words.length - 2)
+            return 'max N comes last: until COND max 4s';
+        const m = maxOf(words[mi + 1]);
+        if (typeof m === 'string')
+            return m;
+        maxMs = m;
+        words = words.slice(0, mi);
+    }
+    if (words[0] === 'change') {
+        if (words.length === 1)
+            return { until: { kind: 'change', box: null }, maxMs };
+        if (words.length !== 5)
+            return 'until change, or until change X1 Y1 X2 Y2 (a box of the screen)';
+        const c = words.slice(1).map(coord);
+        const bad = c.find((v) => typeof v === 'string');
+        return bad ? bad : { until: { kind: 'change', box: c }, maxMs };
+    }
+    const e = words.length === 1 ? parseExpect(words[0]) : null;
+    return e ? { until: { kind: 'state', expect: e }, maxMs } : `until "${words.join(' ')}": a state field (screen!=playing, player.x>120, score>=3) or change [X1 Y1 X2 Y2]`;
+}
+export const untilText = (u) => (u.kind === 'state' ? expectText(u.expect) : u.box ? `change ${u.box.map((c) => c.v).join(' ')}` : 'change');
+export function fixedSteps(s, ms) {
+    const out = [];
+    let left = Math.max(0, Math.round(ms));
+    do {
+        const t = Math.min(left, STEP_LIMITS.maxMs);
+        const h = s.hold;
+        out.push(!h ? `wait ${t}` : h.kind === 'hold_key' ? `hold ${h.key} ${t}` : `hold ${h.x.v} ${h.y.v} ${t}`);
+        left -= t;
+    } while (left > 0);
+    return out;
+}
+export function parseStep(text, phone) {
+    if (text.includes('&')) {
+        const parts = text.split('&').map((t) => parseStep(t, phone));
+        const bad = parts.find((p) => typeof p === 'string');
+        if (bad)
+            return bad;
+        const steps = parts;
+        const err = (m) => `${text.trim()}: ${m}`;
+        if (steps.length < 2 || steps.length > 3)
+            return err('two or three steps join into one gesture');
+        if (steps.some((p) => !POINTER.has(p.kind) && p.kind !== 'hold_key' && p.kind !== 'press'))
+            return err('only tap, drag, hold, press and look join with &');
+        if (!phone && steps.filter((p) => POINTER.has(p.kind)).length > 1)
+            return err('a desktop has one mouse: join keys with one tap, drag or hold');
+        return { kind: 'together', parts: steps };
+    }
+    const [verb, ...a] = text.trim().split(/\s+/);
+    const err = (m) => `${text.trim()}: ${m}`;
+    const noKeys = () => err('a phone has no keyboard — swipe (drag) on the play, or tap or hold the on-screen controls');
+    const ui = a.indexOf('until');
+    if ((verb === 'hold' || verb === 'wait') && ui >= 0) {
+        const u = untilOf(a.slice(ui + 1));
+        if (typeof u === 'string')
+            return err(u);
+        const head = a.slice(0, ui);
+        if (verb === 'wait')
+            return head.length ? err('wait until COND [max N]') : { kind: 'until', hold: null, ...u };
+        if (head.length === 2) {
+            const x = coord(head[0]), y = coord(head[1]);
+            if (typeof x === 'string')
+                return err(x);
+            if (typeof y === 'string')
+                return err(y);
+            return { kind: 'until', hold: { kind: 'hold_at', x, y, ms: 0 }, ...u };
+        }
+        if (head.length !== 1)
+            return err('hold KEY until COND [max N], or hold X Y until COND [max N]');
+        if (phone)
+            return noKeys();
+        const key = keyOf(head[0]);
+        return key ? { kind: 'until', hold: { kind: 'hold_key', key, ms: 0 }, ...u } : err(`unknown key "${head[0]}"`);
+    }
+    switch (verb) {
+        case 'tap': {
+            if (a.length !== 2)
+                return err('tap X Y');
+            const x = coord(a[0]), y = coord(a[1]);
+            return typeof x === 'string' ? err(x) : typeof y === 'string' ? err(y) : { kind: 'tap', x, y };
+        }
+        case 'drag': {
+            if (a.length !== 4 && a.length !== 5)
+                return err('drag X1 Y1 X2 Y2 [ms]');
+            const c = a.slice(0, 4).map(coord);
+            const bad = c.find((v) => typeof v === 'string');
+            if (bad)
+                return err(bad);
+            const t = ms(a[4], 300);
+            if (typeof t === 'string')
+                return err(t);
+            const [x1, y1, x2, y2] = c;
+            return { kind: 'drag', x1, y1, x2, y2, ms: t };
+        }
+        case 'hold': {
+            if (a.length === 3) {
+                const x = coord(a[0]), y = coord(a[1]), t = ms(a[2]);
+                if (typeof x === 'string')
+                    return err(x);
+                if (typeof y === 'string')
+                    return err(y);
+                return typeof t === 'string' ? err(t) : { kind: 'hold_at', x, y, ms: t };
+            }
+            if (a.length !== 2)
+                return err('hold X Y ms, hold KEY ms, or hold KEY until COND [max N]');
+            if (phone)
+                return noKeys();
+            const key = keyOf(a[0]);
+            if (!key)
+                return err(`unknown key "${a[0]}"`);
+            const t = ms(a[1]);
+            return typeof t === 'string' ? err(t) : { kind: 'hold_key', key, ms: t };
+        }
+        case 'press': {
+            if (a.length < 1 || a.length > 2)
+                return err('press KEY [times]');
+            if (phone)
+                return noKeys();
+            const key = keyOf(a[0]);
+            if (!key)
+                return err(`unknown key "${a[0]}"`);
+            const times = a[1] === undefined ? 1 : Number(a[1]);
+            return Number.isInteger(times) && times >= 1 && times <= 20 ? { kind: 'press', key, times } : err('times is 1 to 20');
+        }
+        case 'wait': {
+            const t = ms(a[0]);
+            return a.length !== 1 ? err('wait ms') : typeof t === 'string' ? err(t) : { kind: 'wait', ms: t };
+        }
+        case 'view':
+        case 'verb':
+            return a.length === 1 && /^[\w-]+$/.test(a[0]) ? { kind: verb, name: a[0] } : err(`${verb} NAME`);
+        case 'shot':
+            return a.length ? err('shot takes nothing') : { kind: 'shot' };
+        case 'clip': {
+            const t = ms(a[0]);
+            return a.length !== 1 ? err('clip ms') : typeof t === 'string' ? err(t) : t < 500 ? err('a clip is at least 500 ms') : { kind: 'clip', ms: t };
+        }
+        case 'look':
+        case 'move-mouse': {
+            if (phone)
+                return err('a phone has no mouse — look around by dragging on the play');
+            if (a.length !== 2 && a.length !== 3)
+                return err(`${verb} DX DY [ms] (pixels the mouse moves, no button down)`);
+            const [dx, dy] = a.slice(0, 2).map((v) => (/^-?\d+$/.test(v) ? Number(v) : NaN));
+            if (![dx, dy].every((v) => Number.isInteger(v) && Math.abs(v) <= STEP_LIMITS.lookPx))
+                return err(`DX and DY are whole pixels from -${STEP_LIMITS.lookPx} to ${STEP_LIMITS.lookPx}`);
+            const t = ms(a[2], 200);
+            return typeof t === 'string' ? err(t) : { kind: 'look', dx, dy, ms: t };
+        }
+        default:
+            return err('steps are tap, drag, hold, press, wait, look, view, verb, shot, clip (and hold … until, wait until)');
+    }
+}
+export const px = (c, size) => (c.fraction ? Math.round(c.v * size) : c.v);
+export function holdFrameTimes(ms) {
+    return [300, 600, 1000].filter((k) => k <= ms - 100);
+}

package/dist/playable/build.js

@@ -0,0 +1,90 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { extname, join, posix } from 'node:path';
+import { gameVite } from "../commands/dev.js";
+import { TYPES } from "../verify/serve.js";
+function walk(root, rel = '', out = []) {
+    for (const e of readdirSync(join(root, rel), { withFileTypes: true })) {
+        const child = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory()) {
+            if (!['node_modules', '.git', 'dist-playable'].includes(e.name))
+                walk(root, child, out);
+        }
+        else if (e.isFile())
+            out.push(child);
+    }
+    return out;
+}
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const dataUri = (root, path) => `data:${TYPES[extname(path).toLowerCase()] ?? 'application/octet-stream'};base64,${readFileSync(join(root, path)).toString('base64')}`;
+function local(root, from, ref) {
+    if (/^(data:|blob:|#|[a-z][\w+.-]*:|\/\/)/i.test(ref))
+        return null;
+    const clean = ref.split(/[?#]/)[0];
+    const path = clean.startsWith('/') ? clean.slice(1) : posix.normalize(posix.join(posix.dirname(from), clean));
+    return path && !path.startsWith('..') && existsSync(join(root, path)) ? path : null;
+}
+export function inline(root, entry) {
+    const inlined = new Set();
+    let html = readFileSync(join(root, entry), 'utf8');
+    html = html.replace(/<link\b[^>]*\brel=["']modulepreload["'][^>]*>\s*/gi, '');
+    html = html.replace(/<script\b([^>]*?)\s+src=["']([^"']+)["']([^>]*)>\s*<\/script>/gi, (m, pre, src, post) => {
+        const p = local(root, entry, src);
+        if (!p)
+            return m;
+        inlined.add(p);
+        const attrs = `${pre}${post}`.replace(/\s+crossorigin(=["'][^"']*["'])?/gi, '');
+        return `<script${attrs}>${readFileSync(join(root, p), 'utf8').replace(/<\/script/gi, '<\\/script')}</script>`;
+    });
+    html = html.replace(/<link\b[^>]*\brel=["']stylesheet["'][^>]*>/gi, (m) => {
+        const href = m.match(/\bhref=["']([^"']+)["']/i)?.[1];
+        const p = href ? local(root, entry, href) : null;
+        if (!p)
+            return m;
+        inlined.add(p);
+        return `<style>${readFileSync(join(root, p), 'utf8')}</style>`;
+    });
+    const files = walk(root).filter((p) => p !== entry && !inlined.has(p) && !/\.(html|map)$/i.test(p));
+    for (const p of files.sort((a, b) => b.length - a.length)) {
+        const re = new RegExp(`(["'\`(=])(?:\\./|/)?${escapeRe(p)}(?=["'\`)\\s>])`, 'g');
+        if (!re.test(html))
+            continue;
+        const uri = dataUri(root, p);
+        html = html.replace(re, (_m, q) => `${q}${uri}`);
+        inlined.add(p);
+    }
+    return { html, inlined: [...inlined].sort() };
+}
+export async function buildPlayable(dir) {
+    const out = join(dir, 'dist-playable');
+    const entry = existsSync(join(dir, 'playable.html')) ? 'playable.html' : 'index.html';
+    let root = dir;
+    let built = null;
+    if (existsSync(join(dir, 'package.json'))) {
+        const vite = await gameVite(dir);
+        if (!vite)
+            throw new Error(`vite is not installed in ${dir} — run npm install first`);
+        built = join(out, '.build');
+        const own = ['vite.playable.config.ts', 'vite.playable.config.js'].find((f) => existsSync(join(dir, f)));
+        await vite.build({
+            root: dir,
+            ...(own ? { configFile: join(dir, own) } : {}),
+            logLevel: 'error',
+            build: {
+                outDir: built, emptyOutDir: true, copyPublicDir: true,
+                assetsInlineLimit: Number.MAX_SAFE_INTEGER, cssCodeSplit: false, modulePreload: false,
+                rollupOptions: { input: join(dir, entry), output: { inlineDynamicImports: true } },
+            },
+        });
+        root = built;
+    }
+    else if (!existsSync(join(dir, entry))) {
+        throw new Error(`no ${entry} in ${dir} — this is not a game folder`);
+    }
+    const { html, inlined } = inline(root, entry);
+    mkdirSync(out, { recursive: true });
+    const file = join(out, 'index.html');
+    writeFileSync(file, html);
+    if (built)
+        rmSync(built, { recursive: true, force: true });
+    return { file, html, entry, inlined };
+}

package/dist/playable/cta.js

@@ -0,0 +1,88 @@
+import { launch } from "../verify/browser.js";
+import { serveDir } from "../verify/serve.js";
+const VIEW = { width: 390, height: 844 };
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function score(page) {
+    return page.evaluate(`(() => { try { const s = window.__FPX_STATE__?.(); if (!s || typeof s !== 'object') return null;
+    const o = {}; for (const [k, v] of Object.entries(s)) if (typeof v === 'number' && isFinite(v)) o[k] = v; return o; } catch { return null; } })()`);
+}
+const rose = (a, b) => Object.keys(b).some((k) => k in a && b[k] > a[k]);
+export async function checkCta(dir, net, timing = { settleMs: 1500, playMs: 9000, stepMs: 600 }) {
+    const served = await serveDir(dir);
+    const { browser } = await launch();
+    const r = { steps: [], requests: [], calls: [], rewardAt: null, firstTouchAt: null };
+    const step = (what, verdict, reason = '') => r.steps.push({ what, verdict, reason });
+    try {
+        const context = await browser.newContext({ viewport: VIEW, deviceScaleFactor: 2, isMobile: true, hasTouch: true });
+        const page = await context.newPage();
+        const start = Date.now();
+        const now = () => Date.now() - start;
+        await context.route('**/*', (route) => {
+            const url = route.request().url();
+            if (url === served.url || url === `${served.url}index.html`)
+                return route.continue();
+            if (!net.sanctioned?.test(url))
+                r.requests.push(url);
+            return route.abort();
+        });
+        await page.exposeFunction('__fpxCta', (via) => { r.calls.push({ via, t: now() }); });
+        await page.addInitScript(`${net.stub}
+      window.open = () => { __fpxCta('window.open'); return null; };`);
+        await page.goto(served.url, { waitUntil: 'load' });
+        await sleep(timing.settleMs);
+        const before = r.calls.length;
+        step('no call to action before the first touch', before ? 'fail' : 'pass', before ? `${r.calls[0].via} fired at ${r.calls[0].t} ms with no touch — an automatic store redirect` : '');
+        const base = await score(page);
+        const verbs = (await page.evaluate(`Object.keys(window.__FPX_VERBS__ ?? {})`).catch(() => []));
+        const middle = () => page.touchscreen.tap(VIEW.width / 2, VIEW.height / 2);
+        r.firstTouchAt = now();
+        await middle();
+        await sleep(timing.stepMs);
+        const onFirst = r.calls.length > before;
+        step('no call to action on the first tap', onFirst ? 'fail' : 'pass', onFirst ? 'the first tap opened the store — networks refuse that' : '');
+        for (let t = 0; t < timing.playMs && r.rewardAt === null; t += timing.stepMs) {
+            if (verbs.length)
+                await page.evaluate(`(() => { for (const v of Object.values(window.__FPX_VERBS__)) try { v(); } catch {} })()`);
+            else
+                await middle();
+            await sleep(timing.stepMs);
+            const s = base && (await score(page));
+            if (base && s && rose(base, s))
+                r.rewardAt = now();
+        }
+        const tapped = r.calls.length;
+        for (let i = 0; i < 4 && r.calls.length === tapped; i++) {
+            await page.touchscreen.tap(VIEW.width / 2, VIEW.height * (0.72 + 0.06 * i));
+            await sleep(400);
+        }
+        await sleep(800);
+        const wrong = r.calls.filter((c) => c.via === 'window.open');
+        const right = r.calls.filter((c) => c.via !== 'window.open');
+        if (wrong.length)
+            step(`the call to action is ${net.cta}`, 'fail', `it called window.open — the wrapper found no ${net.cta.split('(')[0]} and fell back to the local preview`);
+        else if (!right.length)
+            step(`the call to action fires (${net.cta})`, 'fail', 'tapping the end card fired nothing');
+        else if (right.length > 1)
+            step('the call to action fires once', 'fail', `${right.length} calls to ${right[0].via} for one tap`);
+        else
+            step(`the call to action fires (${right[0].via})`, 'pass');
+        const first = right[0];
+        if (!first)
+            step('after the reward', 'not_observed', 'the call to action never fired');
+        else if (base === null)
+            step('after the reward', 'not_observed', 'no __FPX_STATE__ number to see the reward by — expose the score');
+        else if (r.rewardAt === null)
+            step('after the reward', 'fail', `no number in __FPX_STATE__ rose in ${Math.round(timing.playMs / 1000)} s of play before the call to action`);
+        else if (first.t < r.rewardAt)
+            step('after the reward', 'fail', `it fired at ${first.t} ms, before the reward at ${r.rewardAt} ms`);
+        else
+            step('after the reward', 'pass', `reward at ${r.rewardAt} ms, call to action at ${first.t} ms`);
+        step('nothing loaded from the network', r.requests.length ? 'fail' : 'pass', r.requests.length ? r.requests.slice(0, 3).join(', ') : '');
+        await context.close();
+    }
+    finally {
+        await browser.close();
+        await served.close();
+    }
+    return r;
+}

package/dist/playable/networks.js

@@ -0,0 +1,33 @@
+const MB = 1_000_000;
+const MRAID = `window.mraid = { getState: () => 'default', isViewable: () => true, getVersion: () => '3.0',
+  addEventListener: (e, f) => { if (e === 'ready' || e === 'viewableChange') setTimeout(() => f(true), 0); },
+  removeEventListener() {}, open: (u) => __fpxCta('mraid.open'), close() {}, useCustomClose() {} };`;
+export const NETWORKS = {
+    applovin: { name: 'AppLovin', ceiling: 5 * MB, cta: 'mraid.open(url)', stub: MRAID },
+    unity: { name: 'Unity Ads', ceiling: 5 * MB, cta: 'mraid.open(url)', stub: MRAID },
+    ironsource: { name: 'ironSource', ceiling: 5 * MB, note: 'build to 4 MB for the ironSource Exchange', cta: 'mraid.open(url)', stub: MRAID },
+    mintegral: {
+        name: 'Mintegral', ceiling: 5 * MB, cta: 'window.install()',
+        stub: `window.install = () => __fpxCta('install'); window.gameEnd = () => {};`,
+    },
+    google: {
+        name: 'Google Ads', ceiling: 5 * MB, cta: 'ExitApi.exit()',
+        stub: `window.ExitApi = { exit: () => __fpxCta('ExitApi.exit') };`,
+        sanctioned: /^https:\/\/(tpc\.googlesyndication\.com|s0\.2mdn\.net|fonts\.googleapis\.com|fonts\.gstatic\.com|ajax\.googleapis\.com)\//,
+        requires: [
+            { test: /<meta[^>]+name=["']ad\.orientation["']/i, what: 'a <meta name="ad.orientation"> in the head' },
+            { test: /<script[^>]+src=["'][^"']*exitapi\.js["']/i, what: "Google's exitapi.js script in the head" },
+        ],
+    },
+    meta: {
+        name: 'Meta', ceiling: 2 * MB, cta: 'FbPlayableAd.onCTAClick()', noMraid: true,
+        stub: `window.FbPlayableAd = { onCTAClick: () => __fpxCta('FbPlayableAd.onCTAClick') };`,
+    },
+    tiktok: {
+        name: 'TikTok Ad Network', ceiling: 5 * MB, cta: 'window.openAppStore()', noMraid: true,
+        stub: `window.openAppStore = () => __fpxCta('openAppStore');`,
+        sanctioned: /^https:\/\/[^/]+\/.*playable-sdk[^/]*\.js$/,
+    },
+};
+export const NETWORK_IDS = Object.keys(NETWORKS);
+export const SPARE = 0.1;

package/dist/playable/scan.js

@@ -0,0 +1,46 @@
+const ASSET_EXT = 'png|jpe?g|webp|gif|svg|mp3|ogg|wav|m4a|glb|gltf|bin|atlas|fnt|woff2?|ttf|otf';
+const XMLNS = /^https?:\/\/www\.w3\.org\//;
+const FILE_PATH = /^(\.{0,2}\/)?([\w@-][\w.@-]*\/)*[\w@-][\w.@-]*\.[a-z0-9]{2,5}([?#].*)?$/i;
+const uniq = (xs) => [...new Set(xs)];
+const short = (s) => (s.length > 90 ? `${s.slice(0, 87)}…` : s);
+export function scanPlayable(html, net) {
+    const fails = [];
+    const notes = [];
+    const allowed = (url) => !!net.sanctioned?.test(url);
+    for (const [, attr, url] of html.matchAll(/\b(src|href)\s*=\s*["']((?:https?:)?\/\/[^"']+)["']/gi)) {
+        if (!allowed(url) && !XMLNS.test(url))
+            fails.push(`${attr}="${short(url)}" loads from the network`);
+    }
+    for (const [, url] of html.matchAll(/url\(\s*["']?((?:https?:)?\/\/[^"')]+)/gi)) {
+        if (!allowed(url))
+            fails.push(`url(${short(url)}) loads from the network`);
+    }
+    for (const [, attr, ref] of html.matchAll(/\b(src|href)\s*=\s*["'](?!data:|blob:|#|javascript:|mailto:|tel:|https?:|\/\/)([^"']+)["']/gi)) {
+        if (FILE_PATH.test(ref))
+            fails.push(`${attr}="${short(ref)}" names a file the playable does not carry`);
+    }
+    for (const [, ref] of html.matchAll(/url\(\s*["']?([^"')\s]+)/g)) {
+        if (!/^(data:|blob:|#|https?:|\/\/)/.test(ref) && FILE_PATH.test(ref))
+            fails.push(`url(${short(ref)}) names a file the playable does not carry`);
+    }
+    for (const [lit] of html.matchAll(new RegExp(`(?<!=\\s*)["'\`](?:\\.{0,2}/)?(?:[\\w-]+/)+[\\w-][\\w.-]*\\.(?:${ASSET_EXT})["'\`]`, 'gi'))) {
+        fails.push(`${short(lit)} is loaded by path — import it so the build inlines it`);
+    }
+    for (const [call] of html.matchAll(/\b(?:fetch|import|WebSocket|EventSource|sendBeacon)\s*\(\s*["'`](?:https?|wss?):\/\/[^"'`]+/g)) {
+        fails.push(`${short(call)} reaches the network at runtime`);
+    }
+    if (net.noMraid && /mraid\.js/i.test(html))
+        fails.push(`mraid.js — ${net.name} refuses it`);
+    if (net.name === 'ironSource') {
+        const plain = uniq([...html.matchAll(/http:\/\/[^\s"'`<>)]+/g)].map((m) => m[0]).filter((u) => !XMLNS.test(u)));
+        for (const u of plain)
+            fails.push(`${short(u)} — ironSource refuses plain http:// links`);
+    }
+    for (const r of net.requires ?? [])
+        if (!r.test.test(html))
+            fails.push(`${net.name} needs ${r.what}`);
+    const bare = uniq([...html.matchAll(/https?:\/\/[^\s"'`<>)\\]+/g)].map((m) => m[0]).filter((u) => !XMLNS.test(u) && !allowed(u)));
+    if (bare.length)
+        notes.push(`${bare.length} URL string(s) in the code (${bare.slice(0, 3).map(short).join(', ')}${bare.length > 3 ? ', …' : ''}) — a store link is fine; one the game fetches blanks the ad`);
+    return { fails: uniq(fails), notes };
+}

package/dist/playtest/after-round.js

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { film, PLAYTEST_DIR, playtests, prepareFidelity } from "./prepare.js";
+import { recordRoute } from "./route.js";
+import { blockersOf, ledgerPrompt } from "./ledger.js";
+import { playFacts } from "./mockups.js";
+import { carried, readKeep } from "./keep.js";
+const readJson = (f) => { try {
+    return JSON.parse(readFileSync(f, 'utf8'));
+}
+catch {
+    return null;
+} };
+export async function afterRound(root, plan, dir, manifest, round, note) {
+    const notes = [], prompts = [];
+    let next = plan;
+    if (round) {
+        const r = await recordRoute(root);
+        notes.push(typeof r === 'string' ? `route: ${r}` : `route: ${r.recorded ? `kept at ${r.file}; ` : ''}${r.note}`);
+    }
+    const measures = readJson(join(dir, 'measures.json'));
+    const owed = plan.fidelity?.seat ? !existsSync(join(dir, 'fidelity', 'fidelity.json')) : true;
+    if (!plan.route?.filmed && owed && measures?.build.ok) {
+        const f = await film(root, dir, note);
+        if (f.film) {
+            const previous = playtests(root).filter((x) => x < plan.n).at(-1);
+            const fidelity = await prepareFidelity(root, dir, measures, typeof manifest.metadata?.orientation === 'string' ? manifest.metadata.orientation : 'portrait', {
+                facts: existsSync(join(dir, 'frames', 'facts.md')) ? readFileSync(join(dir, 'frames', 'facts.md'), 'utf8') : '',
+                artStyle: typeof manifest.metadata?.artStyle === 'string' ? manifest.metadata.artStyle : undefined,
+                previous: previous ? join(root, PLAYTEST_DIR, String(previous)) : undefined, film: f.film,
+            });
+            next = { ...plan, route: f.route, fidelity: { ...fidelity, ...(plan.fidelity?.ui ? { ui: plan.fidelity.ui } : {}) } };
+            await writeFile(join(dir, 'plan.json'), JSON.stringify(next, null, 2) + '\n');
+            notes.push(`film: the route replayed (run ${f.film.run}); ${f.film.moments.filter((m) => m.frame).length} of ${f.film.moments.length} timed moment(s) shot${f.film.void ? `; VOID: ${f.film.void}` : ''}`);
+            if (fidelity.seat)
+                prompts.push(fidelity.seat);
+        }
+        else
+            notes.push(`film: ${f.route.why}`);
+    }
+    const previous = playtests(root).filter((x) => x < plan.n).at(-1);
+    const before = previous !== undefined ? readJson(join(root, PLAYTEST_DIR, String(previous), 'report.json')) : null;
+    const blockers = blockersOf(before);
+    const keep = carried(readKeep(root));
+    if ((blockers.length || keep.length) && !existsSync(join(dir, 'ledger', 'ledger.json'))) {
+        await mkdir(join(dir, 'ledger'), { recursive: true });
+        const filmed = next.route?.moments?.flatMap((m) => (m.frame ? [m.frame] : [])) ?? [];
+        const frames = [...filmed, ...next.frames.filter((f) => !f.startsWith('clip-')).slice(0, 12).map((f) => join(dir, 'frames', f))];
+        const file = join(dir, 'ledger', 'ledger.md');
+        await writeFile(file, ledgerPrompt(blockers, {
+            play: playFacts(round ? readJson(join(round.dir, 'report.json')) : null),
+            facts: existsSync(join(dir, 'frames', 'facts.md')) ? readFileSync(join(dir, 'frames', 'facts.md'), 'utf8') : '',
+            frames, framesDir: join(dir, 'frames'),
+        }, join(dir, 'ledger', 'ledger.json'), keep));
+        prompts.push(file);
+        notes.push(`ledger: ${[blockers.length ? `${blockers.length} blocker(s) from playtest ${before.n}` : '', keep.length ? `${keep.length} thing(s) that already worked (do not regress)` : ''].filter(Boolean).join(' and ')} to judge against this round`);
+    }
+    return { notes, prompts, plan: next };
+}