@funpixel/tools 0.0.0-stage → 0.1.1

package/plugins/kiro/hooks/vendor/sim/judge.mjs

@@ -0,0 +1,241 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/sim/judge.ts by the GDK build. Do not edit.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const TAUGHT_WINS = 0.5;
+export const NOVICE_FLOOR = 0.8;
+export const CEILING_SHARE = 0.9;
+export const CEILING_TIME = 1.25;
+export const IDLE_SHARE = 0.5;
+export const byRole = (cohorts, role) => cohorts.find((c) => c.role === role && !c.human) ?? cohorts.find((c) => c.role === role);
+const pct = (a, b) => (b > 0 ? Math.round((100 * a) / b) : 0);
+const rate = (c) => (c.seeds > 0 ? c.won / c.seeds : 0);
+export function invalid(out) {
+    const o = out;
+    if (!o || typeof o !== 'object')
+        return 'the probe printed no JSON object';
+    if (o.probes !== 1)
+        return 'the JSON is not a probe run ({ "probes": 1, "cohorts": [...] })';
+    if (!Array.isArray(o.cohorts))
+        return 'the probe run has no cohorts';
+    for (const c of o.cohorts)
+        if (!c || typeof c.policy !== 'string' || typeof c.seeds !== 'number' || !c.progress)
+            return `a cohort is malformed (${JSON.stringify(c).slice(0, 80)})`;
+    return null;
+}
+export const STALLED_SHARE = 1.25;
+export function stalledBot(cohorts) {
+    const skilled = byRole(cohorts, 'skilled');
+    if (!skilled)
+        return null;
+    const next = 'fix the sharp policy first (replay a seed and watch where it stops: a target it cannot reach, an input the rules ignore, a timer that never fires); the ceiling, length and moments read the bot until then';
+    if (skilled.progress.max <= 0 && skilled.won === 0)
+        return { id: 'bot', state: 'warn', says: `bot broken: the sharp bot (${skilled.says}) made no progress on any of ${skilled.seeds} seeds in ${skilled.seconds} s`, next };
+    const better = cohorts.filter((c) => c.role !== 'skilled' && !c.human && c.progress.mean > STALLED_SHARE * skilled.progress.mean && c.won >= skilled.won)
+        .sort((a, b) => b.progress.mean - a.progress.mean)[0];
+    if (better)
+        return { id: 'bot', state: 'warn', says: `bot broken: the ${better.role} player gets ${pct(better.progress.mean, skilled.progress.mean)}% as far as the sharp bot (progress ${better.progress.mean} vs ${skilled.progress.mean}), so the sharp bot stalls`, next };
+    return null;
+}
+export function judgeCohorts(cohorts, noviceFloor = NOVICE_FLOOR) {
+    const by = (r) => byRole(cohorts, r);
+    const idle = by('idle'), naive = by('naive'), taught = by('taught'), skilled = by('skilled'), novice = by('novice');
+    const out = [];
+    const stalled = stalledBot(cohorts);
+    if (stalled)
+        out.push(stalled);
+    if (!idle)
+        out.push({ id: 'idle', state: 'not measured', says: 'no idle policy: whether standing still wins was never played' });
+    else if (idle.won > 0)
+        out.push({ id: 'idle', state: 'warn', says: `standing still wins ${idle.won}/${idle.seeds} seeds`, next: 'let a threat or the clock end an idle run; a phone player idles while reading the screen and should not win for it' });
+    else if (skilled && skilled.progress.mean > 0 && idle.progress.mean >= IDLE_SHARE * skilled.progress.mean)
+        out.push({ id: 'idle', state: 'warn', says: `standing still gets ${pct(idle.progress.mean, skilled.progress.mean)}% as far as the sharp bot (progress ${idle.progress.mean} vs ${skilled.progress.mean})`, next: 'waves that clear themselves or points that accrue untouched: make progress come from the verb' });
+    else
+        out.push({ id: 'idle', state: 'ok', says: `standing still does not win (${idle.lost} lost, ${idle.open} unfinished of ${idle.seeds}; progress ${idle.progress.mean})` });
+    if (!naive || !skilled)
+        out.push({ id: 'skill-ceiling', state: 'not measured', says: `no ${!naive ? 'naive' : 'skilled'} policy: the gap between steering at the target and playing well was never measured` });
+    else if (stalled)
+        out.push({ id: 'skill-ceiling', state: 'not measured', says: 'the sharp bot is broken, so the gap between steering at the target and playing well was not measured' });
+    else {
+        const own = 'on purpose (a toy, a relaxed game, a race against the clock)? say so in the design note; else give the verb something to master: a risk that pays, a line to read, a combo';
+        const slower = skilled.meanSeconds > 0 ? naive.meanSeconds / skilled.meanSeconds : 1;
+        if (rate(naive) >= CEILING_SHARE && rate(skilled) >= CEILING_SHARE) {
+            out.push(slower < CEILING_TIME
+                ? { id: 'skill-ceiling', state: 'note', says: `no skill ceiling: the naive player (${naive.says}) wins ${naive.won}/${naive.seeds} as fast as the sharp one (${naive.meanSeconds} s vs ${skilled.meanSeconds} s)`, next: own }
+                : { id: 'skill-ceiling', state: 'note', says: `the win holds no challenge: the naive player (${naive.says}) wins ${naive.won}/${naive.seeds}; skill shows only as time (${naive.meanSeconds} s vs ${skilled.meanSeconds} s)`, next: own });
+        }
+        else if (skilled.progress.mean > 0 && naive.progress.mean >= CEILING_SHARE * skilled.progress.mean && Math.abs(rate(naive) - rate(skilled)) <= 0.1) {
+            out.push({ id: 'skill-ceiling', state: 'note', says: `no skill ceiling: the naive player gets ${pct(naive.progress.mean, skilled.progress.mean)}% as far as the sharp one (progress ${naive.progress.mean} vs ${skilled.progress.mean})`, next: own });
+        }
+        else
+            out.push({ id: 'skill-ceiling', state: 'ok', says: `playing well goes further: progress ${skilled.progress.mean} vs ${naive.progress.mean}, wins ${skilled.won} vs ${naive.won} of ${skilled.seeds}` });
+    }
+    const base = naive ?? idle;
+    if (!taught)
+        out.push({ id: 'taught', state: 'not measured', says: 'no taught policy: whether doing what the game teaches pays was never played' });
+    else if (base && (rate(taught) < rate(base) - 0.1 || taught.progress.mean < CEILING_SHARE * base.progress.mean)) {
+        out.push({ id: 'taught', state: 'warn', says: `doing what the game teaches (${taught.says}) does worse than the ${base.role} player: progress ${taught.progress.mean} vs ${base.progress.mean}, wins ${taught.won} vs ${base.won}`, next: 'the tutorial teaches a losing line, or the mechanic hurts the player who uses it: check the reward reaches them and they are safe from their own move' });
+    }
+    else if (skilled && skilled.won > 0 && rate(taught) < TAUGHT_WINS) {
+        out.push({ id: 'taught', state: 'warn', says: `doing what the game teaches (${taught.policy}: ${taught.says}) wins only ${taught.won}/${taught.seeds} where the sharp policy wins ${skilled.won}/${skilled.seeds} (progress ${taught.progress.mean} vs ${skilled.progress.mean})`, next: 'the lesson alone does not get a player through: teach what the winning player does, give the taught line more room (longer tells, a wider window), or ease the defaults' });
+    }
+    else
+        out.push({ id: 'taught', state: 'ok', says: `doing what the game teaches pays: progress ${taught.progress.mean}, wins ${taught.won}/${taught.seeds}` });
+    if (skilled && skilled.won === 0 && skilled.lost > 0)
+        out.push({ id: 'winnable', state: 'note', says: `the sharp bot never wins in ${skilled.seconds} s (${skilled.lost} lost): a win may be out of reach, or the bot is weak` });
+    else if (skilled && skilled.won > 0)
+        out.push({ id: 'winnable', state: 'ok', says: `the sharp bot wins ${skilled.won}/${skilled.seeds}` });
+    if (!novice)
+        out.push({ id: 'novice', state: 'not measured', says: 'no novice policy: the first-success floor was never played' });
+    else if (novice.firstSuccess === null)
+        out.push({ id: 'novice', state: 'not measured', says: 'the game names no first success (ProbeGame.firstSuccess)' });
+    else {
+        const ok = novice.firstSuccess >= noviceFloor * novice.seeds;
+        out.push({ id: 'novice', state: ok ? 'ok' : 'warn', says: `the novice (${novice.says}) reaches the first success on ${novice.firstSuccess}/${novice.seeds} seeds (the skill's floor: ${Math.round(noviceFloor * 100)}%)`, ...(ok ? {} : { next: 'fix controls, safe introductions and warning time before lowering every enemy\'s health; freeze the novice before tuning' }) });
+    }
+    const checked = cohorts.filter((c) => c.broken !== undefined);
+    const broke = checked.find((c) => c.broken);
+    if (broke?.broken)
+        out.push({ id: 'broken', state: 'warn', says: `${broke.broken.what}: ${broke.policy} policy, seed ${broke.broken.seed}, at ${broke.broken.at} s`, next: 'replay that seed; the worst case matters, not the average' });
+    else if (checked.length)
+        out.push({ id: 'broken', state: 'ok', says: `the game's never-happens check held for ${checked.map((c) => c.policy).join(', ')}` });
+    else
+        out.push({ id: 'broken', state: 'not measured', says: 'no broken() check (NaN, off the map, inside a wall)' });
+    return out;
+}
+export function judgeMoments(moments = []) {
+    return moments.map((m) => {
+        const [best, next] = m.candidates ?? [];
+        if (!best || best.score <= 0)
+            return { id: `moment:${m.name}`, state: 'note', says: `no seed staged a ${m.name} moment in the search`, next: 'widen the seeds or start times, or check the score counts the payoff event' };
+        return {
+            id: `moment:${m.name}`, state: 'ok',
+            says: `best ${m.name}${m.says ? ` (${m.says})` : ''}: seed ${best.seed} at ${best.at} s, score ${best.score}${next ? `; next ${next.score}` : ''}`,
+            next: `the moment view's enter() can replay it: replayTo(game, policy, ${best.seed}, ${best.at}), so capture shoots a real payoff`,
+        };
+    });
+}
+export function correlation(a, b) {
+    const n = Math.min(a.length, b.length);
+    if (n < 3)
+        return null;
+    const ma = a.slice(0, n).reduce((s, x) => s + x, 0) / n, mb = b.slice(0, n).reduce((s, x) => s + x, 0) / n;
+    let ab = 0, aa = 0, bb = 0;
+    for (let i = 0; i < n; i++) {
+        ab += (a[i] - ma) * (b[i] - mb);
+        aa += (a[i] - ma) ** 2;
+        bb += (b[i] - mb) ** 2;
+    }
+    return aa < 1e-9 || bb < 1e-9 ? null : Math.round((ab / Math.sqrt(aa * bb)) * 100) / 100;
+}
+export function judgeTimelines(timelines = []) {
+    const out = [];
+    for (const tl of timelines)
+        for (const f of tl.follow ?? []) {
+            const id = `music:${tl.name}:${f.layer}`;
+            const layer = tl.rows.map((r) => r[f.layer]).filter((v) => typeof v === 'number');
+            const driver = tl.rows.map((r) => r[f.driver]).filter((v) => typeof v === 'number');
+            const span = (xs) => (xs.length ? Math.max(...xs) - Math.min(...xs) : 0);
+            const secs = tl.rows.at(-1)?.t ?? 0;
+            if (layer.length < 4 || driver.length < 4) {
+                out.push({ id, state: 'not measured', says: `${tl.name}: too few samples of ${f.layer} and ${f.driver}` });
+                continue;
+            }
+            if (span(layer) < 0.05) {
+                out.push({ id, state: 'warn', says: `${tl.name}: the ${f.layer} layer never moved in ${secs} s of play`, next: 'the mix does not follow play: raise the layer with what it names, or drop the claim' });
+                continue;
+            }
+            const r = correlation(layer, driver);
+            if (r === null)
+                out.push({ id, state: 'not measured', says: `${tl.name}: ${f.driver} never changed, so nothing to follow` });
+            else if (r < 0.3)
+                out.push({ id, state: 'note', says: `${tl.name}: ${f.layer} moves but not with ${f.driver} (r = ${r} over ${layer.length} samples)`, next: 'check what drives the layer: a mix on a timer reads as a playlist' });
+            else
+                out.push({ id, state: 'ok', says: `${tl.name}: ${f.layer} follows ${f.driver} (r = ${r} over ${layer.length} samples)` });
+        }
+    return out;
+}
+export const SHORT_RUN_SECONDS = 60;
+export function perMinute(c) {
+    const total = Object.values(c.events ?? {}).reduce((a, b) => a + b, 0);
+    return c.meanSeconds > 0 ? Math.round((total / c.meanSeconds) * 600) / 10 : 0;
+}
+const mmss = (secs) => { const s = Math.round(secs); return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`; };
+export function judgeDepth(cohorts) {
+    const out = [];
+    for (const role of ['skilled', 'novice']) {
+        const c = byRole(cohorts, role);
+        if (!c || !(c.meanSeconds > 0))
+            continue;
+        const kinds = Object.entries(c.events ?? {}).sort((a, b) => b[1] - a[1]).slice(0, 4)
+            .map(([k, v]) => `${k} ${Math.round((v / c.meanSeconds) * 600) / 10}`).join(', ');
+        const says = `${role}: a run lasts ${mmss(c.meanSeconds)} and ${perMinute(c)} events a minute${kinds ? ` (${kinds})` : ''}`;
+        if (c.lost >= c.seeds / 2 && c.meanSeconds < SHORT_RUN_SECONDS) {
+            out.push({ id: `depth:${role}`, state: 'note', says: `${says}; ${c.lost}/${c.seeds} runs end lost in under a minute`, next: 'a run under a minute is a demo in most genres (depth.md run length): warning time, a safer start or a slower ramp, before cutting the threat' });
+        }
+        else
+            out.push({ id: `depth:${role}`, state: 'ok', says, ...(kinds ? {} : { next: 'the policy steps return no events: count eats, pickups and decisions to measure density' }) });
+    }
+    return out;
+}
+export const PLAY_FLOOR = 900;
+export const DEFAULT_FLOOR = { seconds: PLAY_FLOOR, where: 'a complete game' };
+export function playFloor(root) {
+    try {
+        const n = Number(JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8'))?.play_min_minutes);
+        if (Number.isFinite(n) && n > 0)
+            return { seconds: Math.round(n * 60), where: 'this game (funpixel.json play_min_minutes)' };
+    }
+    catch { }
+    return DEFAULT_FLOOR;
+}
+const ON_PURPOSE = /\bon purpose\b|\bby design\b|\bdeliberate(?:ly)?\b/i;
+export function statedLength(text, where = 'the design doc') {
+    const m = /play[ -]length\W{0,8}(?:about |~|≈)?(\d+(?:\.\d+)?)(?::(\d\d))?(?:\s*[–-]\s*\d+(?:\.\d+)?)?\s*(min(?:ute)?s?\b|m\b|s\b|sec(?:ond)?s?\b)?/i.exec(text);
+    if (!m) {
+        const body = /^#{1,4}\s*play[ -]length\b[^\n]*\n([\s\S]{0,400})/im.exec(text)?.[1] ?? '';
+        const n = /(\d+(?:\.\d+)?)(?:\s*(?:to|–|-)\s*\d+(?:\.\d+)?)?\s*(min(?:ute)?s?\b|s\b|sec(?:ond)?s?\b)/i.exec(body);
+        return n ? { seconds: /^s/i.test(n[2]) ? Number(n[1]) : Number(n[1]) * 60, where, ...(ON_PURPOSE.test(body) ? { onPurpose: true } : {}) } : null;
+    }
+    const seconds = m[2] !== undefined ? Number(m[1]) * 60 + Number(m[2]) : m[3] && /^s/i.test(m[3]) ? Number(m[1]) : m[3] ? Number(m[1]) * 60 : 0;
+    const at = m.index + m[0].length - 1, eol = text.indexOf('\n', at);
+    const line = text.slice(text.lastIndexOf('\n', at) + 1, eol < 0 ? text.length : eol);
+    return seconds > 0 ? { seconds, where, ...(ON_PURPOSE.test(line) ? { onPurpose: true } : {}) } : null;
+}
+export function judgeLength(cohorts, stated = null, floor = DEFAULT_FLOOR) {
+    const skilled = byRole(cohorts, 'skilled');
+    if (!skilled || !(skilled.meanSeconds > 0))
+        return { id: 'length', state: 'not measured', says: 'no skilled policy: how long a good run lasts was never played' };
+    const levels = (skilled.levels?.length ?? 0) > 1;
+    const chosen = !!stated?.onPurpose && stated.seconds < floor.seconds;
+    const need = chosen ? stated.seconds : Math.max(floor.seconds, stated?.seconds ?? 0);
+    const spread = skilled.spread ? ` (${mmss(skilled.spread.min)}–${mmss(skilled.spread.max)} over ${skilled.seeds} seeds)` : '';
+    const split = levels ? `; levels reached at ${skilled.levels.map((l) => `${l.level} ${mmss(l.meanAt)}`).join(', ')}` : '';
+    const ending = skilled.ended === undefined ? '' : skilled.ended > 0
+        ? `; the ending reached on ${skilled.ended}/${skilled.seeds} seeds${skilled.endedAt ? ` at ${mmss(skilled.endedAt)}` : ''}` : '';
+    const says = `a skilled run lasts ${mmss(skilled.meanSeconds)}${spread}${split}${ending}`;
+    const bar = `${mmss(floor.seconds)} for ${floor.where}${stated ? `, ${stated.where} says ${mmss(stated.seconds)}${stated.onPurpose ? ' on purpose' : ''}` : ''}`;
+    if (skilled.open >= skilled.seeds / 2 && skilled.seconds < need) {
+        return { id: 'length', state: 'not measured', says: `${says}, but the probe stops each run at ${skilled.seconds} s, under the bar (${bar})`, next: `raise the seconds in test/probes.ts to ${need} or more so a run can reach its ending` };
+    }
+    if (skilled.ended === 0) {
+        const looped = skilled.open >= skilled.seeds / 2;
+        const what = looped ? `no ending reached in ${skilled.seconds} s` : `no ending reached in ${skilled.seconds} s: every skilled run ends lost first (${skilled.lost}/${skilled.seeds})`;
+        if (stated?.onPurpose && looped)
+            return { id: 'length', state: 'note', says: `${says}; ${what}, as ${stated.where} chooses (endless on purpose)`, next: 'an endless game carries its minutes in what brings a player back (a best, a daily seed, a score attack)' };
+        return { id: 'length', state: 'warn', says: `${says}; ${what}`, next: looped
+                ? 'play never runs out and never ends: a game reaches an ending worth reaching (a last level, a final boss, an end screen); name it in ProbeGame.ended(run) so sim times it (skill funpixel-game-logic, references/probes.md)'
+                : 'a good player never sees the end: ease the last stretch or check the sharp bot reaches it; a run that must end in a loss says so on the play-length line "on purpose"' };
+    }
+    if (chosen && skilled.meanSeconds + 0.5 >= stated.seconds) {
+        return { id: 'length', state: 'note', says: `${says}: shorter than the ${mmss(floor.seconds)} floor for ${floor.where}, as ${stated.where} chooses on purpose (${mmss(stated.seconds)})`, next: 'a round that short is a choice; what brings a player back for the next one (a best, a daily seed, a score attack) carries the minutes' };
+    }
+    if (skilled.meanSeconds + 0.5 < need) {
+        return { id: 'length', state: 'warn', says: `${says}: under the bar (${bar})`, next: stated && stated.seconds >= floor.seconds
+                ? `play ends before the length ${stated.where} states: content that play reaches (a new idea per stage, a twist, an ending worth reaching), or state the length it has`
+                : `real play of ${mmss(floor.seconds)} or more for a first-time player: escalation, variety, a twist, an ending worth reaching (skill funpixel-game-logic, references/depth.md); a smaller scope is a choice: say "on purpose" on the play-length line of the design doc, or set funpixel.json play_min_minutes` };
+    }
+    return { id: 'length', state: 'ok', says: `${says}, at or over the bar (${bar})${skilled.ended === undefined ? '; the probe kit reports no ending (src/probe-kit.ts predates endedAt: `funtools upgrade`)' : ''}` };
+}
+export function judge(out, noviceFloor = NOVICE_FLOOR, stated = null, floor = DEFAULT_FLOOR) {
+    return [...judgeCohorts(out.cohorts, noviceFloor), judgeLength(out.cohorts, stated, floor), ...judgeDepth(out.cohorts), ...judgeMoments(out.moments), ...judgeTimelines(out.timelines)];
+}

package/plugins/kiro/hooks/vendor/spec/rooms.mjs

@@ -0,0 +1,189 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/spec/rooms.ts by the GDK build. Do not edit.
+import { createHash } from 'node:crypto';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { byId, readTunables, SPEC_DIR } from './tunables.mjs';
+import { playFloor } from '../sim/judge.mjs';
+export const ROOMS_RECORD = join('.funtools', 'rooms.json');
+export const OPEN_FILE = join('.funtools', 'rooms-open.json');
+export const END = 'end';
+export const PAR_BAND = 0.5;
+export const ROOM_SEEDS = 5;
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+const sha = (s) => createHash('sha256').update(s).digest('hex').slice(0, 16);
+export function roomFiles(root, specDir = SPEC_DIR) {
+    let names = [];
+    try {
+        names = readdirSync(join(root, specDir));
+    }
+    catch {
+        return [];
+    }
+    return names.filter((n) => /(^|[-_])rooms[^/]*\.json$/i.test(n)).sort().map((n) => join(specDir, n));
+}
+function parOf(raw, id, tunables) {
+    if (typeof raw.par === 'number' && raw.par > 0)
+        return { par: raw.par, parFrom: 'the room' };
+    const num = (t) => (t && typeof t.default === 'number' && t.default > 0 ? t.default : null);
+    if (typeof raw.par === 'string') {
+        const t = tunables.get(raw.par);
+        return { par: num(t), parFrom: raw.par };
+    }
+    const want = id.toUpperCase().replace(/[^A-Z0-9]+/g, '-');
+    for (const t of tunables.values()) {
+        if (new RegExp(`(^|-)ROOM-${want}-PAR$`, 'i').test(t.id) || t.id === `rooms.${id}_par`)
+            return { par: num(t), parFrom: t.id };
+    }
+    return { par: null };
+}
+function exitOf(raw) {
+    if (typeof raw.exit === 'string' && raw.exit.trim())
+        return raw.exit.trim();
+    if (Array.isArray(raw.exits) && raw.exits.length)
+        return 'doors';
+    return null;
+}
+export function specRooms(root, specDir = SPEC_DIR) {
+    const files = roomFiles(root, specDir), problems = [], rooms = [];
+    const t = readTunables(root, specDir);
+    const tunables = 'list' in t ? byId(t.list) : new Map();
+    for (const file of files) {
+        const data = readJson(join(root, file));
+        if (!data) {
+            problems.push(`${file} is not JSON`);
+            continue;
+        }
+        const chapters = Array.isArray(data.chapters)
+            ? data.chapters.map((c) => ({ id: String(c?.id ?? '?'), rooms: Array.isArray(c?.rooms) ? c.rooms : [] }))
+            : Array.isArray(data.rooms) ? [{ id: 'rooms', rooms: data.rooms }] : [];
+        if (!chapters.length)
+            problems.push(`${file} has neither "chapters" nor "rooms"`);
+        for (const c of chapters)
+            for (const r of c.rooms) {
+                if (!r || typeof r !== 'object' || typeof r.id !== 'string' || !r.id) {
+                    problems.push(`${file}: a room without an id`);
+                    continue;
+                }
+                rooms.push({
+                    id: r.id, name: typeof r.name === 'string' ? r.name : r.id, chapter: c.id, ...parOf(r, r.id, tunables), exit: exitOf(r),
+                    slice: r.slice === true, ...(typeof r.teaches === 'string' ? { teaches: r.teaches } : {}),
+                    ...(r.tune && typeof r.tune === 'object' ? { tune: r.tune } : {}), file, hash: sha(JSON.stringify(r)),
+                });
+            }
+    }
+    return { rooms, files, problems };
+}
+export function uniqueRooms(rooms) {
+    const at = new Map(), out = [];
+    for (const r of rooms) {
+        const i = at.get(r.id);
+        if (i === undefined) {
+            at.set(r.id, out.length);
+            out.push(r);
+        }
+        else
+            out[i] = r;
+    }
+    return out;
+}
+export const sliceRoom = (rooms) => rooms.find((r) => r.slice) ?? rooms[0] ?? null;
+export function readOpen(root) {
+    const r = readJson(join(root, OPEN_FILE));
+    return { version: 1, planned: r?.planned && typeof r.planned === 'object' ? r.planned : {}, opened: Array.isArray(r?.opened) ? r.opened : [] };
+}
+export const isOpened = (rec, rooms, id) => sliceRoom(rooms)?.id === id || rec.opened.some((o) => o.room === id);
+export function builtEarly(rec, rooms) {
+    return rooms.filter((r) => !isOpened(rec, rooms, r.id) && rec.planned[r.id] !== undefined && rec.planned[r.id] !== r.hash);
+}
+export const readRoomsRecord = (root) => {
+    const r = readJson(join(root, ROOMS_RECORD));
+    return r && Array.isArray(r.rooms) ? r : null;
+};
+export function specHash(root) {
+    const h = createHash('sha256');
+    const walk = (rel, depth) => {
+        let names = [];
+        try {
+            names = readdirSync(join(root, rel)).sort();
+        }
+        catch {
+            return;
+        }
+        for (const n of names) {
+            if (n === 'node_modules' || n.startsWith('.'))
+                continue;
+            const p = join(rel, n);
+            let st;
+            try {
+                st = statSync(join(root, p));
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                if (depth < 6)
+                    walk(p, depth + 1);
+            }
+            else {
+                try {
+                    h.update(p).update('\0').update(readFileSync(join(root, p))).update('\n');
+                }
+                catch { }
+            }
+        }
+    };
+    walk(SPEC_DIR, 0);
+    walk('src', 0);
+    return `sha256:${h.digest('hex').slice(0, 32)}`;
+}
+export function lengthFromRooms(root, fp, floor) {
+    const rec = readRoomsRecord(root);
+    if (!rec || (fp && rec.fingerprint && rec.fingerprint !== fp))
+        return null;
+    const played = rec.played_total;
+    if (typeof played !== 'number')
+        return null;
+    const says = `play length from the rooms: a careful player's whole campaign of ${rec.rooms.length} rooms takes ${mmss(played)} (pars ${mmss(rec.par_total)}; ${ROOMS_RECORD}) against the bar (${mmss(floor.seconds)} for ${floor.where}); one round is one wave`;
+    return played >= floor.seconds ? { state: 'ok', says } : { state: 'warn', says, next: 'more rooms, more waves, or bigger rooms in design/spec/rooms.json until the campaign reaches the floor; then funtools rooms' };
+}
+const mmss = (s) => `${Math.floor(s / 60)}:${String(Math.round(s % 60)).padStart(2, '0')}`;
+export const clock = mmss;
+const T = 'npx @funpixel/tools';
+export function roomsGate(root, fp) {
+    const { rooms: all } = specRooms(root);
+    const rooms = uniqueRooms(all);
+    const closes = `${ROOMS_RECORD} on the current files: every room opened in turn and cleared by the careful player on ${ROOM_SEEDS} seeds within its par, the pars adding up to the play floor`;
+    if (!rooms.length)
+        return { state: 'open', says: 'no rooms as data yet (design/spec/rooms.json)', closes, run: `${T} spec init (the big tier's spec folder, rooms and the room runner), then ${T} rooms` };
+    const open = readOpen(root);
+    const early = builtEarly(open, rooms);
+    if (early.length)
+        return { state: 'failing', says: `${early.map((r) => r.id).join(', ')} changed before ${early.length === 1 ? 'it was' : 'they were'} opened (slice first: a room waits until the one before it passes)`, closes, run: `put ${early.length === 1 ? 'it' : 'them'} back as planned, or open in turn: ${T} rooms open ${early[0].id} (the owner can release it: --by owner)` };
+    const rec = readRoomsRecord(root);
+    if (!rec)
+        return { state: 'open', says: 'the bots never played the rooms', closes, run: `${T} rooms` };
+    if (fp && rec.fingerprint && rec.fingerprint !== fp)
+        return { state: 'stale', says: 'the rooms were played on older files', closes, run: `${T} rooms` };
+    const row = (id) => rec.rooms.find((r) => r.id === id);
+    for (const r of rooms) {
+        const got = row(r.id);
+        if (!isOpened(open, rooms, r.id)) {
+            const prev = rooms[rooms.indexOf(r) - 1];
+            return { state: 'open', says: `${r.id} is next${prev ? `: ${prev.id} passes` : ''}`, closes, run: `${T} rooms open ${r.id}, build it, then ${T} rooms` };
+        }
+        if (!got)
+            return { state: 'open', says: `${r.id} was not played`, closes, run: `${T} rooms` };
+        if (got.verdict !== 'pass')
+            return { state: 'failing', says: `${r.id}: ${got.says}`, closes, run: `fix ${r.id} (its data in ${r.file}, the rules, or its par), then ${T} rooms` };
+    }
+    const floor = playFloor(root);
+    const total = rooms.reduce((s, r) => s + (r.par ?? 0), 0);
+    if (total < floor.seconds)
+        return { state: 'failing', says: `the pars add up to ${mmss(total)}, under the floor of ${mmss(floor.seconds)} (${floor.where})`, closes, run: 'add rooms, or grow the rooms you have, until the pars reach the floor; then funtools rooms' };
+    return { state: 'met', says: `${rooms.length} rooms cleared in turn on ${rec.seeds} seeds; pars ${mmss(total)} against the floor ${mmss(floor.seconds)}`, closes: '', run: '' };
+}

