@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/playtest/history.js

@@ -0,0 +1,115 @@
+import { readFileSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { DIMENSION_NAME, DIMENSIONS } from "../depth/experience.js";
+import { PLAYTEST_DIR } from "./prepare.js";
+import { autoLog } from "../feedback/auto.js";
+export const HISTORY_FILE = join(PLAYTEST_DIR, 'history.json');
+export function readHistory(root) {
+    try {
+        const h = JSON.parse(readFileSync(join(root, HISTORY_FILE), 'utf8'));
+        return Array.isArray(h?.rounds) ? h : { rounds: [] };
+    }
+    catch {
+        return { rounds: [] };
+    }
+}
+export async function saveRound(root, row) {
+    const h = readHistory(root);
+    const rounds = [...h.rounds.filter((r) => r.n !== row.n), row].sort((a, b) => a.n - b.n);
+    await writeFile(join(root, HISTORY_FILE), JSON.stringify({ rounds }, null, 2) + '\n');
+    const panel = Object.values(row.panel ?? {}).filter((v) => typeof v === 'number');
+    if (panel.length)
+        autoLog(root, 'playtest', 'panel mean', Math.round((panel.reduce((a, b) => a + b, 0) / panel.length) * 100) / 100, '', HISTORY_FILE);
+    return { rounds };
+}
+export function historyRow(s) {
+    return {
+        n: s.n, at: s.at, fingerprint: s.fingerprint, milestone: s.milestone ?? null,
+        route: s.route?.filmed && s.route.script && s.route.run != null ? { script: s.route.script, run: s.route.run, void: s.route.void ?? null } : null,
+        panel: s.means, experience: s.experience?.means ?? {},
+        player: {
+            verdict: s.player.round === null ? null : s.player.blocked ? 'blocked' : 'through', high: s.player.defects.high ?? 0,
+            defects: Object.values(s.player.defects).reduce((a, b) => a + b, 0), come_back: s.experience?.come_back?.answer ?? null, played_minutes: s.experience?.played_minutes ?? null,
+        },
+        fidelity: {
+            art: s.fidelity?.art ?? null, creative: s.fidelity?.creative ?? null, ui: s.fidelity?.ui?.ui ?? null, ux: s.fidelity?.ui?.ux ?? null, rules: s.fidelity?.rules ?? {},
+            moments: (s.fidelity?.moments ?? []).map((m) => ({ moment: m.moment, ...(m.at ? { at: m.at } : {}), ...(m.source ? { source: m.source } : {}), art: m.art, creative: m.creative, ui: m.ui, ux: m.ux, ...(m.staged?.reached === false ? { staged_unreached: true } : {}) })),
+        },
+        blockers: (s.ledger ?? []).map((e) => ({ text: e.text, status: e.status })),
+        ...(s.keep?.length ? { keep: s.keep.map((k) => ({ id: k.id, text: k.text, status: k.status })) } : {}),
+    };
+}
+const DROP = 0.005;
+export function cell(now, before, digits = 2) {
+    if (typeof now !== 'number')
+        return '—';
+    const v = now.toFixed(digits);
+    if (typeof before !== 'number')
+        return v;
+    const d = now - before;
+    return d <= -DROP ? `**${v} ▼${d.toFixed(digits)}**` : d >= DROP ? `${v} ▲+${d.toFixed(digits)}` : v;
+}
+const RULE_RANK = { held: 3, partly: 2, broken: 1, missing: 1 };
+const ruleRank = (w) => RULE_RANK[String(w ?? '').toLowerCase().split(/\W/)[0]] ?? null;
+const PANEL_ROWS = [['Panel overall', 'overall'], ['Look and feel', 'lookAndFeel'], ['Fun', 'fun'], ['Juice', 'juice'], ['Readability', 'readability'], ['Intuitive', 'intuitiveness'], ['HUD', 'hud'], ['Mobile', 'mobile']];
+export function historyMd(h, max = 6) {
+    const rs = h.rounds.slice(-max);
+    if (rs.length < 1)
+        return [];
+    const out = ['## Round history', '', `Every playtest here, same seats and bar${rs.some((r) => r.route) ? ', same route' : ''}. A drop against the round before is **bold ▼**, and every drop is listed below the table.`, ''];
+    const head = `| | ${rs.map((r) => `Playtest ${r.n}`).join(' | ')} |`;
+    const sep = `|---|${rs.map(() => '---|').join('')}`;
+    const drops = [];
+    const row = (label, get) => {
+        const vals = rs.map(get);
+        if (vals.every((v) => typeof v !== 'number'))
+            return null;
+        vals.forEach((v, i) => { const b = i ? vals[i - 1] : undefined; if (i === rs.length - 1 && typeof v === 'number' && typeof b === 'number' && v - b <= -DROP)
+            drops.push(`${label} ${b.toFixed(2)} → ${v.toFixed(2)} (${(v - b).toFixed(2)})`); });
+        return `| ${label} | ${vals.map((v, i) => cell(v, i ? vals[i - 1] : undefined)).join(' | ')} |`;
+    };
+    const lines = [
+        ...PANEL_ROWS.map(([l, a]) => row(l, (r) => r.panel[a])),
+        ...DIMENSIONS.map((d) => row(`Experience: ${DIMENSION_NAME[d]}`, (r) => r.experience[d])),
+        row('Fidelity: art direction', (r) => r.fidelity.art), row('Fidelity: creative direction', (r) => r.fidelity.creative),
+        row('Fidelity: UI', (r) => r.fidelity.ui), row('Fidelity: UX', (r) => r.fidelity.ux),
+        row('Real play reached (min)', (r) => r.player.played_minutes),
+    ].filter((l) => !!l);
+    out.push(head, sep, ...lines);
+    out.push(`| Blind player | ${rs.map((r) => (r.player.verdict ? `${r.player.verdict}${r.player.high ? `, ${r.player.high} high` : ''}${r.player.come_back ? `; back: ${r.player.come_back}` : ''}` : 'not played')).join(' | ')} |`);
+    out.push(`| Route | ${rs.map((r, i) => (!r.route ? 'none' : `run ${r.route.run}${i && rs[i - 1].route && rs[i - 1].route.script !== r.route.script ? ' (CHANGED route: not like with like)' : ''}${r.route.void ? ' (VOID run)' : ''}`)).join(' | ')} |`);
+    out.push('', drops.length ? `Down since playtest ${rs.at(-2).n}: ${drops.join('; ')}.` : rs.length > 1 ? `Nothing scored went down since playtest ${rs.at(-2).n}.` : 'The first round: the next one is set beside it.', '');
+    const moments = [...new Set(rs.flatMap((r) => r.fidelity.moments.map((m) => m.moment)))];
+    if (moments.length) {
+        out.push('### Fidelity per moment (art / creative; ui / ux where the plan drew the screen)', '', `| Moment | ${rs.map((r) => `Playtest ${r.n}`).join(' | ')} |`, sep);
+        for (const m of moments) {
+            const cells = rs.map((r, i) => {
+                const x = r.fidelity.moments.find((y) => y.moment === m);
+                if (!x || (x.art === null && x.creative === null))
+                    return x?.staged_unreached ? 'staged only (play never reached it)' : '—';
+                const b = i ? rs[i - 1].fidelity.moments.find((y) => y.moment === m) : undefined;
+                const down = b && typeof b.art === 'number' && typeof x.art === 'number' && (x.art < b.art || (x.creative ?? 0) < (b.creative ?? 0));
+                const s = `${x.art ?? '—'} / ${x.creative ?? '—'}${typeof x.ui === 'number' ? ` · ui ${x.ui} / ux ${x.ux ?? '—'}` : ''}`;
+                return `${down ? `**${s} ▼**` : s}${x.source === 'route' ? ` (played, ${x.at})` : x.staged_unreached ? ' (STAGED: play never reached it)' : x.source === 'view' ? ' (staged view)' : ''}`;
+            });
+            out.push(`| ${m} | ${cells.join(' | ')} |`);
+        }
+        out.push('', 'A single judge moves about ±1 on a moment between reads: trust the trend, not the digit.', '');
+    }
+    const rules = [...new Set(rs.flatMap((r) => Object.keys(r.fidelity.rules)))].sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+    if (rules.length) {
+        out.push('### Art direction lines', '', `| Rule | ${rs.map((r) => `Playtest ${r.n}`).join(' | ')} |`, sep);
+        for (const k of rules) {
+            out.push(`| ${k} | ${rs.map((r, i) => {
+                const w = r.fidelity.rules[k];
+                if (!w)
+                    return '—';
+                const a = ruleRank(w), b = i ? ruleRank(rs[i - 1].fidelity.rules[k]) : null;
+                return a !== null && b !== null && a < b ? `**${w} ▼**` : a !== null && b !== null && a > b ? `${w} ▲` : w;
+            }).join(' | ')} |`);
+        }
+        out.push('');
+    }
+    return out;
+}

package/dist/playtest/hits.js

@@ -0,0 +1,48 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const AXES = ['lookAndFeel', 'readability', 'intuitiveness', 'juice', 'fun', 'mobile', 'hud', 'overall'];
+const p = (lookAndFeel, readability, intuitiveness, juice, fun, mobile, hud, overall) => ({ lookAndFeel, readability, intuitiveness, juice, fun, mobile, hud, overall });
+const x = (depth, content, replay, story, world, arc, originality) => ({ depth, content, replay, story, world, arc, originality });
+export const HITS = [
+    { slug: 'pacman-ce-dx', name: 'Pac-Man CE DX', genres: ['arcade', 'maze', 'chase', 'score attack'], brief: 'k2', panel: p(8.27, 7.33, 6.83, 8.6, 8.3, 4.33, 7.23, 8.1), experience: x(8, 4, 6, 0.5, 2.5, 5.5, 6.5) },
+    { slug: 'suika-game', name: 'Suika Game', genres: ['puzzle', 'merge', 'physics', 'casual'], panel: p(8.0, 7.3, 7.1, 6.5, 7.33, 6.22, 6.7, 7.22), experience: x(6, 2, 5.5, 0, 0.5, 4, 3.5) },
+    { slug: 'vampire-survivors', name: 'Vampire Survivors', genres: ['survivors', 'roguelite', 'horde', 'bullet heaven', 'shooter'], panel: p(7.78, 6.03, 6.97, 8.35, 8.0, 6.58, 6.42, 7.72), experience: x(6, 9, 9, 2, 4.5, 6, 8) },
+    { slug: 'hades', name: 'Hades', genres: ['action', 'roguelike', 'rpg', 'brawler', 'isometric'], panel: p(9.3, 7.45, 6.65, 8.4, 7.83, 3.12, 7.5, 8.25), experience: x(8, 8, 9, 9, 7, 8, 8) },
+    { slug: 'hollow-knight', name: 'Hollow Knight', genres: ['metroidvania', 'adventure', 'exploration'], panel: p(9.25, 8.03, 7.12, 8.2, 8.35, 2.62, 8.28, 8.43), experience: x(8, 9.5, 6, 8, 9.5, 8, 6) },
+    { slug: 'celeste', name: 'Celeste', genres: ['platformer', 'precision', 'runner'], panel: p(9.0, 8.05, 7.33, 7.95, 8.47, 3.0, 7.78, 8.2), experience: x(9, 8, 8, 8, 7.5, 8.5, 7) },
+    { slug: 'mario-kart-tour', name: 'Mario Kart Tour', genres: ['racing', 'racer', 'kart', 'driving', 'race'], dimension: '3d', brief: 'k2', panel: p(8.73, 7.5, 7.7, 8.1, 7.53, 7.97, 7.33, 8.03) },
+    { slug: 'monument-valley-2', name: 'Monument Valley 2', genres: ['puzzle', 'perspective', 'chambers', 'diorama', 'story'], dimension: '3d', brief: 'k2', panel: p(9.23, 7.7, 7.53, 7.53, 7.93, 8.47, 7.87, 8.57), experience: x(3.5, 6, 1, 7, 6, 6.5, 5) },
+];
+export function nearestHit(genre, dimension) {
+    const g = (genre ?? '').toLowerCase();
+    const d = dimension === '3d' ? '3d' : undefined;
+    let best = HITS[0], score = 0;
+    for (const h of HITS) {
+        const s = h.genres.filter((x) => g.includes(x)).length + (g.includes(h.slug.split('-')[0]) ? 1 : 0);
+        const t = s > 0 && h.dimension === d ? s + 0.5 : s;
+        if (t > score) {
+            best = h;
+            score = t;
+        }
+    }
+    return best;
+}
+export function onCurrentBrief(slug) {
+    return HITS.find((h) => h.slug === slug)?.brief === 'k2';
+}
+export function hitDirs(slug) {
+    return [process.env.FUNPIXEL_HITS_DIR, join(homedir(), '.funpixel', 'hits')].filter((d) => !!d).map((d) => join(d, slug));
+}
+const IMAGE = /\.(png|jpe?g|webp)$/i;
+export function usableEvidence(dir) {
+    try {
+        return existsSync(join(dir, 'premise.txt')) && readdirSync(dir).filter((f) => IMAGE.test(f)).length >= 3;
+    }
+    catch {
+        return false;
+    }
+}
+export function findHitEvidence(slug) {
+    return hitDirs(slug).find(usableEvidence) ?? null;
+}

package/dist/playtest/hosted.js

@@ -0,0 +1,98 @@
+import { readFileSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { apiOptions, ApiError } from "../api/http.js";
+import { estimate, followJob, submit } from "../api/jobs.js";
+import { decodePng, encodePng } from "../look/png.js";
+import { EXIT } from "../commands/verify.js";
+import { assemble } from "./assemble.js";
+import { factsText } from "./facts.js";
+import { prepare } from "./prepare.js";
+import { shrink } from "./sheet.js";
+import { ui } from "../ui.js";
+export const REVIEW_IMAGES = { max: 12, bytes: 700 * 1024 };
+export function hostedImages(frames) {
+    const weight = (f) => (f.startsWith('clip-') ? 0 : f.startsWith('playing') ? 1 : f.startsWith('title') ? 2 : 3);
+    return [...frames].sort((a, b) => weight(a) - weight(b) || a.localeCompare(b)).slice(0, REVIEW_IMAGES.max);
+}
+function imagePayload(dir, f) {
+    let bytes = readFileSync(join(dir, f));
+    for (let img = decodePng(bytes); bytes.length > REVIEW_IMAGES.bytes && img.width > 160;) {
+        img = shrink(img, Math.round(img.width * 0.75));
+        bytes = Buffer.from(encodePng(img));
+    }
+    return { name: f.replace(/\.png$/i, ''), data_base64: bytes.toString('base64') };
+}
+export async function playtestHosted(opts, io = console) {
+    const u = ui(io, 'playtest');
+    const api = apiOptions();
+    if (!api) {
+        u.error('no API key for the hosted seats', 'funtools login, or run the seats on your own agent (drop --hosted)');
+        return EXIT.error;
+    }
+    const root = opts.dir;
+    let manifest;
+    try {
+        manifest = JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8'));
+    }
+    catch {
+        u.error(`no funpixel.json in ${root}`);
+        return EXIT.error;
+    }
+    const gameId = typeof manifest.game_id === 'string' && /^[0-9a-f]{32}$/.test(manifest.game_id) ? manifest.game_id : null;
+    if (!gameId) {
+        u.error('the hosted seats need the game\'s id in funpixel.json', 'publish a draft first (it mints the id), or run the seats on your own agent (drop --hosted)');
+        return EXIT.error;
+    }
+    const { plan, dir, measures } = await prepare(root, manifest, { quick: opts.quick, build: opts.build, versus: 'none', note: (l) => u.item('note', l) });
+    if (!measures.build.ok) {
+        u.item('fail', 'the build failed: nothing to judge', measures.build.tail);
+        return EXIT.fail;
+    }
+    const facts = factsText(plan.facts ?? []);
+    const review = { game_id: gameId, premise: plan.premise.text, seats: opts.quick ? 'quick' : 'full', images: hostedImages(plan.frames).map((f) => imagePayload(join(dir, 'frames'), f)), ...(facts ? { facts } : {}) };
+    const playIn = { game_id: gameId, premise: plan.premise.text, viewport: 'phone' };
+    try {
+        const quotes = await Promise.all([estimate(api, 'review', review), estimate(api, 'play', playIn)]);
+        const total = quotes.reduce((s, q) => s + q.estimate_credits, 0);
+        u.item('note', `quote: review ${quotes[0].estimate_credits} credits · play ${quotes[1].estimate_credits} credits (a hold; the charge is what the seats cost) · head to head: not hosted (the hits' media never leave this machine)`);
+        if (quotes.some((q) => q.requires_confirmation) && !opts.yes) {
+            u.summary('warn', `${total} credits: run again with --yes to spend them (measurements are in ${dir})`);
+            return EXIT.pass;
+        }
+        const key = `playtest-${plan.fingerprint.slice(0, 16)}-${plan.n}`;
+        const jobs = await Promise.all([
+            submit(api, 'review', review, { idempotencyKey: `${key}-review`, confirm: opts.yes }),
+            submit(api, 'play', playIn, { idempotencyKey: `${key}-play`, confirm: opts.yes }),
+        ]);
+        u.item('note', `jobs: ${jobs.map((j) => `${j.job.tool} ${j.job.job_id}`).join(' · ')}`);
+        const done = await Promise.all(jobs.map((j) => followJob(api, j.job.job_id)));
+        let credits = 0;
+        for (const job of done) {
+            credits += job.charged_credits ?? 0;
+            if (job.status !== 'succeeded') {
+                u.item('fail', `${job.tool} ${job.status}`, job.error?.message);
+                continue;
+            }
+            const result = job.result;
+            if (job.tool === 'review')
+                for (const seat of result?.seats ?? [])
+                    await writeFile(join(dir, 'seats', `${seat.critic}.json`), JSON.stringify(seat, null, 2) + '\n');
+            if (job.tool === 'play')
+                await writeFile(join(dir, 'player-hosted.json'), JSON.stringify({ ...result, frames: job.outputs.map((o) => o.url ?? o.name), at: new Date().toISOString() }, null, 2) + '\n');
+        }
+        const { summary, file } = await assemble(root, plan.n, { costUsd: opts.costUsd, hostedCredits: credits });
+        if (opts.json) {
+            io.log(JSON.stringify(summary, null, 2));
+            return EXIT.pass;
+        }
+        summary.steps.forEach((s, i) => u.item('note', `${i + 1}. ${s.text}`, `${s.who} · ${s.number}`));
+        u.line(file);
+        u.summary('pass', `${credits} credits charged; read the report and pick, edit or ignore its steps`);
+        return EXIT.pass;
+    }
+    catch (e) {
+        u.error(e instanceof ApiError ? `${e.message} (${e.code})` : e.message, `the measurements and the local seat prompts are in ${dir}`);
+        return EXIT.error;
+    }
+}

package/dist/playtest/keep.js

@@ -0,0 +1,110 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export const KEEP_FILE = join('.funtools', 'keep.json');
+export const KEEP_MAX = 8;
+const STOP = new Set('that this with from they them their there which would could should about into than then what when where while more most less your have been only each every make made over under very much also just like the and for are but not was its game player reads'.split(' '));
+export const keepWords = (t) => new Set(t.toLowerCase().replace(/`[^`]*`/g, ' ').match(/[a-z]{4,}/g)?.filter((w) => !STOP.has(w)) ?? []);
+const overlap = (a, b) => { let n = 0; for (const w of a)
+    if (b.has(w))
+        n++; return n / Math.max(1, a.size + b.size - n); };
+export const SAME = 0.3;
+const short = (s, n = 200) => { const t = s.replace(/\s+/g, ' ').trim(); return t.length <= n ? t : `${t.slice(0, n - 1)}…`; };
+export function readKeep(root) {
+    try {
+        const r = JSON.parse(readFileSync(join(root, KEEP_FILE), 'utf8'));
+        const ok = (list) => (Array.isArray(list) ? list.filter((i) => typeof i?.id === 'string' && typeof i?.text === 'string') : []);
+        return r && Array.isArray(r.items) ? { version: 1, at: String(r.at ?? ''), playtest: Number(r.playtest) || 0, items: ok(r.items), before: Array.isArray(r.before) ? ok(r.before) : null } : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeKeep(root, rec) {
+    const p = join(root, KEEP_FILE);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(rec, null, 2) + '\n');
+}
+export const carried = (rec) => (rec?.items ?? []).filter((i) => !i.dropped);
+export const lostItems = (rec) => carried(rec).filter((i) => i.status === 'lost');
+export function pickNew(named, have, room) {
+    if (room <= 0)
+        return [];
+    const all = named.flatMap((n) => n.lines.filter((l) => typeof l === 'string' && keepWords(l).size >= 2).map((l, i) => ({ who: n.who, text: short(l), i, bag: keepWords(l), support: 0 })));
+    for (const c of all)
+        c.support = new Set(all.filter((o) => o.who !== c.who && overlap(c.bag, o.bag) >= SAME).map((o) => o.who)).size;
+    const order = [...all].sort((a, b) => b.support - a.support || a.i - b.i);
+    const out = [];
+    const held = have.map((h) => keepWords(h.text));
+    for (const c of order) {
+        if (out.length >= room)
+            break;
+        if (held.some((h) => overlap(h, c.bag) >= SAME) || out.some((o) => overlap(o.bag, c.bag) >= SAME))
+            continue;
+        const who = [c.who, ...all.filter((o) => o.who !== c.who && overlap(c.bag, o.bag) >= SAME).map((o) => o.who)];
+        out.push({ text: c.text, who: [...new Set(who)], bag: c.bag });
+    }
+    return out.map(({ text, who }) => ({ text, who }));
+}
+const withoutLoss = (it) => { const { note: _n, lost_since: _l, ...rest } = it; return rest; };
+export function judgeKeep(items, answers, named, n) {
+    const lines = named.flatMap((x) => x.lines.map((l) => ({ who: x.who, l, bag: keepWords(l) })));
+    return items.map((it) => {
+        if (it.dropped)
+            return it;
+        const a = answers?.find((x) => x.id === it.id);
+        const stillLost = (why) => ({ ...it, status: 'lost', judged: n, note: `${why} in playtest ${n}` });
+        if (a) {
+            if (a.status === 'not observed' && it.status === 'lost')
+                return stillLost('not observed');
+            return { ...withoutLoss(it), status: a.status, judged: n, evidence: short(a.evidence, 300), judged_by: 'seat', ...(a.status === 'lost' ? { lost_since: it.status === 'lost' ? it.lost_since ?? n : n } : {}) };
+        }
+        const bag = keepWords(it.text);
+        const again = lines.find((x) => overlap(bag, x.bag) >= SAME);
+        if (again)
+            return { ...withoutLoss(it), status: 'held', judged: n, evidence: `named as working again by ${again.who}: “${short(again.l, 160)}”`, judged_by: 'words' };
+        if (it.status === 'lost')
+            return stillLost('not judged again');
+        return { ...it, status: 'not judged', judged: n, evidence: 'no ledger seat filed on it and no seat named it again', judged_by: 'none' };
+    });
+}
+export function keepBefore(rec, n) {
+    if (!rec || rec.playtest < n)
+        return rec;
+    return rec.before ? { ...rec, playtest: n - 1, items: rec.before, before: null } : null;
+}
+export function mergeKeep(before, answers, named, n, now = new Date()) {
+    const judged = judgeKeep(before?.items ?? [], answers, named, n);
+    const live = judged.filter((i) => !i.dropped);
+    const next = Math.max(0, ...judged.map((i) => Number(i.id.replace(/^K/, '')) || 0)) + 1;
+    const fresh = pickNew(named, live, KEEP_MAX - live.length).map((x, k) => ({ id: `K${next + k}`, text: x.text, who: x.who, since: n, status: 'new', judged: n }));
+    return { version: 1, at: now.toISOString(), playtest: n, items: [...judged, ...fresh], before: before?.items ?? null };
+}
+export function dropKeep(rec, id, why, now = new Date()) {
+    const it = rec.items.find((i) => i.id === id && !i.dropped);
+    if (!it)
+        return null;
+    return { ...rec, items: rec.items.map((i) => (i === it ? { ...i, dropped: { at: now.toISOString(), why } } : i)) };
+}
+export function keepLines(rec) {
+    return carried(rec).map((i) => `${i.id}${i.status === 'lost' ? ' LOST (a regression: put it back first)' : ''}: ${i.text} (since playtest ${i.since})`);
+}
+export function keepPromptList(items) {
+    const live = items.filter((i) => !i.dropped);
+    return live.length ? live.map((i) => `- **${i.id}** (named by ${i.who.join(', ')}, playtest ${i.since}): ${i.text}`).join('\n') : 'None named yet.';
+}
+export function readKeepAnswers(v) {
+    const list = Array.isArray(v?.keep) ? v.keep : [];
+    return list.filter((k) => typeof k?.id === 'string' && /^(held|lost|not observed)$/i.test(String(k.status ?? '').trim()))
+        .map((k) => ({ id: k.id, status: String(k.status).trim().toLowerCase(), evidence: String(k.evidence ?? '') }));
+}
+export function keepMd(rec) {
+    const live = carried(rec);
+    if (!live.length)
+        return [];
+    const lost = live.filter((i) => i.status === 'lost');
+    const out = ['## Do not regress', '', lost.length ? `**${lost.length} lost: ${lost.map((i) => i.id).join(', ')}.** Each worked in an earlier round and this round's evidence shows it gone: put it back before anything else.` : 'What already works, named by the panel; every round\'s brief carries it, and losing one is a regression.', '', '| | What works | Since | This round | Evidence |', '|---|---|---|---|---|'];
+    for (const i of live)
+        out.push(`| ${i.id} | ${i.text.replace(/\|/g, '/')} | playtest ${i.since} | **${i.status}**${i.judged_by === 'words' ? ' (by its words)' : ''} | ${[i.evidence ?? '', i.lost_since ? `lost since playtest ${i.lost_since}` : '', i.note ?? ''].filter(Boolean).join(' · ').replace(/\|/g, '/').slice(0, 300)} |`);
+    out.push('');
+    return out;
+}

package/dist/playtest/ledger.js

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { jaccard, words } from "./rank.js";
+import { keepPromptList, readKeepAnswers } from "./keep.js";
+const PANEL = new URL('../../panel/', import.meta.url);
+export const CARRIED = 4;
+export function blockersOf(before) {
+    return (before?.steps ?? []).slice(0, CARRIED).map((s, i) => ({ id: `B${i + 1}`, from: before.n, text: s.text, quote: s.quote, who: s.who, number: s.number, frame: s.frame }));
+}
+export function ledgerPrompt(blockers, evidence, answer, keep = []) {
+    const now = (f) => {
+        if (!f)
+            return '';
+        const same = join(evidence.framesDir, basename(f));
+        return existsSync(same) ? ` · THIS ROUND ${same}` : '';
+    };
+    const list = blockers.length ? blockers.map((b) => `- **${b.id}** (${b.who}; ${b.number}): ${b.text}\n  - In its words: “${b.quote.replace(/\s+/g, ' ').slice(0, 400)}”${b.frame ? `\n  - LAST ROUND ${b.frame}${now(b.frame)}` : ''}`).join('\n') : 'None carried.';
+    const ev = [
+        '### The blind round on this build', '', evidence.play, '',
+        '### Measured facts on this build', '', evidence.facts.trim() || 'None measured.', '',
+        '### This round\'s frames', '', ...evidence.frames.map((f) => `- ${f}`),
+    ].join('\n');
+    return readFileSync(new URL('blockers.md', PANEL), 'utf8').replaceAll('{{BLOCKERS}}', list).replaceAll('{{KEEP}}', keepPromptList(keep)).replaceAll('{{EVIDENCE}}', ev) +
+        `\n\n## Filing\n\nWrite your JSON answer, and nothing else, to this file with your file-writing tool:\n${answer}\nThen reply with one line: \`filed\`. You read nothing but the images named above.\n`;
+}
+const STATUS = /^(fixed|still there|changed|not observed)$/;
+export function readLedger(file) {
+    if (!existsSync(file))
+        return { problem: 'not filed' };
+    let v;
+    try {
+        const raw = readFileSync(file, 'utf8');
+        v = JSON.parse(raw.slice(raw.indexOf('{'), raw.lastIndexOf('}') + 1));
+    }
+    catch {
+        return { problem: 'no JSON in the answer' };
+    }
+    const list = Array.isArray(v?.blockers) ? v.blockers.filter((b) => typeof b?.id === 'string' && STATUS.test(String(b.status ?? '').toLowerCase())) : [];
+    const keep = readKeepAnswers(v);
+    if (!list.length && !keep.length)
+        return { problem: 'no blocker judged' };
+    return { answers: list.map((b) => ({ id: b.id, status: String(b.status).toLowerCase(), evidence: String(b.evidence ?? ''), ...(b.now ? { now: String(b.now) } : {}) })), ...(keep.length ? { keep } : {}) };
+}
+export function judgeLedger(blockers, seat, now) {
+    return blockers.map((b) => {
+        const a = seat?.answers?.find((x) => x.id === b.id);
+        if (a)
+            return { ...b, status: a.status, evidence: a.evidence, ...(a.now ? { now: a.now } : {}), judged_by: 'seat' };
+        const bag = words(`${b.text} ${b.quote}`);
+        const match = now.map((s) => ({ s, j: jaccard(bag, words(`${s.text} ${s.quote}`)) })).sort((x, y) => y.j - x.j)[0];
+        if (match && match.j >= 0.22)
+            return { ...b, status: 'still there', evidence: `this round: “${match.s.text}” (${match.s.who}; ${match.s.number})`, judged_by: 'words' };
+        return { ...b, status: 'not judged', evidence: 'no ledger seat filed, and nothing this round repeats it: run the ledger seat to judge it', judged_by: 'none' };
+    });
+}
+export function carryForward(steps, ledger) {
+    const carried = new Map();
+    for (const e of ledger.filter((x) => x.status === 'still there' || x.status === 'changed')) {
+        const bag = words(`${e.text} ${e.quote}`);
+        const best = steps.map((s, i) => ({ i, j: jaccard(bag, words(`${s.text} ${s.quote}`)) })).filter((x) => !carried.has(x.i)).sort((a, b) => b.j - a.j)[0];
+        if (best && best.j >= 0.22)
+            carried.set(best.i, e);
+    }
+    return steps.map((s, i) => {
+        const e = carried.get(i);
+        return e ? { ...s, number: `${s.number} · carried from playtest ${e.from} (${e.id}, ${e.status})`, score: s.score + 30 } : s;
+    }).sort((a, b) => b.score - a.score);
+}
+export function ledgerMd(entries) {
+    if (!entries.length)
+        return [];
+    const out = [`## Last round's blockers (playtest ${entries[0].from})`, '', '| | Blocker | This round | Evidence |', '|---|---|---|---|'];
+    for (const e of entries)
+        out.push(`| ${e.id} | ${e.text} | **${e.status}**${e.judged_by === 'words' ? ' (by its words; no ledger seat)' : ''} | ${[e.now, e.evidence].filter(Boolean).join(' — ').replace(/\|/g, '/').replace(/\s+/g, ' ').slice(0, 300)} |`);
+    out.push('');
+    return out;
+}

package/dist/playtest/length.js

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { designDoc } from "../gdd/doc.js";
+import { classOf, contentList, contentTotals } from "../gdd/size.js";
+import { byEvidence } from "../depth/experience.js";
+import { playFloor, statedLength } from "../sim/judge.js";
+const m1 = (s) => Math.round(s / 6) / 10;
+const readJson = (f) => { try {
+    return JSON.parse(readFileSync(f, 'utf8'));
+}
+catch {
+    return null;
+} };
+export function playLength(root, pacing) {
+    const doc = designDoc(root);
+    const rows = doc ? contentList(doc.text) : null;
+    const areas = rows ? contentTotals(rows).areas || null : null;
+    const stated = doc ? statedLength(doc.text, doc.rel) : null;
+    const sim = readJson(join(root, '.funtools', 'sim.json'));
+    const bots = (sim?.cohorts ?? []).filter((c) => ['skilled', 'novice', 'naive'].includes(c.role)).map((c) => ({
+        who: c.human ? `${c.role} at ${c.human.hz}/s` : c.role, minutes: m1(c.meanSeconds), won: c.won, lost: c.lost, seeds: c.seeds,
+        top: c.levels?.length ? Math.max(...c.levels.filter((l) => l.reached > 0).map((l) => l.level)) : null,
+    }));
+    const blind = byEvidence(pacing.filter((p) => /^blind round/.test(p.source)))[0];
+    const player = blind ? { source: blind.source, minutes: m1(blind.playSeconds ?? blind.seconds), places: blind.places, field: blind.placeField } : null;
+    const warnings = [];
+    const skilled = bots.find((b) => b.who === 'skilled');
+    const floor = playFloor(root), chosen = !!stated?.onPurpose && stated.seconds < floor.seconds;
+    const need = m1(chosen ? stated.seconds : floor.seconds);
+    if (skilled && skilled.minutes < need)
+        warnings.push(`a skilled bot's run lasts ${skilled.minutes} min, under the ${need}-minute ${chosen ? 'length the plan chooses' : `floor for ${floor.where}`}${stated && !chosen ? ` (the plan says ${m1(stated.seconds)} min)` : ''}`);
+    const sharp = (sim?.cohorts ?? []).find((c) => c.role === 'skilled' && !c.human);
+    if (sharp?.ended === 0 && !(stated?.onPurpose))
+        warnings.push(`no ending reached in ${sharp.seconds} s: the skilled bot's runs ${sharp.open >= sharp.seeds / 2 ? 'loop without running out' : 'all end lost first'}; a game reaches an ending worth reaching`);
+    const reached = Math.max(player?.places.length ?? 0, skilled?.top ?? 0);
+    if (areas && areas >= 2 && (player || skilled?.top) && reached <= areas / 2) {
+        warnings.push(`the plan claims ${areas} areas or levels; play reached ${reached} (${[player ? `the blind player ${player.places.length}` : '', skilled?.top ? `the skilled bot ${skilled.top}` : ''].filter(Boolean).join(', ')}): build what the plan names, or lower the claim`);
+    }
+    return { player, bots, plan: { stated_minutes: stated ? m1(stated.seconds) : null, areas, file: doc?.rel ?? null }, warnings };
+}
+export function lengthMd(p) {
+    const out = ['## Play length', ''];
+    const plan = [p.plan.stated_minutes !== null ? `the plan says ${p.plan.stated_minutes} min` : 'no `Play length:` line', p.plan.areas ? `${p.plan.areas} areas or levels in the content list` : 'no areas in a content list'].join(', ');
+    out.push(`Against the plan (${p.plan.file ?? 'no design doc'}: ${plan}); the floor is 15 min of play and an ending (funpixel.json play_min_minutes moves it).`, '');
+    out.push('| Player | Minutes of play | Reached |', '|---|---|---|');
+    if (p.player)
+        out.push(`| Blind player (${p.player.source}) | ${p.player.minutes} | ${p.player.field ? `${p.player.places.length} ${p.player.field}(s): ${p.player.places.slice(0, 8).join(', ')}` : 'no place field in the state'} |`);
+    else
+        out.push('| Blind player | not measured (run `playtest experience` after the long round) | |');
+    for (const b of p.bots)
+        out.push(`| ${b.who} bot (sim) | ${b.minutes} | ${b.top !== null ? `level ${b.top}; ` : ''}won ${b.won}, lost ${b.lost} of ${b.seeds} |`);
+    if (!p.bots.length)
+        out.push('| Bots | not measured (no test/probes.ts, or sim did not run) | |');
+    out.push('');
+    for (const w of p.warnings)
+        out.push(`- **warn** · ${w}`);
+    if (p.warnings.length)
+        out.push('');
+    return out;
+}
+export const MEASURED = '(measured)';
+export function fillReached(text, p) {
+    const player = p.player?.field ? p.player.places.length : null, bot = p.bots.find((b) => b.who === 'skilled')?.top ?? null;
+    if (player === null && bot === null)
+        return null;
+    const lines = text.split('\n');
+    const start = lines.findIndex((l) => /^##\s+content list\b/i.test(l));
+    if (start < 0)
+        return null;
+    let head = null, col = -1, changed = false;
+    for (let i = start + 1; i < lines.length && !/^##\s/.test(lines[i]); i++) {
+        const l = lines[i];
+        if (!/^\s*\|.*\|\s*$/.test(l)) {
+            if (head)
+                break;
+            continue;
+        }
+        const cells = l.trim().replace(/^\||\|$/g, '').split('|');
+        if (!head) {
+            head = cells.map((c) => c.trim().toLowerCase());
+            col = head.findIndex((h) => /reached/.test(h));
+            if (col < 0)
+                return null;
+            continue;
+        }
+        if (/^[\s:|-]+$/.test(l.trim().replace(/\|/g, '')))
+            continue;
+        const what = cells[0]?.trim() ?? '', cell = (cells[col] ?? '').trim();
+        if (classOf(what) !== 'areas' || (cell && !/^<.*>$/.test(cell) && !cell.endsWith(MEASURED)))
+            continue;
+        const claimed = /(\d+)/.exec(cells[1] ?? '')?.[1];
+        const says = [player !== null ? `blind player ${player}` : '', bot !== null ? `skilled bot ${bot}` : ''].filter(Boolean).join(', ');
+        const value = ` ${Math.max(player ?? 0, bot ?? 0)}${claimed ? ` of ${claimed}` : ''} (${says}) ${MEASURED} `;
+        while (cells.length <= col)
+            cells.push('');
+        if (cells[col] === value)
+            continue;
+        cells[col] = value;
+        lines[i] = `|${cells.join('|')}|`;
+        changed = true;
+    }
+    return changed ? lines.join('\n') : null;
+}
+export function writeReached(root, p) {
+    const file = join(root, 'design', 'GDD.md');
+    if (!existsSync(file))
+        return null;
+    const next = fillReached(readFileSync(file, 'utf8'), p);
+    if (next === null)
+        return null;
+    writeFileSync(file, next);
+    return 'design/GDD.md';
+}