@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/commands/play.js

@@ -0,0 +1,368 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { appendFile, readFile, rename, writeFile } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { EXIT } from "./verify.js";
+import { criteriaOf, criteriaText } from "../criteria.js";
+import { fingerprint } from "../verify/fingerprint.js";
+import { assemble, blocked, CRITERION_SHAPE, DEFECT_SHAPE } from "../play/report.js";
+import { gameSeconds } from "../depth/pacing.js";
+import { ancestors, call, claimRound, closedPath, closedUnfiled, DEFAULT_ROUNDS, helperOutsideRound, openSessions, pickSession, playRoot, roundDir, roundsAll, roundsFiled, startServer } from "../play/session.js";
+import { STEP_LIMITS } from "../play/steps.js";
+import { ui } from "../ui.js";
+import { NO_RENDERER, timingVoid } from "../verify/gpu.js";
+import { autoLog } from "../feedback/auto.js";
+export const PLAY_SUBCOMMANDS = ['act', 'look', 'note', 'check', 'report', 'end', 'status'];
+const isUrl = (t) => /^https?:\/\//.test(t);
+function gameCriteria(root) {
+    try {
+        return criteriaOf(JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8'))).criteria;
+    }
+    catch {
+        return [];
+    }
+}
+async function readLog(root, round) {
+    try {
+        return (await readFile(join(roundDir(root, round), 'log.jsonl'), 'utf8')).split('\n').filter(Boolean).map((l) => JSON.parse(l));
+    }
+    catch {
+        return [];
+    }
+}
+async function picked(u, root, round, procs) {
+    const p = await pickSession(root, round);
+    if (!('session' in p)) {
+        u.error(p.error, p.hint);
+        return null;
+    }
+    if (!helperRefused(u, root, p.session.round, procs))
+        return p.session;
+    return null;
+}
+function helperRefused(u, root, round, procs) {
+    const helper = helperOutsideRound(procs ?? ancestors(), root, round);
+    if (!helper)
+        return false;
+    u.error(`refused: this command ran from ${helper}, a helper outside round ${round}'s folder — another round's player can overwrite it, and its steps would land in the wrong round`, `keep helpers and scratch files in your own round's folder: ${roundDir(root, round)}/ (copy it there, then run it from there)`);
+    return true;
+}
+export async function play(opts, io = console) {
+    const u = ui(io, 'play');
+    const target = opts.sub === 'open' ? opts.args[0] ?? '.' : '.';
+    const root = opts.dir ? resolve(opts.dir) : opts.sub === 'open' ? resolve(isUrl(target) ? '.' : target) : playRoot('.');
+    switch (opts.sub) {
+        case 'open': return open(u, io, opts, target, root);
+        case 'act': {
+            const s = await picked(u, root, opts.round, opts.procs);
+            if (!s)
+                return EXIT.error;
+            if (!opts.args.length) {
+                u.error('no steps', `funtools play act "tap 0.5 0.8" "wait 500" (up to ${STEP_LIMITS.perAct})`);
+                return EXIT.error;
+            }
+            const r = await call(s, '/act', { steps: opts.args, look: !!opts.look });
+            if (r.error) {
+                u.error(r.error, r.browser_lost ? 'funtools play end, then funtools play . to retry' : 'write the report: funtools play report <file.json>');
+                return EXIT.error;
+            }
+            if (opts.json) {
+                io.log(JSON.stringify(r, null, 2));
+                return EXIT.pass;
+            }
+            for (const x of r.results)
+                u.item(x.ok ? 'pass' : 'fail', `${x.n}. ${x.step}`, x.error ?? (x.until ? untilSaid(x.until) : undefined));
+            if (r.page_errors)
+                u.item('note', `the page reported ${r.page_errors} error(s)`, r.first_error);
+            for (const extra of r.shots ?? [])
+                u.line(`shot ${extra}`);
+            for (const held of r.held_frames ?? [])
+                u.line(`held ${held}`);
+            for (const clip of r.clips ?? [])
+                u.line(`clip ${clip} (real time)`);
+            if (r.look) {
+                u.line(`look ${r.look} (${r.size}; the full-size screen is ${r.shot})`);
+                u.line(`state ${r.state}`);
+            }
+            else
+                u.line(`screen ${r.shot}`);
+            u.line(`${r.left} steps left this round`);
+            if (s.long_minutes)
+                u.line(`${mmss(gameSeconds(await readLog(root, s.round), s.viewport === 'phone'))} of game time played of the long session's ${s.long_minutes}:00`);
+            return EXIT.pass;
+        }
+        case 'look': {
+            const s = await picked(u, root, opts.round, opts.procs);
+            if (!s)
+                return EXIT.error;
+            const r = await call(s, '/look');
+            if (r.error) {
+                u.error(r.error, 'funtools play end, then funtools play . to retry');
+                return EXIT.error;
+            }
+            if (opts.json) {
+                io.log(JSON.stringify(r, null, 2));
+                return EXIT.pass;
+            }
+            u.line(`look ${r.look} (${r.size}, at step ${r.step}; no game time passed)`);
+            u.line(`state ${r.state}`);
+            u.line(`${r.left} steps left this round`);
+            return EXIT.pass;
+        }
+        case 'note': {
+            const s = await picked(u, root, opts.round, opts.procs);
+            if (!s)
+                return EXIT.error;
+            const text = opts.args.join(' ').trim();
+            if (!text) {
+                u.error('no note', 'funtools play note "step 12: the beetle walked in alone, tagged NEW"');
+                return EXIT.error;
+            }
+            const log = await readLog(root, s.round);
+            const step = log.reduce((m, l) => Math.max(m, typeof l.n === 'number' ? l.n : 0), 0);
+            const file = join(roundDir(root, s.round), 'notes.md');
+            await appendFile(file, `- step ${step}: ${text.replace(/\s+/g, ' ').slice(0, 600)}\n`);
+            if (opts.json)
+                io.log(JSON.stringify({ step, file }, null, 2));
+            else
+                u.line(`noted at step ${step} → ${file}`);
+            return EXIT.pass;
+        }
+        case 'check': return report(u, io, opts, root, true);
+        case 'report': return report(u, io, opts, root, false);
+        case 'end': {
+            const s = await picked(u, root, opts.round, opts.procs);
+            if (!s)
+                return EXIT.error;
+            const r = await call(s, '/end');
+            if (opts.json) {
+                io.log(JSON.stringify({ round: s.round, ended: true, steps: r.steps }, null, 2));
+                return EXIT.pass;
+            }
+            u.summary('pass', `round ${s.round} closed after ${r.steps} step(s), no report filed`);
+            return EXIT.pass;
+        }
+        case 'status': {
+            const filed = roundsFiled(root);
+            const open = await openSessions(root);
+            const last = filed.length ? JSON.parse(readFileSync(join(roundDir(root, filed.at(-1)), 'report.json'), 'utf8')) : null;
+            if (opts.json) {
+                io.log(JSON.stringify({ filed, open: open.map((s) => ({ round: s.round, viewport: s.viewport })), last }, null, 2));
+                return EXIT.pass;
+            }
+            u.heading(`play · ${root}`);
+            u.item('note', `${filed.length} round(s) filed${open.map((s) => `; round ${s.round} is open (${s.viewport})`).join('')}`);
+            if (last)
+                u.item(last.blocked ? 'fail' : 'pass', `round ${last.round}: ${summaryLine(last)}`);
+            return EXIT.pass;
+        }
+    }
+}
+function reportOf(root, round) {
+    try {
+        return JSON.parse(readFileSync(join(roundDir(root, round), 'report.json'), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function open(u, io, opts, target, root) {
+    const already = (await openSessions(root)).length;
+    const filed = roundsFiled(root);
+    const current = isUrl(target) ? undefined : (await fingerprint(root).catch(() => null))?.fingerprint;
+    const thisBuild = current ? filed.filter((r) => reportOf(root, r)?.fingerprint === current) : filed;
+    if (thisBuild.length + already >= opts.rounds) {
+        u.error(`${thisBuild.length} round(s) already filed on this build${already ? ` and ${already} open` : ''} (the cap is ${opts.rounds})`, `review the open findings before continuing; for an authorized new fix round, use --rounds ${thisBuild.length + already + 1} (keeps the earlier evidence)`);
+        return EXIT.fail;
+    }
+    const round = await claimRound(root);
+    const s = await startServer({ target: isUrl(target) ? target : resolve(target), root, round, viewport: opts.viewport, orientation: opts.orientation, ...(opts.long ? { long_minutes: opts.long } : {}) });
+    const criteria = gameCriteria(root);
+    const shot = join(roundDir(root, round), '000.png');
+    const timing = timingVoid(s.renderer ?? NO_RENDERER);
+    const addr = `--round ${round}${resolve('.') === root ? '' : ` --dir ${root}`}`;
+    if (opts.json) {
+        io.log(JSON.stringify({ round, address: addr, round_dir: roundDir(root, round), rounds: opts.rounds, this_build: thisBuild.length + 1, viewport: `${s.width}x${s.height}`, input: s.viewport === 'phone' ? 'touch' : 'mouse and keys', views: s.views, verbs: s.verbs, criteria, shot, renderer: s.renderer ?? NO_RENDERER, ...(timing ? { timing_void: timing } : {}) }, null, 2));
+        return EXIT.pass;
+    }
+    u.heading(`play · round ${round} (${thisBuild.length + 1} of ${opts.rounds} on this build) · ${s.viewport} ${s.width}x${s.height} (${s.viewport === 'phone' ? 'touch: tap, drag, hold' : 'mouse and keys'})`);
+    if (timing)
+        u.item('not_observed', `VOID pace: ${timing}; judge what you see, never how smooth or fast it moves`);
+    u.item('note', `views: ${s.views.join(', ') || 'none declared'}`, s.views.length ? '"view NAME" jumps there — a jump, not play; say so in the report' : undefined);
+    u.item('note', s.verbs.length ? `verbs: ${s.verbs.join(', ')}` : 'verbs: none declared', s.verbs.length ? '"verb NAME" presses the game\'s own action when no input of yours reaches it' : undefined);
+    u.item('note', criteria.length ? `criteria to judge from the screen:\n${criteriaText(criteria)}` : 'criteria: none declared in funpixel.json');
+    u.item('note', 'the game runs only while an act plays and is held between acts; "wait ms" lets it run');
+    if (s.long_minutes)
+        u.item('note', `a long session: play about ${s.long_minutes} minutes of game time (each act prints how much), past the first win or loss — retry, go on, explore — and note what changes; the report ends with "come_back": { "answer": "yes|maybe|no", "why": "…", "first": "what you would do first" } — would you come back tomorrow, and why?`);
+    u.line(`screen ${shot}`);
+    u.line(`this round is ${addr}: pass it to every play command (act, note, check, report, end), so a round open beside it never gets your steps`);
+    u.line(`next: funtools play act ${addr} "tap 0.5 0.8" "wait 500"  (up to ${STEP_LIMITS.perAct} steps an act, ${s.budget ?? STEP_LIMITS.perRound} a round;`);
+    u.line('each act saves the screen as NNN.png, NNN = its last step; "shot" saves one mid-act; "A & B" is one two-finger gesture)');
+    u.line('play in batches: one act of several steps costs one screen; "hold right until x>120 max 5s" or "wait until screen!=playing" lets the game run until it happens;');
+    u.line(`"play look" (or "act --look") is a small frame and the state line instead of the full screen${s.viewport === 'phone' ? '' : '; "look DX DY" turns the camera with no button down (a drag clicks)'}`);
+    u.line(`helpers and scratch files go in this round's folder, ${roundDir(root, round)}/ (a helper anywhere else is refused)`);
+    return EXIT.pass;
+}
+async function moveDraftOut(draft, game, into) {
+    const rel = relative(game, draft);
+    if (rel.startsWith('..') || isAbsolute(rel) || rel.split(sep)[0] === '.funtools')
+        return;
+    await rename(draft, into).catch(() => { });
+}
+const untilSaid = (x) => x.met ? `${x.waited_for} after ${(x.after_ms / 1000).toFixed(1)} s` : `${x.waited_for} not seen in ${(x.after_ms / 1000).toFixed(1)} s (it stopped at its max)`;
+const mmss = (s) => `${Math.floor(s / 60)}:${String(Math.round(s % 60)).padStart(2, '0')}`;
+const summaryLine = (r) => `start ${r.start.answer} · goal ${r.goal.answer} · act ${r.act.answer} · end ${r.end.answer} · ${r.defects.length} defect(s)` +
+    `${r.criteria.length ? ` · criteria ${r.criteria.filter((c) => c.verdict === 'pass').length}/${r.criteria.length} pass` : ''}`;
+async function reportRound(root, round, refile = false) {
+    const p = await pickSession(root, round);
+    if ('session' in p)
+        return { s: p.session, live: true };
+    if (refile) {
+        if (round === undefined)
+            return { error: '--refile needs the round', hint: 'name it: --round N' };
+        try {
+            return { s: JSON.parse(readFileSync(closedPath(root, round), 'utf8')), live: false };
+        }
+        catch {
+            return { error: `round ${round} has no closed session to refile into in ${root}`, hint: 'its round folder needs closed.json (the session it was played in)' };
+        }
+    }
+    if (round !== undefined && 'error' in p && existsSync(closedPath(root, round))) {
+        const filed = existsSync(join(roundDir(root, round), 'report.json'));
+        const c = closedUnfiled(root, round);
+        if (filed || c?.closed === 'end')
+            return { error: `round ${round} is closed${filed ? ' and its report was filed' : ' (play end)'}`, hint: `to file a corrected report: funtools play report --round ${round} --refile <file> (the earlier report is kept)` };
+    }
+    const late = (n) => { const c = closedUnfiled(root, n); return c && c.closed !== 'end' ? c : null; };
+    if (round !== undefined) {
+        const c = late(round);
+        return c ? { s: c, live: false } : p;
+    }
+    if ((await openSessions(root)).length)
+        return p;
+    const waiting = roundsAll(root).flatMap((n) => { const c = late(n); return c ? [c] : []; });
+    if (waiting.length === 1)
+        return { s: waiting[0], live: false };
+    return waiting.length ? { error: `${waiting.length} closed rounds wait for a report in ${root}`, hint: `name yours: --round ${waiting.map((c) => c.round).join(' or --round ')}` } : p;
+}
+function keepDir(root, round) {
+    if (round !== undefined)
+        return existsSync(roundDir(root, round)) ? roundDir(root, round) : null;
+    const unfiled = roundsAll(root).filter((n) => !existsSync(join(roundDir(root, n), 'report.json')));
+    return unfiled.length === 1 ? roundDir(root, unfiled[0]) : null;
+}
+async function report(u, io, opts, root, checkOnly) {
+    const file = opts.args[0];
+    const verb = checkOnly ? 'check' : 'report';
+    if (!file) {
+        u.error('no report', `funtools play ${verb} <file.json>  (or - for stdin)`);
+        return EXIT.error;
+    }
+    let text;
+    try {
+        text = file === '-' ? readFileSync(0, 'utf8') : await readFile(resolve(file), 'utf8');
+    }
+    catch (e) {
+        u.error(`cannot read the report: ${e.message}`, 'write it with the Write tool, then name its path');
+        return EXIT.error;
+    }
+    const at = await reportRound(root, opts.round, !!opts.refile);
+    const keep = async (dir) => {
+        if (checkOnly)
+            return;
+        if (!dir) {
+            u.item('warn', 'the report as written was not kept: no single round to keep it in (name it with --round N)');
+            return;
+        }
+        const path = join(dir, 'report-unfiled.json');
+        await writeFile(path, text.endsWith('\n') ? text : text + '\n').then(() => u.item('note', `the report as written is kept beside the notes: ${path}`), () => { });
+    };
+    if (!('s' in at)) {
+        u.error(at.error, at.hint);
+        await keep(keepDir(root, opts.round));
+        return EXIT.error;
+    }
+    const { s, live } = at;
+    if (helperRefused(u, root, s.round, opts.procs))
+        return EXIT.error;
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (e) {
+        u.error(`the report is not JSON: ${e.message}`, 'write it as the player agent\'s report shape');
+        await keep(roundDir(root, s.round));
+        return EXIT.error;
+    }
+    const log = await readLog(root, s.round);
+    const { report: r, problems } = assemble(raw, log, gameCriteria(root), { comeBack: !!s.long_minutes });
+    if (problems.length) {
+        for (const p of problems)
+            u.item('fail', p);
+        if (problems.some((p) => p.startsWith('defects')))
+            u.line(`each defect: ${DEFECT_SHAPE}`);
+        if (problems.some((p) => p.startsWith('criteria')))
+            u.line(`each criterion: ${CRITERION_SHAPE}`);
+        if (checkOnly) {
+            u.error(`round ${s.round}: the report would not file`, 'fix the fields named above, then check again');
+            return EXIT.error;
+        }
+        await keep(roundDir(root, s.round));
+        u.error('the report was not filed', `fix it and file again (play report --round ${s.round} <file>); the round stays open`);
+        return EXIT.error;
+    }
+    if (checkOnly) {
+        if (opts.json)
+            io.log(JSON.stringify({ round: s.round, ok: true }, null, 2));
+        else
+            u.summary('pass', `round ${s.round}: the report would file (${r.defects.length} defect(s)); file it with play report --round ${s.round} <file>`);
+        return EXIT.pass;
+    }
+    const dir = roundDir(root, s.round);
+    const played = s.source_dir ?? (isUrl(s.target) ? null : s.target);
+    const source = played && existsSync(played) ? played : null;
+    if (played && !source)
+        u.item('warn', `the folder this round was played from is gone (${played}); filed without checking whether its source changed`);
+    if (file !== '-' && source)
+        await moveDraftOut(resolve(file), resolve(source), join(dir, 'draft.json'));
+    const pageErrors = log.flatMap((l) => l.page_errors ?? []);
+    const record = {
+        round: s.round, viewport: s.viewport, size: `${s.width}x${s.height}`, target: s.target, at: new Date().toISOString(),
+        ...(s.renderer ? { renderer: s.renderer, ...(timingVoid(s.renderer) ? { timing_void: timingVoid(s.renderer) } : {}) } : {}),
+        ...(source ? {
+            fingerprint: s.fingerprint,
+            source_changed: !s.fingerprint || s.fingerprint !== (await fingerprint(source)).fingerprint,
+        } : played ? { fingerprint: s.fingerprint, source_gone: played } : {}),
+        steps: log.filter((l) => l.step !== undefined).length, jumps: log.filter((l) => /^(view|verb) /.test(l.step ?? '')).length,
+        played_minutes: Math.round(gameSeconds(log, s.viewport === 'phone') / 6) / 10, ...(s.long_minutes ? { long_minutes: s.long_minutes } : {}),
+        page_errors: pageErrors.slice(0, 10), ...(live ? {} : { filed_after_close: s.closed ?? 'gone' }), blocked: blocked(r), ...r,
+        defects: r.defects.map((d) => ({ ...d, shot: d.shot ? join(dir, d.shot) : '' })),
+    };
+    const prior = join(dir, 'report.json');
+    if (opts.refile && existsSync(prior))
+        await rename(prior, join(dir, `report-prev-${Date.now()}.json`));
+    await writeFile(prior, JSON.stringify(opts.refile ? { ...record, refiled: true } : record, null, 2) + '\n');
+    if (source)
+        autoLog(resolve(source), 'play', 'high defects (blind player)', record.defects.filter((d) => d.severity === 'high').length, '', join(dir, 'report.json'));
+    if (live)
+        await call(s, '/end').catch(() => { });
+    if (opts.json)
+        io.log(JSON.stringify(record, null, 2));
+    else {
+        u.heading(`play · round ${s.round} report`);
+        for (const k of ['start', 'goal', 'act'])
+            u.item(r[k].answer === 'yes' ? 'pass' : r[k].answer === 'no' ? 'fail' : 'not_observed', `${k}: ${r[k].answer}`, r[k].note || undefined);
+        u.item('note', `end: ${r.end.answer}`, r.end.note || undefined);
+        for (const d of record.defects)
+            u.item(d.severity === 'high' ? 'fail' : 'warn', `${d.severity}: ${d.title}`, `${d.shot} · repro: steps 0–${d.step} from a fresh load`);
+        for (const c of r.criteria)
+            u.item(c.verdict === 'pass' ? 'pass' : c.verdict === 'fail' ? 'fail' : 'not_observed', `${c.id} ${c.text}`, c.note || undefined);
+        if (r.come_back)
+            u.item('note', `come back tomorrow: ${r.come_back.answer}`, `${r.come_back.why}${r.come_back.first ? ` · first: ${r.come_back.first}` : ''} (${record.played_minutes} min of game time)`);
+        u.line(join(dir, 'report.json'));
+        if ('source_changed' in record && record.source_changed)
+            u.item('warn', 'source changed since this round opened; rebuild and play a new round before using it as current evidence');
+        u.summary(record.blocked ? 'fail' : 'pass', record.blocked ? `a new player is blocked: ${r.blocking || record.defects[0]?.title || 'see the report'}` : 'a new player gets through');
+    }
+    return record.blocked ? EXIT.fail : EXIT.pass;
+}
+export const DEFAULTS = { rounds: DEFAULT_ROUNDS };

package/dist/commands/playable.js

@@ -0,0 +1,51 @@
+import { resolve } from 'node:path';
+import { buildPlayable } from "../playable/build.js";
+import { checkCta } from "../playable/cta.js";
+import { NETWORKS, NETWORK_IDS, SPARE } from "../playable/networks.js";
+import { scanPlayable } from "../playable/scan.js";
+import { stageFiles } from "../stage/stage.js";
+import { EXIT } from "./verify.js";
+import { ui, verdictWord } from "../ui.js";
+const mb = (n) => `${(n / 1_000_000).toFixed(2)} MB`;
+export async function playable(opts, io = console) {
+    const u = ui(io, 'playable');
+    if (!opts.network || !NETWORK_IDS.includes(opts.network)) {
+        u.error(opts.network ? `unknown network: ${opts.network}` : 'playable needs --network', `use one of ${NETWORK_IDS.join(', ')}`);
+        return EXIT.error;
+    }
+    const net = NETWORKS[opts.network];
+    const dir = resolve(opts.target ?? '.');
+    const built = await buildPlayable(dir);
+    const bytes = Buffer.byteLength(built.html);
+    const scan = scanPlayable(built.html, net);
+    const size = bytes > net.ceiling ? 'fail' : 'pass';
+    const tight = size === 'pass' && bytes > net.ceiling * (1 - SPARE);
+    const cta = opts.play && !scan.fails.some((f) => f.startsWith(net.name)) ? await checkCta(resolve(dir, 'dist-playable'), net) : null;
+    const all = [size, scan.fails.length ? 'fail' : 'pass', ...(cta?.steps.map((s) => s.verdict) ?? [])];
+    const verdict = all.includes('fail') ? 'fail' : !cta || all.includes('not_observed') ? 'not_observed' : 'pass';
+    if (opts.json) {
+        io.log(JSON.stringify({ verdict, network: opts.network, file: built.file, entry: built.entry, bytes, ceiling: net.ceiling, inlined: built.inlined, scan, cta }, null, 2));
+        return EXIT[verdict];
+    }
+    u.heading(`playable · ${net.name} · ${built.file}`);
+    u.item('note', `built from ${built.entry}; ${built.inlined.length} file(s) folded in`);
+    u.item(size === 'fail' ? 'fail' : tight ? 'warn' : 'pass', `${mb(bytes)} of ${net.name}'s ${mb(net.ceiling)}`, size === 'fail' ? 'cut music first, then sprite count, resolution, photographic backdrops, web fonts' : tight ? 'less than 10% to spare — the next sprite will not fit' : undefined);
+    if (net.note)
+        u.item('note', net.note);
+    if (stageFiles(dir).included.some((p) => p.startsWith('dist-playable/'))) {
+        u.item('warn', 'dist-playable/ would ship with the game on publish', 'add /dist-playable/ to .harnessignore');
+    }
+    if (!scan.fails.length)
+        u.item('pass', 'nothing it would fetch at runtime');
+    for (const f of scan.fails)
+        u.item('fail', f);
+    for (const n of scan.notes)
+        u.item('note', n);
+    if (!cta)
+        u.item('not_observed', 'played offline', opts.play ? 'skipped: fix the markup the network requires first' : '--no-play');
+    else
+        for (const s of cta.steps)
+            u.item(s.verdict, s.what, s.reason || undefined);
+    u.summary(verdict, `${verdictWord(verdict)} — ${verdict === 'not_observed' ? 'nothing wrong, but the call to action could not be placed after the reward' : `for ${net.name}; submit it through their own preview too`}`);
+    return EXIT[verdict];
+}