package/plugins/kiro/hooks/vendor/spec/tunables.mjs

@@ -0,0 +1,75 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/spec/tunables.ts by the GDK build. Do not edit.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const SPEC_DIR = join('design', 'spec');
+export const TUNABLES_FILE = join(SPEC_DIR, 'tunables.json');
+const isNum = (v) => typeof v === 'number' && Number.isFinite(v);
+function rangeOf(v) {
+    return Array.isArray(v) && v.length === 2 && isNum(v[0]) && isNum(v[1]) ? [v[0], v[1]] : undefined;
+}
+const testsOf = (v) => (Array.isArray(v) ? v.filter((t) => typeof t === 'string' && !!t.trim()) : []);
+const textOf = (v) => (typeof v === 'string' && v.trim() ? v.trim() : undefined);
+function entry(id, group, name, e) {
+    return {
+        id, group, name, default: e.default,
+        ...(textOf(e.type) ? { type: textOf(e.type) } : {}),
+        ...(textOf(e.unit) ? { unit: textOf(e.unit) } : {}),
+        ...(rangeOf(e.range) ? { range: rangeOf(e.range) } : {}),
+        ...(textOf(e.why) ? { why: textOf(e.why) } : {}),
+        tests: testsOf(e.tests),
+    };
+}
+export function parseTunables(raw) {
+    const problems = [];
+    const list = [];
+    const o = raw && typeof raw === 'object' ? raw : null;
+    if (o && o.groups && typeof o.groups === 'object' && !Array.isArray(o.groups)) {
+        for (const [g, entries] of Object.entries(o.groups)) {
+            if (!entries || typeof entries !== 'object' || Array.isArray(entries)) {
+                problems.push(`group "${g}" is not an object of tunables`);
+                continue;
+            }
+            for (const [n, e] of Object.entries(entries)) {
+                if (!e || typeof e !== 'object' || Array.isArray(e)) {
+                    problems.push(`${g}.${n} is not an object ({ default, unit, range, why })`);
+                    continue;
+                }
+                list.push(entry(`${g}.${n}`, g, n, e));
+            }
+        }
+        return { shape: 'groups', list, problems };
+    }
+    if (o && Array.isArray(o.tunables)) {
+        for (const e of o.tunables) {
+            const r = e && typeof e === 'object' ? e : null;
+            if (!r || typeof r.id !== 'string') {
+                problems.push('an entry without an id');
+                continue;
+            }
+            const words = r.id.split('-');
+            list.push(entry(r.id, words[1] ?? r.id, words.slice(2).join('-') || r.id, r));
+        }
+        return { shape: 'list', list, problems };
+    }
+    problems.push('neither { "groups": { … } } nor { "tunables": [ … ] }');
+    return { shape: 'groups', list, problems };
+}
+export function readTunables(root, specDir = SPEC_DIR) {
+    const rel = join(specDir, 'tunables.json');
+    let text;
+    try {
+        text = readFileSync(join(root, rel), 'utf8');
+    }
+    catch {
+        return { missing: true, rel };
+    }
+    try {
+        return { ...parseTunables(JSON.parse(text)), rel };
+    }
+    catch (e) {
+        return { broken: e instanceof Error ? e.message : String(e), rel };
+    }
+}
+export function byId(list) {
+    return new Map(list.map((t) => [t.id, t]));
+}

