@funpixel/tools 0.0.0-stage → 0.1.1

package/plugins/codex/hooks/vendor/playtest/keep.mjs

@@ -0,0 +1,111 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/playtest/keep.ts by the GDK build. Do not edit.
+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/plugins/codex/hooks/vendor/playtest/stuck.mjs

@@ -0,0 +1,48 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/playtest/stuck.ts by the GDK build. Do not edit.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DIMENSIONS, EXPERIENCE_LABEL, scoreExperience } from '../gdd/rubric.mjs';
+import { designDoc } from '../gdd/doc.mjs';
+export const STUCK_BELOW = 3;
+export const STUCK_PLAYTESTS = 3;
+export const STUCK_HISTORY_FILE = join('.funtools', 'playtest', 'history.json');
+export const STUCK_PANEL_AXES = ['lookAndFeel', 'readability', 'intuitiveness', 'juice', 'fun', 'mobile', 'hud'];
+const PANEL_LABEL = { lookAndFeel: 'look and feel', readability: 'readability', intuitiveness: 'intuitiveness', juice: 'juice', fun: 'fun', mobile: 'mobile', hud: 'HUD' };
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+function run(rows, pick) {
+    const scored = rows.flatMap((r) => { const v = pick(r); return typeof v === 'number' && Number.isFinite(v) ? [{ n: r.n, v }] : []; });
+    const last = scored.slice(-STUCK_PLAYTESTS);
+    if (last.length < STUCK_PLAYTESTS || !last.every((x) => x.v < STUCK_BELOW))
+        return null;
+    return { scores: last.map((x) => Math.round(x.v * 10) / 10), playtests: last.map((x) => x.n) };
+}
+export function stuckScores(root, o = {}) {
+    const h = o.rows ?? readJson(join(root, STUCK_HISTORY_FILE))?.rounds;
+    const rows = Array.isArray(h) ? h.filter((r) => r && typeof r.n === 'number').sort((a, b) => a.n - b.n) : [];
+    if (rows.length < STUCK_PLAYTESTS)
+        return [];
+    const gdd = o.gdd !== undefined ? o.gdd : designDoc(root)?.text ?? null;
+    const named = gdd ? scoreExperience(gdd).addressed : null;
+    const out = [];
+    for (const d of DIMENSIONS) {
+        if (named && !named[d])
+            continue;
+        const r = run(rows, (x) => x.experience?.[d]);
+        if (r)
+            out.push({ kind: 'experience', axis: d, label: EXPERIENCE_LABEL[d], ...r });
+    }
+    for (const a of STUCK_PANEL_AXES) {
+        const r = run(rows, (x) => x.panel?.[a]);
+        if (r)
+            out.push({ kind: 'panel', axis: a, label: PANEL_LABEL[a], ...r });
+    }
+    return out.sort((a, b) => a.scores.at(-1) - b.scores.at(-1));
+}
+export function stuckLine(s) {
+    return `${s.label} ${s.scores.join(' · ')} (playtests ${s.playtests.join(', ')})`;
+}

package/plugins/codex/hooks/vendor/progress/holds.mjs