package/plugins/kiro/hooks/vendor/stage/harnessignore.mjs

@@ -0,0 +1,91 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/stage/harnessignore.ts by the GDK build. Do not edit.
+export function parseHarnessIgnore(text) {
+    return text
+        .replace(/^\uFEFF/, "")
+        .split(/\r?\n/)
+        .flatMap((raw, i) => {
+        const l = raw.trim();
+        if (!l || l.startsWith("#"))
+            return [];
+        return [l.startsWith("!") ? { pattern: l.slice(1), negated: true, line: i + 1 } : { pattern: l, negated: false, line: i + 1 }];
+    });
+}
+const globToRe = (glob) => {
+    let re = "";
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === "*") {
+            if (glob[i + 1] === "*") {
+                re += ".*";
+                i++;
+            }
+            else
+                re += "[^/]*";
+        }
+        else if (c === "?")
+            re += "[^/]";
+        else
+            re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+    return re;
+};
+export function makeDecider(rules) {
+    const compiled = rules.map((rule) => {
+        const { pattern } = rule;
+        const rooted = pattern.startsWith("/") || pattern.startsWith("./");
+        const dirOnly = pattern.endsWith("/");
+        let p = pattern;
+        if (p.startsWith("./"))
+            p = p.slice(2);
+        else if (rooted)
+            p = p.slice(1);
+        if (dirOnly)
+            p = p.slice(0, -1);
+        const body = globToRe(p);
+        const prefix = rooted ? "^" : "^(?:.*/)?";
+        const re = new RegExp(`${prefix}${body}(?:/.*)?$`);
+        const exactRe = new RegExp(`${prefix}${body}$`);
+        return { re, exactRe, rule, dirOnly };
+    });
+    return (relPath, isDir) => {
+        let decided = null;
+        for (const { re, exactRe, rule, dirOnly } of compiled) {
+            if (dirOnly && !isDir && exactRe.test(relPath))
+                continue;
+            if (re.test(relPath))
+                decided = rule;
+        }
+        return decided;
+    };
+}
+export function makeIgnoreMatcher(rules) {
+    const decide = makeDecider(rules);
+    return (relPath, isDir) => {
+        const rule = decide(relPath, isDir);
+        return rule !== null && !rule.negated;
+    };
+}
+export function makeRuleMatchers(rules) {
+    return rules.map((rule) => ({
+        rule,
+        test: makeIgnoreMatcher([rule]),
+    }));
+}
+export const PROPHYLACTIC = new Set([
+    ".env", ".env.*", "/verify.json", "/design/", "/dist-playable/",
+    "/scripts/", "/tools/", "/assets/", "/reference/", "/test/", "/vitest.config.ts", "/.funtools/", "*.md",
+]);
+export function deadRules(rules, allPaths) {
+    const ruleMatchers = makeRuleMatchers(rules);
+    const matched = new Set();
+    for (const path of allPaths) {
+        for (const { rule, test } of ruleMatchers) {
+            if (test(path, false) || test(path, true)) {
+                matched.add(rule.pattern);
+            }
+        }
+    }
+    return rules
+        .filter((r) => !r.negated && !matched.has(r.pattern) && !PROPHYLACTIC.has(r.pattern))
+        .map((r) => r.pattern);
+}