@@ -0,0 +1,107 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/progress/holds.ts by the GDK build. Do not edit.
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { evaluate, HOLD_LABELS, readPipeline, TIER_STAGES, worldRead } from '../pipeline/pipeline.mjs';
+import { readProgress } from './progress.mjs';
+import { madeOf } from '../look/made-of.mjs';
+export { HOLD_LABELS };
+const LABEL = new RegExp(`(^|: )(${HOLD_LABELS.join('|')}):`);
+const NO_HERO = /no (player|hero) node found|no hero on screen/i;
+export const ART_OUT = /\b(3d|models?|mesh(es)?|glb|art|sprites?|images?|textures?|pictures?|portraits?|characters?|cut-?outs?|assets?|generated|concepts?)\b/i;
+export const CODE_STANDIN = /\b(code|coded|primitives?|box(es)?|cubes?|capsules?|cylinders?|spheres?|placeholders?|procedural|gr[ae]y ?box(ed)?|shapes?|flat cut-?outs?)\b/i;
+export const ACCEPT_PICK = /^(accept(-?stand-?ins)?|stand-?ins|keep-stand-?ins|2d|2d-cut-?outs|cut-?outs|pause)$/i;
+const ART_WORD = String.raw `(stand-?ins?|primitives?|box(es)?|placeholders?|code[- ]built|shapes?|cut-?outs?|low[- ]?poly|blocky|flat shapes?)`;
+export const ACCEPT_WORDS = new RegExp(String.raw `\baccept\w*\b[^.]*\b${ART_WORD}\b|\b${ART_WORD}\b[^.]*\b(are|is)\b[^.]*\b(fine|ok|okay|good|accepted|the (style|look)|on purpose|intended|what I want)\b`, 'i');
+const ABOUT_ART = /\b(3d|models?|art|stand-?ins?|primitives?|box(es)?|cut-?outs?|sprites?|images?|generat\w*|provider|look)\b/i;
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+const short = (s, n = 160) => (s.length <= n ? s : `${s.slice(0, n - 1)}…`);
+const PLAYABLE = new Set(TIER_STAGES.deep.slice(TIER_STAGES.deep.indexOf('slice')));
+export function builtAndPlays(root, fp) {
+    const v = readJson(join(root, 'verify.json'));
+    if (v?.verdict === 'pass' && (!fp || !v.fingerprint || v.fingerprint === fp))
+        return true;
+    return existsSync(join(root, 'dist', 'index.html'));
+}
+export function isThree(m) {
+    const d = m?.metadata?.dimension;
+    return d === '3d' || (!d && /three/i.test(String(m?.metadata?.framework ?? '')));
+}
+function stageOf(root, fp, s) {
+    const p = readPipeline(root);
+    if (p) {
+        try {
+            const e = evaluate(root, p, fp);
+            if (e.current)
+                return e.current.stage.id;
+            return 'done';
+        }
+        catch { }
+    }
+    return s.last?.stage ?? null;
+}
+export function worldHolds(root, fp) {
+    const w = worldRead(root, fp);
+    const m = readJson(join(root, 'funpixel.json')) ?? {};
+    const three = isThree(m);
+    const out = [];
+    if (three) {
+        let made = null;
+        try {
+            made = madeOf(root, { manifest: m });
+        }
+        catch { }
+        if (made?.verdict === 'fail')
+            out.push({ kind: 'world', line: short(`HERO OBJECTS ARE CODE (look --3d): ${made.says} — take the hero route (generated models, skill funpixel-3d, references/hero-route.md), or declare a procedural style in funpixel.json "art3d" { "heroes": "procedural", "why", "proof": "<frame>" }`, 320) });
+    }
+    if (w.state === 'failing') {
+        for (const x of w.warns)
+            if (LABEL.test(x) || NO_HERO.test(x))
+                out.push({ kind: 'world', line: short(NO_HERO.test(x) && !LABEL.test(x) ? `NO HERO IN THE SCENE: ${x}` : x) });
+    }
+    else if (three && (w.state === 'open' || w.state === 'stale')) {
+        out.push({ kind: 'world', unread: true, line: `the world was never read on these files (${w.says}): run \`npx @funpixel/tools check --world\` (boxes, grounding, life) before handing back` });
+    }
+    return [...new Map(out.map((h) => [h.line, h])).values()].slice(0, 8);
+}
+export function artHolds(s) {
+    const out = [];
+    const outs = [...new Set(s.cards.flatMap((c) => c.out ?? []))].filter((o) => ART_OUT.test(o));
+    const standins = [...new Set(s.cards.flatMap((c) => c.standins ?? []))].filter((x) => CODE_STANDIN.test(x));
+    for (const o of outs)
+        out.push({ kind: 'art', line: `generated art listed as out: "${short(o, 100)}" — retry it, switch provider or tier, make 2D cut-outs from the locked sheets, or ask the person (\`npx @funpixel/tools progress ask "<what failed>: retry / 2D cut-outs from the locked sheets / pause" --kind scope --options retry,cutouts,pause\`)` });
+    for (const x of standins)
+        out.push({ kind: 'art', line: `code stand-in where generated art belongs: "${short(x, 100)}"` });
+    return out;
+}
+export function ownerRelease(root, s, stage) {
+    const ans = [...s.questions].reverse().find((q) => q.answer?.by === 'owner' && ACCEPT_PICK.test(q.answer.pick));
+    if (ans)
+        return `the owner answered ${ans.id}: ${ans.answer.pick}`;
+    const p = readPipeline(root);
+    const note = (p?.notes ?? []).find((n) => n.by === 'owner' && ACCEPT_WORDS.test(n.text));
+    if (note)
+        return `the owner's note ${note.id}: "${short(note.text, 100)}"`;
+    const v = [...(p?.verdicts ?? [])].reverse().find((x) => x.stage === stage);
+    if (v?.says === 'accept')
+        return `the owner accepted ${stage}${v.words ? `: "${short(v.words, 80)}"` : ''}`;
+    return null;
+}
+export function handBackHolds(root, fp, s = readProgress(root)) {
+    const stage = stageOf(root, fp, s);
+    const playable = (stage !== null && (PLAYABLE.has(stage) || stage === 'done')) || builtAndPlays(root, fp);
+    const holds = [...(playable ? worldHolds(root, fp) : []), ...artHolds(s)];
+    if (!holds.length)
+        return { holds, released: null, waiting: null, stage };
+    const released = ownerRelease(root, s, stage);
+    const ask = s.open.find((q) => q.kind === 'scope' && ABOUT_ART.test(q.text));
+    return { holds, released, waiting: ask ? `${ask.id} (scope) waits for the person: "${short(ask.text, 100)}"` : null, stage };
+}
+export const holding = (h) => (h.released || h.waiting ? [] : h.holds);
+export function holdMessage(h) {
+    return `NOT DONE — the hand-back holds on:\n${h.map((x) => `- ${x.line}`).join('\n')}\nFix them (generated art in the world, \`npx @funpixel/tools check --world\` passing), or ask the person (\`npx @funpixel/tools progress ask … --kind scope\`). Only the owner accepts stand-ins.`;
+}