package/plugins/kiro/hooks/vendor/stage/stage.mjs

@@ -0,0 +1,58 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/stage/stage.ts by the GDK build. Do not edit.
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, relative, resolve } from 'node:path';
+import { deadRules, makeDecider, parseHarnessIgnore } from './harnessignore.mjs';
+export const BUILTIN = ['node_modules/', '.git/', 'dist/', '.vite/', '.claude/', '.DS_Store', '._*', '__MACOSX/'];
+export const PRIVATE = ['.funtools/', '.funpixel/', '/design/decisions.md', '/design/status.json', '/design/GDD.html', '/design/inbox/'];
+export const SPLASH_FUNPIXEL = '/src/splash-funpixel/';
+export function funpixelSplashChosen(dir) {
+    try {
+        return JSON.parse(readFileSync(join(dir, 'funpixel.json'), 'utf8')).splash === 'funpixel';
+    }
+    catch {
+        return false;
+    }
+}
+function refuseHome(dir) {
+    const up = relative(resolve(dir), homedir());
+    if (up === '' || (!up.startsWith('..') && !/^[A-Za-z]:/.test(up))) {
+        throw new Error(`refusing to stage ${resolve(dir)}: it holds your home directory — run this in the game's own folder`);
+    }
+}
+export const UNITY_OUTPUT = /^(library|temp|obj|logs|builds?|usersettings|memorycaptures|recordings)$/i;
+export function stageFiles(dir, { own = true } = {}) {
+    refuseHome(dir);
+    const ignoreFile = join(dir, '.harnessignore');
+    const rules = own && existsSync(ignoreFile) ? parseHarnessIgnore(readFileSync(ignoreFile, 'utf8')) : [];
+    const fixed = (list) => parseHarnessIgnore(list.join('\n')).map((r) => ({ ...r, line: 0 }));
+    const decide = makeDecider([...fixed(BUILTIN), ...rules, ...fixed(PRIVATE), ...fixed(funpixelSplashChosen(dir) ? [] : [SPLASH_FUNPIXEL])]);
+    const included = [], considered = [], skippedEmpty = [];
+    const excluded = [];
+    const walk = (rel, inUnity = false) => {
+        const unity = existsSync(join(dir, rel, 'ProjectSettings', 'ProjectVersion.txt'));
+        const within = inUnity || unity;
+        for (const ent of readdirSync(rel ? join(dir, rel) : dir, { withFileTypes: true })) {
+            const child = rel ? `${rel}/${ent.name}` : ent.name;
+            const isDir = ent.isDirectory();
+            considered.push(child);
+            const output = isDir && ((unity && UNITY_OUTPUT.test(ent.name)) || (within && /^(bin|obj)$/i.test(ent.name)));
+            const rule = output ? { pattern: `${ent.name}/ (Unity's output)`, negated: false, line: 0 } : decide(child, isDir);
+            if (rule && !rule.negated) {
+                excluded.push({ path: child, isDir, rule });
+                continue;
+            }
+            if (isDir)
+                walk(child, within);
+            else if (ent.isFile()) {
+                if (statSync(join(dir, child)).size === 0)
+                    skippedEmpty.push(child);
+                else
+                    included.push(child);
+            }
+        }
+    };
+    walk('');
+    included.sort();
+    return { included, considered, excluded, skippedEmpty, rules, dead: rules.length ? deadRules(rules, considered) : [] };
+}