package/plugins/codex/hooks/vendor/progress/progress.mjs

@@ -0,0 +1,301 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/progress/progress.ts by the GDK build. Do not edit.
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export const PROGRESS_FILE = join('.funtools', 'progress.jsonl');
+export const FORK_KINDS = ['taste', 'spend', 'scope'];
+const ms = (iso) => { const t = iso ? Date.parse(iso) : NaN; return Number.isFinite(t) ? t : 0; };
+export function readEntries(root) {
+    let text = '';
+    try {
+        text = readFileSync(join(root, PROGRESS_FILE), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            if (e && (e.type === 'card' || e.type === 'ask' || e.type === 'answer'))
+                out.push(e);
+        }
+        catch { }
+    }
+    return out;
+}
+export function appendEntry(root, e) {
+    const p = join(root, PROGRESS_FILE);
+    mkdirSync(dirname(p), { recursive: true });
+    appendFileSync(p, JSON.stringify(e) + '\n');
+}
+export function fold(entries) {
+    const cards = entries.filter((e) => e.type === 'card');
+    const answers = entries.filter((e) => e.type === 'answer');
+    const dropped = cards.filter((c) => c.kind === 'dropped' && c.dropped_by === 'owner').at(-1) ?? null;
+    const questions = entries.filter((e) => e.type === 'ask').map((a) => {
+        const mine = answers.filter((x) => x.q === a.id);
+        const answer = mine.at(-1) ?? null;
+        const state = !answer && dropped && ms(a.at) <= ms(dropped.at) ? 'dropped' : !answer ? 'open'
+            : answer.by === 'default' ? 'defaulted'
+                : mine.some((x) => x.by === 'default') ? 'reversed' : 'answered';
+        return { ...a, answers: mine, answer, state, due: a.default !== undefined && a.timeout_ms ? ms(a.at) + a.timeout_ms : null };
+    });
+    return {
+        cards, questions, open: questions.filter((q) => q.state === 'open'),
+        last: cards.at(-1) ?? null, lastObserved: [...cards].reverse().find((c) => c.observed) ?? null, dropped,
+    };
+}
+export const readProgress = (root) => fold(readEntries(root));
+export const nextCard = (s) => (s.cards.at(-1)?.n ?? 0) + 1;
+export const nextQuestion = (s) => `Q${s.questions.reduce((m, q) => Math.max(m, Number(/^Q(\d+)$/.exec(q.id)?.[1] ?? 0)), 0) + 1}`;
+export function heartbeatsOn(s, stage) {
+    let n = 0;
+    for (const c of [...s.cards].reverse()) {
+        if (c.kind === 'decided' || c.kind === 'waiting')
+            continue;
+        if (c.kind !== 'heartbeat' || c.stage !== stage)
+            break;
+        n++;
+    }
+    return n;
+}
+export function unheard(s) {
+    const heard = new Set(s.cards.flatMap((c) => (c.heard ?? []).map((h) => `${h.q}@${h.at}`)));
+    return s.questions.flatMap((q) => q.answers).filter((a) => !heard.has(`${a.q}@${a.at}`));
+}
+export function closedNotesSince(root, since) {
+    let p = null;
+    try {
+        p = JSON.parse(readFileSync(join(root, 'design', 'pipeline.json'), 'utf8'));
+    }
+    catch {
+        return [];
+    }
+    const pic = (x) => (typeof x === 'string' && /\.(png|jpe?g|webp|gif)$/i.test(x) ? x : undefined);
+    return (Array.isArray(p?.notes) ? p.notes : [])
+        .filter((n) => n && n.by === 'owner' && n.status === 'closed' && n.closed_by && ms(n.closed_by.at) > since)
+        .map((n) => ({ id: String(n.id), text: String(n.text ?? ''), ...(pic(n.screenshot) ? { before: n.screenshot } : {}), ...(pic(n.closed_by.evidence) ? { after: n.closed_by.evidence } : {}), ...(n.closed_by.forced ? { forced: true } : {}) }));
+}
+export function unpickedNotes(root, s) {
+    let p = null;
+    try {
+        p = JSON.parse(readFileSync(join(root, 'design', 'pipeline.json'), 'utf8'));
+    }
+    catch {
+        return [];
+    }
+    const picked = new Set(s.cards.flatMap((c) => (c.picked ?? []).map((x) => x.id)));
+    return (Array.isArray(p?.notes) ? p.notes : [])
+        .filter((n) => n && n.by === 'owner' && (n.status === 'open' || (n.status !== 'dropped' && n.verdict?.says === 'reject')) && !picked.has(n.id))
+        .map((n) => ({ id: String(n.id), text: String(n.text ?? ''), stage: String(n.stage ?? '') }));
+}
+export const BUDGET_TOPIC = 'flow:budget';
+export const PITCH_BUDGET_TOPIC = 'pitch:budget';
+export function budgetPick(pick) {
+    if (pick === null || pick === undefined || pick === '')
+        return null;
+    if (pick === 'free' || pick === 'free-only' || pick === 'code-drawn')
+        return 0;
+    if (pick === 'open')
+        return 'open';
+    const n = typeof pick === 'number' ? pick : /^\s*\d+\s*$/.test(String(pick)) ? Number(pick) : NaN;
+    return Number.isInteger(n) && n >= 0 ? n : null;
+}
+export function ownerBudgetAnswer(s) {
+    const qs = s.questions.filter((q) => (q.topic === BUDGET_TOPIC || q.topic === PITCH_BUDGET_TOPIC) && q.answer?.by === 'owner')
+        .sort((a, b) => ms(a.answer.at) - ms(b.answer.at));
+    for (const q of qs.reverse()) {
+        const v = budgetPick(q.answer.pick);
+        if (v !== null)
+            return { q, value: v };
+    }
+    return null;
+}
+export function manifestBudget(root) {
+    try {
+        const b = JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8'))?.assets?.budget;
+        if (b?.open === true)
+            return { value: 'open', by: String(b.by ?? ''), at: String(b.at ?? '') };
+        return b && Number.isFinite(b.credits) && b.credits >= 0 ? { value: b.credits, by: String(b.by ?? ''), at: String(b.at ?? '') } : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function budgetOf(root, ps) {
+    const m = manifestBudget(root);
+    if (m)
+        return m.value === 'open' ? null : m.value;
+    const st = ps ?? readProgress(root);
+    const a = ownerBudgetAnswer(st);
+    if (a)
+        return a.value === 'open' ? null : a.value;
+    return null;
+}
+export function effectiveBudget(root, s) {
+    const b = budgetOf(root, s);
+    if (b === null)
+        return null;
+    const spend = s.questions.filter((q) => q.kind === 'spend');
+    if (spend.some((q) => q.answer?.pick === 'free-only'))
+        return null;
+    return b + spend.filter((q) => q.answer?.pick === 'raise').length * Math.max(b, 100);
+}
+export function autonomyOf(root) {
+    const ok = (a) => (a === 'ask' || a === 'plan-then-go' || a === 'go' ? a : null);
+    try {
+        const m = JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8'));
+        const a = ok(m?.flow?.autonomy);
+        if (a)
+            return a;
+    }
+    catch { }
+    return 'plan-then-go';
+}
+export function parseDuration(s) {
+    if (s === undefined)
+        return null;
+    const m = /^\s*(\d+(?:\.\d+)?)\s*(ms|s|m|min|h)?\s*$/i.exec(s);
+    if (!m)
+        return null;
+    const n = Number(m[1]), u = (m[2] ?? 'm').toLowerCase();
+    return Math.round(n * (u === 'ms' ? 1 : u === 's' ? 1000 : u === 'h' ? 3_600_000 : 60_000));
+}
+export const minutes = (msN) => (msN < 60_000 ? `${Math.max(0, Math.round(msN / 1000))} s` : `${Math.round(msN / 60_000)} min`);
+export const FIRST_FRAME_MS = 10 * 60_000;
+export const HEARTBEAT_MS = 20 * 60_000;
+const T = 'npx @funpixel/tools';
+export function cardPrompt(stage) {
+    return `Show the person this move: capture the built game (\`${T} capture\`), then \`${T} progress card --stage ${stage} --shot last --line "<what changed>" --next "<what's next>"\`. A card with no frame says "not observed"; it is never filled with a target picture.`;
+}
+export function cadence(root, o) {
+    const s = readProgress(root);
+    const lines = [], said = [];
+    const once = (key, line) => { if (!o.said[key]) {
+        lines.push(line);
+        said.push(key);
+    } };
+    const seen = s.cards.some((c) => c.observed && (c.shot || c.clip) && ms(c.at) >= o.start);
+    const quiet = Math.max(o.start || 0, o.spoke ?? 0);
+    if (o.start && o.now - quiet >= FIRST_FRAME_MS && !seen) {
+        once('first', `The person has seen nothing for ${minutes(o.now - quiet)}. Get the first visible result in front of them: a built frame of the game, even standing still on the real camera (\`${T} capture\`, then \`${T} progress card --stage ${o.stage ?? '<stage>'} --shot last --line "it boots: …"\`).`);
+    }
+    const lastAt = Math.max(quiet, o.stageMovedAt ?? 0, ms(s.last?.at));
+    if (lastAt && o.now - lastAt >= HEARTBEAT_MS) {
+        const beats = o.stage ? heartbeatsOn(s, o.stage) : 0;
+        once(`beat@${lastAt}`, `${minutes(o.now - lastAt)} on ${o.stage ?? 'this stage'} with no card: post a heartbeat with a fresh frame (\`${T} progress heartbeat --shot last --tried "<what you tried>"\`).${beats >= 2 ? ' It is the third on this gate, so it becomes a stuck card asking the person: skip, cut or keep going.' : ''}`);
+    }
+    for (const a of unheard(s)) {
+        if (a.by !== 'owner')
+            continue;
+        const q = s.questions.find((x) => x.id === a.q);
+        once(`ans@${a.q}@${a.at}`, `The person answered ${a.q} (${q?.kind ?? 'fork'}: "${(q?.text ?? '').slice(0, 80)}"): ${a.pick}${a.words ? ` — "${a.words.slice(0, 120)}"` : ''}${q?.state === 'reversed' ? ' (reversing the default you took)' : ''}. Act on it; your next card says you heard it.`);
+    }
+    return { lines, said };
+}
+export function atStop(root, o) {
+    const s = readProgress(root);
+    const out = [];
+    if (o.stageMovedAt && ms(s.last?.at) < o.stageMovedAt)
+        out.push(`the last progress card is older than the last stage move${o.stage ? ` (now ${o.stage})` : ''}: post one with a frame so the person sees where it stands (\`${T} progress card\`)`);
+    for (const q of s.open) {
+        const left = q.due ? q.due - o.now : null;
+        out.push(`question ${q.id} (${q.kind}) is unanswered: "${q.text.slice(0, 100)}"${q.default ? `; ${left !== null && left > 0 ? `the default (${q.default}) lands in ${minutes(left)}` : `the default (${q.default}) is due: \`${T} progress wait ${q.id}\` takes it under autonomy go`}` : '; say in the hand-back that it waits for the person'}`);
+    }
+    return out;
+}
+export const LIST_PRICE = { model3d: 160, image: 4, sound: 2, music: 16 };
+export const HERO_CORE_MODELS = 3;
+export const BUILD_STAGES = ['prototype', 'slice'];
+export const REFUSAL = 'fallback shapes are not a game; raise the cap, remove it, or choose a 2D/code-drawn look on purpose';
+const fpx = (root) => { try {
+    return JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8'));
+}
+catch {
+    return {};
+} };
+const up100 = (n) => Math.max(100, Math.ceil(n / 100) * 100);
+export const isThree = (root) => { const m = fpx(root); return m.metadata?.dimension === '3d' || /three/i.test(String(m.metadata?.framework ?? '')); };
+const MAKES = {
+    '3d:small': { models: 4, images: 8, sounds: 10, music: 1 }, '3d:mid': { models: 8, images: 16, sounds: 16, music: 2 }, '3d:deep': { models: 12, images: 24, sounds: 24, music: 3 },
+    '2d:small': { models: 0, images: 20, sounds: 10, music: 1 }, '2d:mid': { models: 0, images: 40, sounds: 16, music: 2 }, '2d:deep': { models: 0, images: 80, sounds: 24, music: 3 },
+};
+export function planPrice(root) {
+    let items = [];
+    try {
+        const d = JSON.parse(readFileSync(join(root, 'assets', 'assets.json'), 'utf8'));
+        items = Array.isArray(d) ? d : Array.isArray(d?.items) ? d.items : Array.isArray(d?.assets) ? d.assets : [];
+    }
+    catch { }
+    if (!items.length) {
+        const n = budgetNeed(root);
+        return { credits: n.recommended, says: `the tier's estimate: ${n.says}` };
+    }
+    const count = { model3d: 0, image: 0, sound: 0, music: 0 };
+    for (const it of items) {
+        const k = String(it?.kind ?? '');
+        if (k === 'model3d' || k === 'rig' || k === 'parts')
+            count.model3d++;
+        else if (k === 'sound')
+            count.sound++;
+        else if (k === 'music')
+            count.music++;
+        else
+            count.image++;
+    }
+    const credits = count.model3d * LIST_PRICE.model3d + count.image * LIST_PRICE.image + count.sound * LIST_PRICE.sound + count.music * LIST_PRICE.music;
+    return { credits, says: `the asset list: ${count.model3d} models × ${LIST_PRICE.model3d} + ${count.image} pictures × ${LIST_PRICE.image} + ${count.sound} sounds × ${LIST_PRICE.sound} + ${count.music} music × ${LIST_PRICE.music}` };
+}
+export function budgetNeed(root) {
+    const three = isThree(root);
+    const t = fpx(root).production?.tier;
+    const n = MAKES[`${three ? '3d' : '2d'}:${t === 'small' || t === 'deep' ? t : 'mid'}`];
+    const rest = n.images * LIST_PRICE.image + n.sounds * LIST_PRICE.sound + n.music * LIST_PRICE.music;
+    const total = n.models * LIST_PRICE.model3d + rest;
+    const heroCore = three ? HERO_CORE_MODELS * LIST_PRICE.model3d : null;
+    const says = `${n.models ? `${n.models} 3D models × ${LIST_PRICE.model3d} + ` : ''}${n.images} pictures × ${LIST_PRICE.image} + ${n.sounds} sounds × ${LIST_PRICE.sound} + ${n.music} music tracks × ${LIST_PRICE.music} = ${total} credits at list price`;
+    return { three, recommended: up100(total), floor: heroCore === null ? null : up100(heroCore + rest), heroCore, says };
+}
+export function settledBudget(root, s = readProgress(root)) {
+    const m = manifestBudget(root);
+    if (m)
+        return m.value === 'open' ? { state: 'open', by: m.by } : { state: 'set', credits: m.value, by: m.by };
+    const a = ownerBudgetAnswer(s);
+    if (a)
+        return a.value === 'open' ? { state: 'open', by: `the owner (${a.q.id})` } : { state: 'set', credits: a.value, by: `the owner (${a.q.id})` };
+    const q = s.questions.filter((x) => x.topic === BUDGET_TOPIC).at(-1);
+    return { state: 'unset', asking: q && q.state === 'open' ? q.id : null };
+}
+export const budgetLine = (b) => b.state === 'set' ? `${b.credits} credits, set by ${b.by}` : b.state === 'open' ? `no cap, set by ${b.by}` : b.asking ? `not set yet (${b.asking} waits on the owner)` : 'none: the account\'s credits (out of credits is a pause: the owner tops up, the build goes on)';
+export function writeAgreedBudget(root, value, by, o = {}) {
+    const p = join(root, 'funpixel.json');
+    const j = fpx(root);
+    const at = (o.now ?? new Date()).toISOString();
+    j.assets = { ...(j.assets ?? {}), budget: value === 'open' ? { open: true, by, at } : { credits: value, by, at } };
+    if (o.codeDrawn)
+        j.art3d = { ...(j.art3d ?? {}), heroes: 'procedural', by: 'owner', why: `a code-drawn look on purpose (${by})` };
+    writeFileSync(p, JSON.stringify(j, null, 2) + '\n');
+}
+export function foldBudget(root, s = readProgress(root)) {
+    if (manifestBudget(root))
+        return false;
+    const a = ownerBudgetAnswer(s);
+    if (!a)
+        return false;
+    writeAgreedBudget(root, a.value, `the owner (${a.q.id})`, { codeDrawn: a.q.answer.pick === 'code-drawn', now: new Date(ms(a.q.answer.at) || Date.now()) });
+    return true;
+}
+export function buildRefusal(root, stage, s = readProgress(root)) {
+    if (!stage || !BUILD_STAGES.includes(stage) || !isThree(root))
+        return null;
+    const a = fpx(root).art3d;
+    if (a?.by === 'owner' && a.heroes === 'procedural')
+        return null;
+    const b = settledBudget(root, s);
+    const hc = HERO_CORE_MODELS * LIST_PRICE.model3d;
+    if (b.state !== 'set' || b.credits >= hc)
+        return null;
+    return { says: `the owner's cap of ${b.credits} credits (${b.by}) cannot buy the hero and the core models (${HERO_CORE_MODELS} × ${LIST_PRICE.model3d} = ${hc} credits): ${REFUSAL}`, asking: null };
+}