@funpixel/tools 0.0.0-stage → 0.1.1

package/plugins/claude/hooks/vendor/studio/pitch.mjs

@@ -0,0 +1,295 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/studio/pitch.ts by the GDK build. Do not edit.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export const STUDIO_FILE = join('design', 'studio.json');
+export const CATALOGUE = [
+    {
+        id: 'genre', title: 'Genre and fidelity', asks: 'which of the genre\'s habits players keep, and which one this game breaks on purpose',
+        options: [
+            { id: 'faithful', label: 'Faithful', why: 'players arrive knowing how to play; the craft is in the execution' },
+            { id: 'twist', label: 'One twist', why: 'keep the camera, the body and how a run ends; break one convention and pay for it in the design' },
+            { id: 'cross', label: 'Two genres crossed', why: 'a fresh shape, at the cost of teaching more in the first minute' },
+        ],
+    },
+    {
+        id: 'depth', title: 'Depth', asks: 'how long a first-time player plays, which sets the production tier',
+        options: [
+            { id: '5min', label: '5 minutes', why: 'one sitting, a score to beat; small tier: one loop polished hard' },
+            { id: '30min', label: '15–30 minutes', why: 'levels with a ramp and a short arc; mid tier: keep it consistent across places' },
+            { id: 'chapters', label: 'Chapters', why: 'a story spine across episodes; deep tier: identity locks, a QA loop, a pilot first' },
+        ],
+    },
+    {
+        id: 'core', title: 'The core that burns', asks: 'the one thing everything serves: it gets the art budget, the tests and the hardest checks',
+        options: [
+            { id: 'fun', label: 'Gameplay fun', why: 'the verb, its decisions and its numbers; checks: sim, feel, the panel\'s fun seat' },
+            { id: 'world', label: 'The world', why: 'places that differ and a living system with a job in play; checks: variety --within, life, compare --target' },
+            { id: 'story', label: 'The story', why: 'a want, a turn, voices and an ending that changes the world; checks: depth --fill, the storyteller seat' },
+            { id: 'feel', label: 'The feel', why: 'the controller, the camera and the juice in the hands; checks: feel, phone, a blind player' },
+        ],
+    },
+    {
+        id: 'story', title: 'Story standard', asks: 'how much story the game carries',
+        options: [
+            { id: 'none', label: 'None', why: 'an arcade round: the GDD says "Story: declined" and why, and nothing asks for more' },
+            { id: 'light', label: 'Light', why: 'a want said by a person, a turn, an ending that changes the world' },
+            { id: 'deep', label: 'Deep', why: 'all five: the goal, the clock, the question, the antagonist (whose want is half right), the frame' },
+        ],
+    },
+    {
+        id: 'sound', title: 'Sound', asks: 'how much audio is made for this game; every action answers with a sound whichever you pick',
+        options: [
+            { id: 'feedback', label: 'Feedback only', why: 'each action answers with a sound made in code or from the starter set; no generated music', cost: 'free' },
+            { id: 'full', label: 'Sound and music', why: 'generated effects for the moments that matter and one mastered music bed', cost: 'about $0.10–0.40' },
+            { id: 'score', label: 'A score', why: 'music that follows the play: layers or stingers, tracks with a clear beat the game syncs to (`funtools beats`)', cost: 'about $0.50–1.50' },
+        ],
+    },
+    {
+        id: 'extras', title: 'Extras', asks: 'optional pieces, each with its cost; none is the default', multi: true,
+        options: [
+            { id: 'voice', label: 'Voice per character', why: 'the cast speaks its lines; the radio or the narrator becomes the game\'s voice', cost: 'about $0.01–0.03 a line; a casting pass per character' },
+            { id: 'cutscenes', label: 'Cutscenes', why: 'one earned cinematic (the ending, a reveal), skippable', cost: '$1–3 each, plus a scene to stage' },
+            { id: 'photo', label: 'Photo mode', why: 'players share the wow moments; the share card carries the game', cost: 'a free camera, a frame and a share sheet: about a day' },
+            { id: 'multiplayer', label: 'Multiplayer', why: 'friends in one room through the relay', cost: 'doubles the test work; the host owns the world state' },
+            { id: 'two-takes', label: 'Two takes', why: 'for a deep game: two parallel builds of the same locked plan, each winning different areas (one the environment, one the dynamics); `funtools compare-takes` plays both from the title and writes a best-of-both table, and the mix beats both (one game, 3 rounds)', cost: 'twice the build sessions, plus a merge round' },
+            { id: 'none', label: 'None', why: 'everything goes into the core' },
+        ],
+    },
+];
+const AUTONOMY = ['ask', 'plan-then-go', 'go'];
+export const AUTONOMY_WHY = {
+    ask: 'the owner answers each pitch choice, the first look and the plan; nothing moves without a yes',
+    'plan-then-go': 'the owner answers each pitch choice and agrees the plan; then the build runs round after round',
+    go: 'the agent picks and records each pick with its reason; the owner reviews what was made',
+};
+const notAChoice = (choice) => { if (choice === 'autonomy')
+    throw new Error('autonomy is the owner\'s setting, not a pitch choice: funpixel.json flow.autonomy (from the brief: `funtools flow start --autonomy ask|plan-then-go|go`)'); };
+export const isAutonomy = (s) => AUTONOMY.includes(s);
+export function freshStudio(hints = {}) {
+    const depth = hints.tier === 'small' ? '5min' : hints.tier === 'deep' ? 'chapters' : hints.tier === 'mid' ? '30min' : null;
+    const proposals = {
+        depth: depth ? [depth] : [],
+        story: hints.story ? [hints.story] : [],
+        sound: ['full'],
+        extras: hints.multiplayer ? ['multiplayer'] : [],
+        budget: [hints.tier === 'deep' ? '1500' : hints.tier === 'mid' ? '500' : '200'],
+    };
+    return {
+        version: 1,
+        choices: CATALOGUE.map((c) => ({ ...c, options: c.options.map((o) => ({ ...o })), proposed: proposals[c.id] ?? [], picked: [] })),
+        autonomy: 'plan-then-go',
+        locked: null,
+    };
+}
+export function readStudio(root) {
+    const p = join(root, STUDIO_FILE);
+    if (!existsSync(p))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(p, 'utf8'));
+        if (!raw || !Array.isArray(raw.choices))
+            return null;
+        const choices = raw.choices.filter((c) => c && typeof c.id === 'string' && c.id !== 'autonomy').map((c) => ({
+            id: c.id, title: String(c.title ?? c.id), asks: String(c.asks ?? ''), multi: !!c.multi,
+            options: (Array.isArray(c.options) ? c.options : []).filter((o) => o && typeof o.id === 'string').map((o) => ({ id: o.id, label: String(o.label ?? o.id), why: String(o.why ?? ''), ...(o.picture ? { picture: String(o.picture) } : {}), ...(o.cost ? { cost: String(o.cost) } : {}) })),
+            proposed: list(c.proposed), ...(c.proposedWhy ? { proposedWhy: String(c.proposedWhy) } : {}), picked: list(c.picked), ...(c.note ? { note: String(c.note) } : {}), ...(c.pickedOn === 'page' ? { pickedOn: 'page' } : {}),
+        }));
+        return { version: 1, choices, autonomy: isAutonomy(raw.autonomy) ? raw.autonomy : 'plan-then-go', locked: raw.locked && typeof raw.locked === 'object' ? raw.locked : null };
+    }
+    catch {
+        return null;
+    }
+}
+const list = (x) => (Array.isArray(x) ? x.map(String) : typeof x === 'string' && x ? [x] : []);
+export function writeStudio(root, s) {
+    const p = join(root, STUDIO_FILE);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(s, null, 2) + '\n');
+}
+const choiceOf = (s, id) => {
+    const c = s.choices.find((x) => x.id === id);
+    if (!c)
+        throw new Error(`no choice "${id}" (choices: ${s.choices.map((x) => x.id).join(', ')})`);
+    return c;
+};
+const optionIds = (c, ids) => {
+    const out = ids.flatMap((i) => i.split(',')).map((i) => i.trim()).filter(Boolean);
+    for (const i of out)
+        if (!c.options.some((o) => o.id === i))
+            throw new Error(`"${c.id}" has no option "${i}" (options: ${c.options.map((o) => o.id).join(', ')}); add one with --label`);
+    if (!c.multi && out.length > 1)
+        throw new Error(`"${c.id}" takes one option`);
+    return out;
+};
+export function propose(s, choice, option, o = {}) {
+    notAChoice(choice);
+    let c = s.choices.find((x) => x.id === choice);
+    if (!c) {
+        c = { id: choice, title: o.title ?? choice, asks: '', options: [], proposed: [], picked: [] };
+        s.choices.push(c);
+    }
+    for (const id of option.split(',').map((x) => x.trim()).filter(Boolean)) {
+        const have = c.options.find((x) => x.id === id);
+        if (have) {
+            if (o.picture)
+                have.picture = o.picture;
+            if (o.cost)
+                have.cost = o.cost;
+            if (o.label)
+                have.label = o.label;
+        }
+        else
+            c.options.push({ id, label: o.label ?? id, why: o.why ?? '', ...(o.picture ? { picture: o.picture } : {}), ...(o.cost ? { cost: o.cost } : {}) });
+    }
+    c.proposed = optionIds(c, [option]);
+    if (o.why)
+        c.proposedWhy = o.why;
+    return s;
+}
+export function pick(s, choice, option, note, o = {}) {
+    notAChoice(choice);
+    const c = choiceOf(s, choice);
+    c.picked = optionIds(c, [option]);
+    if (o.on)
+        c.pickedOn = o.on;
+    else
+        delete c.pickedOn;
+    if (note !== undefined)
+        c.note = note.trim() || undefined;
+    return s;
+}
+export function standing(c) {
+    if (c.picked.length)
+        return { ids: c.picked, by: 'person' };
+    if (c.proposed.length)
+        return { ids: c.proposed, by: 'agent' };
+    return { ids: [], by: null };
+}
+export function lock(s, planVersion, now = new Date()) {
+    const picks = {}, by = {}, notes = {};
+    const open = [], agentPicks = [];
+    for (const c of s.choices) {
+        const st = standing(c);
+        if (!st.by) {
+            open.push(c.id);
+            continue;
+        }
+        picks[c.id] = st.ids;
+        by[c.id] = st.by;
+        if (st.by === 'agent')
+            agentPicks.push(c.id);
+        if (c.note)
+            notes[c.id] = c.note;
+    }
+    s.locked = { at: now.toISOString(), plan: planVersion, picks, by, notes };
+    return { studio: s, open, agentPicks };
+}
+export function movedSinceLock(s) {
+    if (!s.locked)
+        return [];
+    return s.choices.filter((c) => { const st = standing(c).ids; const was = s.locked.picks[c.id] ?? []; return st.join(',') !== was.join(','); }).map((c) => c.id);
+}
+export const labelOf = (s, choice, ids) => {
+    const c = s.choices.find((x) => x.id === choice);
+    return ids.map((i) => c?.options.find((o) => o.id === i)?.label ?? i).join(' + ');
+};
+export const FOCUS = {
+    fun: { sections: ['Core loop', 'The numbers', 'Content', 'Opening'], checks: ['funtools sim', 'funtools feel', 'funtools playtest (the fun seat)'], goHard: 'every number with its reason, a boring optimum that loses, each kind bending the core rule, a decision every few seconds' },
+    world: { sections: ['Places', 'Living world', 'The hook', 'Identity lock'], checks: ['funtools variety --within', 'funtools life', 'funtools compare --target'], goHard: 'each place its own shape, material, era and light; one living system with a job in play; the first minutes alive' },
+    story: { sections: ['Story', 'The hook', 'Actors', 'Audio'], checks: ['funtools depth --fill', 'the owner\'s read of the story in the chat'], goHard: 'a want said by a person, a turn the player performs, an antagonist whose want is half right, beats seen in play' },
+    feel: { sections: ['The numbers', 'Juice', 'Controls', 'Actors'], checks: ['funtools feel', 'funtools phone', 'a blind phone player'], goHard: 'the controller\'s numbers read back from play, juice per event, one gesture per thumb zone' },
+};
+export const STORY_FIELDS = { deep: ['Goal', 'Clock', 'Question', 'Antagonist', 'Frame'], light: ['Want', 'Turn', 'Ending'] };
+export function lockedNotes(s, gdd) {
+    const picks = s.locked?.picks ?? {};
+    const out = [];
+    const sec = (title) => new RegExp(`^##\\s+(the\\s+)?${title.replace(/^the\s+/i, '')}\\b[^\\n]*\\n([\\s\\S]*?)(?=^##\\s|(?![\\s\\S]))`, 'im').exec(gdd)?.[2] ?? null;
+    const filled = (label) => new RegExp(`^\\s*[-*]?\\s*\\**${label}\\**\\s*:\\**\\s*(?!<)(?!none\\b)\\S[^\\n]{8,}`, 'im').test(gdd);
+    for (const core of picks.core ?? []) {
+        const f = FOCUS[core];
+        if (!f)
+            continue;
+        const thin = f.sections.filter((t) => { const b = sec(t); return b === null || b.replace(/<[^<>\n]{2,}>/g, '').replace(/[|\s-]/g, '').length < 200; });
+        if (thin.length)
+            out.push({ state: 'warn', what: `the locked core is ${labelOf(s, 'core', [core])}: ${thin.map((t) => `## ${t}`).join(', ')} ${thin.length === 1 ? 'is' : 'are'} missing or thin — go hard here: ${f.goHard}` });
+    }
+    const story = picks.story?.[0];
+    if (story === 'deep' || story === 'light') {
+        const miss = STORY_FIELDS[story].filter((l) => !filled(l));
+        if (miss.length)
+            out.push({ state: 'warn', what: `story standard ${story}: ${miss.map((m) => `${m}:`).join(' ')} not filled in ## Story` });
+    }
+    else if (story === 'none' && !/story\s*:\s*\**\s*declined/i.test(gdd)) {
+        out.push({ state: 'note', what: 'story standard none: one line "Story: declined, and why" keeps the mirror from asking for one' });
+    }
+    for (const x of picks.extras ?? []) {
+        const planned = { voice: /\bvoic(e|ed|es)\b|voice ?line|\bVO\b/i, cutscenes: /cut-?scenes?|cinematic/i, photo: /photo mode/i, multiplayer: /multiplayer|\brooms?\b|relay/i, 'two-takes': /two takes|take [ab12]\b|compare-takes|parallel builds?/i };
+        if (planned[x] && !planned[x].test(gdd))
+            out.push({ state: 'warn', what: `extra "${labelOf(s, 'extras', [x])}" was picked, and the GDD never plans it (where, how many, its cost)` });
+    }
+    const sound = picks.sound?.[0];
+    if (sound === 'feedback' && /generate_music|gen music|music bed|soundtrack/i.test(gdd))
+        out.push({ state: 'warn', what: 'sound is "Feedback only" (the person\'s pick), and the GDD plans generated music: ask before making it, or plan code-made sound' });
+    if (sound === 'score' && !/\b(beat|tempo|bpm|stinger|layer)/i.test(gdd))
+        out.push({ state: 'warn', what: 'sound is "A score": the GDD never says what follows the music (beats, layers, stingers); `funtools beats` gives the game each track\'s beat map' });
+    for (const [c, by] of Object.entries(s.locked?.by ?? {}))
+        if (by === 'agent' && s.autonomy === 'ask')
+            out.push({ state: 'note', what: `${c}: locked at the agent's proposal, never confirmed by the person (autonomy is ask)` });
+    return out;
+}
+export function lightByChoice(s) {
+    const out = new Set();
+    const p = s?.locked?.picks ?? {};
+    if (p.story?.[0] === 'none')
+        out.add('story');
+    return out;
+}
+export const BLOCK_START = '<!-- studio pitch: written by funtools pitch from design/studio.json; pick there or with funtools pitch pick -->';
+export const BLOCK_END = '<!-- /studio pitch -->';
+export function gddBlock(s) {
+    const cell = (x) => x.replace(/\|/g, '/').replace(/\n/g, ' ');
+    const rows = s.choices.map((c) => {
+        const st = standing(c);
+        const locked = s.locked?.picks[c.id];
+        const pickCell = st.ids.length ? `**${labelOf(s, c.id, st.ids)}**${st.by === 'agent' ? ' (proposed)' : ''}${locked && locked.join(',') === st.ids.join(',') ? ' · locked' : ''}` : 'open';
+        const why = [c.proposedWhy, c.note ? `the person: "${c.note}"` : ''].filter(Boolean).join(' · ') || st.ids.map((i) => c.options.find((o) => o.id === i)?.why ?? '').join('; ');
+        return `| **${cell(c.title)}** | ${cell(c.options.map((o) => o.label + (o.cost ? ` (${o.cost})` : '')).join(' · '))} | ${cell(pickCell)} | ${cell(why)} |`;
+    });
+    const core = s.locked?.picks.core ?? standing(s.choices.find((c) => c.id === 'core') ?? { picked: [], proposed: [] }).ids;
+    const hard = core.map((c) => FOCUS[c]?.goHard).filter(Boolean);
+    return [
+        BLOCK_START,
+        s.locked ? `Locked ${s.locked.at.slice(0, 10)} at ${s.locked.plan}. What is not picked stays light or out.` : 'Nothing is locked until the person confirms (`funtools pitch lock`).',
+        '',
+        '| Choice | Options | Pick | Why |',
+        '|---|---|---|---|',
+        ...rows,
+        '',
+        hard.length ? `**Where the work goes hard:** ${hard.join('; ')}.` : '**Where the work goes hard:** pick the core that burns first.',
+        `**Autonomy:** ${s.autonomy}, the owner's setting (funpixel.json flow.autonomy): ${AUTONOMY_WHY[s.autonomy]}.`,
+        BLOCK_END,
+    ].join('\n');
+}
+export function writeGddBlock(text, s) {
+    const block = gddBlock(s);
+    const re = new RegExp(`${esc(BLOCK_START)}[\\s\\S]*?${esc(BLOCK_END)}`);
+    if (re.test(text))
+        return text.replace(re, block);
+    const head = /^##\s+(the\s+)?studio pitch\b[^\n]*\n/im.exec(text);
+    if (head) {
+        const at = head.index + head[0].length;
+        const next = text.slice(at).search(/^##\s/m);
+        const end = next < 0 ? text.length : at + next;
+        return `${text.slice(0, at)}${block}\n\n${text.slice(end)}`;
+    }
+    const first = text.search(/^##\s/m);
+    const section = `## The studio pitch\n${block}\n\n`;
+    return first < 0 ? `${text.trimEnd()}\n\n${section}` : `${text.slice(0, first)}${section}${text.slice(first)}`;
+}
+const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+export function manifestStudio(s) {
+    if (!s.locked)
+        return null;
+    return { locked: s.locked.picks, by: s.locked.by, autonomy: s.autonomy, at: s.locked.at, plan: s.locked.plan, ...(Object.keys(s.locked.notes).length ? { notes: s.locked.notes } : {}) };
+}
+export const TIER_OF = { '5min': 'small', '30min': 'mid', chapters: 'deep' };

package/plugins/claude/hooks/vendor/verify/fingerprint.mjs

@@ -0,0 +1,73 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/verify/fingerprint.ts by the GDK build. Do not edit.
+import { createHash } from 'node:crypto';
+import { createReadStream, statSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { stageFiles } from '../stage/stage.mjs';
+const RECORD = 'verify.json';
+const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
+export function fingerprintOfDigests(digests) {
+    const h = createHash('sha256');
+    for (const { path, digest } of [...digests].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))) {
+        h.update(path).update('\0').update(digest).update('\n');
+    }
+    return `sha256:${h.digest('hex')}`;
+}
+export function fingerprintOf(entries) {
+    return fingerprintOfDigests(entries.map(({ path, bytes }) => ({ path, digest: sha256(bytes) })));
+}
+const AT_ONCE = 32;
+export async function stagedEntries(root) {
+    const files = stageFiles(root).included.filter((f) => f !== RECORD);
+    const entries = [];
+    for (let i = 0; i < files.length; i += AT_ONCE) {
+        entries.push(...await Promise.all(files.slice(i, i + AT_ONCE).map(async (path) => ({ path, bytes: await readFile(join(root, path)) }))));
+    }
+    return entries;
+}
+function digestOf(file) {
+    return new Promise((done, fail) => {
+        const h = createHash('sha256');
+        createReadStream(file).on('error', fail).on('data', (chunk) => h.update(chunk)).on('end', () => done(h.digest('hex')));
+    });
+}
+export class HashBudgetExceeded extends Error {
+    hashed;
+    staged;
+    constructor(hashed, staged) {
+        super(`hashed ${hashed} of ${staged} files before the deadline`);
+        this.hashed = hashed;
+        this.staged = staged;
+    }
+}
+export async function stagedDigests(root, cache, until) {
+    const files = stageFiles(root).included.filter((f) => f !== RECORD);
+    const digests = [];
+    for (let i = 0; i < files.length; i += AT_ONCE) {
+        if (until !== undefined && Date.now() > until)
+            throw new HashBudgetExceeded(i, files.length);
+        digests.push(...await Promise.all(files.slice(i, i + AT_ONCE).map(async (path) => {
+            const file = join(root, path);
+            if (!cache)
+                return { path, digest: await digestOf(file) };
+            const { size, mtimeMs } = statSync(file);
+            const was = cache[path];
+            if (was && was[0] === size && was[1] === mtimeMs)
+                return { path, digest: was[2] };
+            const digest = await digestOf(file);
+            cache[path] = [size, mtimeMs, digest];
+            return { path, digest };
+        })));
+    }
+    if (cache) {
+        const staged = new Set(files);
+        for (const path of Object.keys(cache))
+            if (!staged.has(path))
+                delete cache[path];
+    }
+    return digests;
+}
+export async function fingerprint(root, cache) {
+    const digests = await stagedDigests(root, cache);
+    return { fingerprint: fingerprintOfDigests(digests), files: digests.length };
+}

package/plugins/claude/hooks/vendor/verify/reads.mjs

@@ -0,0 +1,33 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/verify/reads.ts by the GDK build. Do not edit.
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { stageFiles } from '../stage/stage.mjs';
+export const STYLESHEET = /\.(css|scss|sass|less|styl)$/i;
+export const sceneReadsFile = (path) => !STYLESHEET.test(path);
+export function sceneReads(root) {
+    const out = {};
+    for (const path of stageFiles(root).included) {
+        if (path === 'verify.json' || !sceneReadsFile(path))
+            continue;
+        out[path] = createHash('sha256').update(readFileSync(join(root, path))).digest('hex').slice(0, 16);
+    }
+    return out;
+}
+export function sameReads(recorded, now) {
+    if (!recorded || typeof recorded !== 'object' || Array.isArray(recorded))
+        return false;
+    const r = recorded;
+    const keys = Object.keys(now);
+    return keys.length === Object.keys(r).length && keys.every((k) => r[k] === now[k]);
+}
+export function readsUnchanged(root, rec, now) {
+    if (!rec?.reads)
+        return false;
+    try {
+        return sameReads(rec.reads, now ?? sceneReads(root));
+    }
+    catch {
+        return false;
+    }
+}

package/plugins/claude/hooks/vendor/wow/picks.mjs

@@ -0,0 +1,75 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/wow/picks.ts by the GDK build. Do not edit.
+export const WOW_HEADING = 'Wow';
+export const MAX_ALSO = 3;
+const PLACEHOLDER = /^<.*>$|^…$/;
+const clean = (v) => { const t = (v ?? '').trim(); return !t || PLACEHOLDER.test(t) ? '' : t; };
+function section(gdd) {
+    const m = /^## Wow[ \t]*$/m.exec(gdd);
+    if (!m)
+        return null;
+    const rest = gdd.slice(m.index + m[0].length);
+    const next = rest.search(/^## /m);
+    const end = next < 0 ? gdd.length : m.index + m[0].length + next;
+    return { start: m.index, end, body: gdd.slice(m.index + m[0].length, end) };
+}
+export function parseCheck(text) {
+    const m = /^(event|frame|view|moment)\s+([\w-]+)/i.exec(text.trim());
+    if (!m)
+        return null;
+    return { kind: /^event$/i.test(m[1]) ? 'event' : 'frame', name: m[2] };
+}
+export function wowPicks(gdd) {
+    const s = section(gdd);
+    if (!s)
+        return [];
+    const rows = s.body.split('\n').filter((l) => /^\s*\|.*\|\s*$/.test(l) && !/^\s*\|[\s:|-]+\|\s*$/.test(l)).map((l) => l.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim()));
+    return rows.slice(1).map((r) => ({ role: /^sig/i.test(r[0]) ? 'signature' : 'also', id: clean(r[1]).replace(/`/g, ''), expression: clean(r[2]), why: clean(r[3]), check: parseCheck(clean(r[4])) })).filter((p) => p.id);
+}
+export const signatureOf = (gdd) => wowPicks(gdd).find((p) => p.role === 'signature') ?? null;
+const row = (p) => `| ${p.role} | ${p.id} | ${p.expression || '<what this game makes of it>'} | ${p.why || '<why it pays off the pitch>'} | ${p.check ? `${p.check.kind} ${p.check.name}` : '<event name, or frame view>'} |`;
+const HEAD = '| Pick | Move | Expression | Why it pays off the pitch | Checked by |\n|---|---|---|---|---|';
+export function writePick(gdd, p) {
+    const s = section(gdd);
+    let picks = s ? wowPicks(gdd) : [];
+    if (p.role === 'signature')
+        picks = picks.map((x) => (x.role === 'signature' && x.id !== p.id ? { ...x, role: 'also' } : x));
+    const at = picks.findIndex((x) => x.id === p.id);
+    if (at >= 0)
+        picks[at] = { ...picks[at], ...p, expression: p.expression || picks[at].expression, why: p.why || picks[at].why, check: p.check ?? picks[at].check };
+    else
+        picks.push(p);
+    picks.sort((a, b) => Number(b.role === 'signature') - Number(a.role === 'signature'));
+    const block = `## ${WOW_HEADING}\nOne signature and up to ${MAX_ALSO} more, from the genre card's wow catalogue (\`funtools wow\`) or invented; each with what this game makes of it and how a check sees it.\n\n${HEAD}\n${picks.map(row).join('\n')}\n`;
+    if (s)
+        return `${gdd.slice(0, s.start)}${block}\n${gdd.slice(s.end).replace(/^\n+/, '')}`.replace(/\n{3,}/g, '\n\n');
+    const before = gdd.search(/^## Content list\b/m);
+    return before < 0 ? `${gdd.trimEnd()}\n\n${block}` : `${gdd.slice(0, before)}${block}\n${gdd.slice(before)}`;
+}
+export function pickProblems(picks, known) {
+    const out = [];
+    const sig = picks.filter((p) => p.role === 'signature');
+    if (!picks.length)
+        return [{ level: 'warn', text: 'no wow picked: the game has no chosen signature moment (`funtools wow` lists the card\'s catalogue)' }];
+    if (sig.length !== 1)
+        out.push({ level: 'warn', text: sig.length ? `${sig.length} signatures: pick one (${sig.map((p) => p.id).join(', ')})` : 'no signature: one pick must be the moment the game is remembered for' });
+    const also = picks.filter((p) => p.role === 'also');
+    if (also.length > MAX_ALSO)
+        out.push({ level: 'warn', text: `${also.length} more moves past the signature: keep ${MAX_ALSO} at most, so each is built past the point of sense` });
+    for (const p of picks) {
+        if (!known(p.id) && !/^custom-/.test(p.id))
+            out.push({ level: 'warn', text: `${p.id}: not in the catalogue; an invented move is named custom-<name>` });
+        if (!p.expression)
+            out.push({ level: 'note', text: `${p.id}: no expression yet (what this game makes of it: subject, axis, payoff)` });
+        if (!p.check)
+            out.push({ level: 'warn', text: `${p.id}: no check (an event the game marks with __FPX_MOMENT__, or a frame of a view)` });
+    }
+    return out;
+}
+const words = (t) => new Set((t.toLowerCase().match(/[a-z]{4,}/g) ?? []).map((w) => w.replace(/(?<=[^s])s$/, '')));
+export function sameExpression(a, b) {
+    const A = words(a), B = words(b);
+    if (!A.size || !B.size)
+        return true;
+    const inter = [...A].filter((w) => B.has(w)).length;
+    return inter / new Set([...A, ...B]).size >= 0.4;
+}

package/plugins/claude/skills/3d/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: 3d
+description: Use when a 3D game needs a model or a place, or one is wrong (a character, creature, vehicle or prop; a GLB that draws black, will not animate, slides its feet or is too heavy for a phone; grey or plastic skin across a cast; a 3D level, an interior or a set, or a scene that must match a painted target). In Unity, follow references/unity.md.
+---
+
+# 3D models and places
+
+A generated GLB is paid, slow and can load without an error while it renders flat grey, stands
+frozen, skates, sinks into the floor or carries 100K triangles where a phone draws 6K. None of these
+throws, and an idle-pose screenshot hides most of them. This skill picks the lane per object, checks
+every model on the bench before code depends on it, gives a cast one skin, and builds levels from a
+spec. The person's locked choices override every default here.
+
+## Route by the job
+
+| The job | Read |
+|---|---|
+| A new character, creature, vehicle or prop: lane, concept image, price, clips, loading | [models](references/models.md), [hero-route](references/hero-route.md), [concept-image](references/concept-image.md), [three-loading](references/three-loading.md) |
+| A model that is wrong or heavy: inspect, rig, clips, optimize, finalize, proof | [bench](references/bench.md), [reading](references/reading.md), [budgets](references/budgets.md) |
+| Skin across a cast, a variant on the same mesh | [skin](references/skin.md) |
+| A level from a spec: blockout, colliders, markers, dressing | [level-spec](references/level-spec.md), [light-and-places](references/light-and-places.md) |
+| A scene that must match a painted target; skies | [painted-target](references/painted-target.md), [skyboxes](references/skyboxes.md) |
+| A Unity project | [unity](references/unity.md), [engine-targets](references/engine-targets.md) |
+
+## Tools
+
+- `generate_3d_model`: a prompt or image URL to a GLB; `style` `standard` (~160 credits), `hero` or
+  `lowpoly` (~45); `animations` rigs a humanoid biped. Long runs return a job id for `get_job`: a
+  timed-out job still runs, paid for, so collect it and never resubmit.
+- `generate_image` makes the concept image; `list_characters`, `get_character` (free) and
+  `restyle_character` give rigged characters that already move; `get_material` after
+  `find_material` for free CC0 HDRIs and PBR sets; `generate_skybox` for a sky.
+- The bench, about 1 credit a step: `inspect_model` (free), `rig_model`, `audit_clips` (free),
+  `optimize_model`, `finalize_model`, `render_model`, `lod_model`, `texture_stats` (free),
+  `fracture_model`.
+- `author_skin` (about 3 credits) and `retexture_model` for skin and variants.
+- `build_level` turns `design/level.json` into `level.glb` with `plan.png`, `view.png`, the markers
+  and the collider audit.
+- `inspect_scene`, `capture_view` and `screenshot` show it in the game at the camera you ship.
+- Local: `npx @funpixel/tools model --local inspect|render|finalize|level <file>` on your own
+  Blender (free); `npx @funpixel/tools gen model3d` with a paid key; `fidelity` scores a model
+  against its views; `look --3d` says whether the heroes are code primitives or models; `reach`
+  names markers nothing reaches. With none of these, build from palette primitives and name the
+  stand-in.
+
+## The order that avoids rework
+
+1. **A lane per object,** written in the design note with its cost: a humanoid a library character
+   fits → `get_character`; a hero the camera frames close → `standard` from a concept image; a body
+   whose size is a stat → primitives in code; animal, blob or vehicle → a static mesh animated in
+   code; crates and walls → primitives; crowds → one model instanced, with a far LOD.
+2. **A concept image first:** one subject, whole, straight on, plain light background, flat light;
+   a rig needs an A-pose, empty hands and fitted clothing. Text-to-3D invents its own design.
+3. **Say the price, start early,** and pass `confirm_cost` only when the person allowed it. Retry a
+   failed humanoid alone: parallel resubmits have all failed where serial ones passed.
+4. **The bench before wiring:** `inspect_model` (act on findings before facts; `-1` means not
+   measured), a rig check before paying for motion, `audit_clips` with `expected` set to every clip
+   name the code plays, then the contact sheet. Rig before decimating; decimate before welding.
+5. **Optimize to the device,** `phone`, `desktop` and `high` cuts from the kept source; `finalize_model`
+   with `keep_clips`; the proof render, not the success message, is the fix.
+6. **One material direction** for generated and code-built objects; compare them under the game's
+   light at phone size.
+7. **Skin:** one tone per character in a cast table; `retexture_model` before `author_skin`, never
+   after; read `marks` and `proof.png`, then fix the scene light rather than the tone per shot.
+8. **Levels:** a table of areas, doors, routes and every named point before the spec; blockout with
+   no props; walk every route in the game (a hidden `colliders` node, a kill plane under the
+   floor); dress with the kit to zero audit findings; read markers by name and fail loudly.
+9. **Report what you could not fix:** a dragging limb, a clip replaced by code motion, a model
+   checked by eye only, a scene over budget, each by name.
+
+## Worked example
+
+A runner's knight hero: lanes in the note (knight generated and rigged; coins, crates and track in
+code). A concept image, front view, A-pose, hands empty. "About 248 credits, rigged with idle, run
+and jump. Go ahead?" Yes. The call times out; `get_job` returns `knight.glb`, 98K triangles.
+`audit_clips` finds all three clips; `optimize_model` cuts it to 6K for a phone; `finalize_model`
+keeps the three clips and its contact sheet shows it lit from every side. Hand-back: "Knight rigged
+with three clips; the rest is code, one material."
+
+## Common mistakes
+
+- Text-to-3D for the hero: the model drifts from the 2D art.
+- `animations` on a dog or a slime: the rig step is skipped and the money buys nothing.
+- `root.clone()` for a second enemy: every copy shares one skeleton and stands frozen.
+- A clip name typed from memory (`hurt` against `hit`): it loads and never plays.
+- Running `author_skin` before `retexture_model`: the repaint paints over the skin.
+- Colliding against the art mesh, or dressing before walking the blockout.
+
+Adapted in part from scenario-labs/skills (MIT); see THIRD_PARTY_NOTICES.md.

package/plugins/claude/skills/3d/references/bake-off.md

@@ -0,0 +1,48 @@
+# The model bake-off: several candidates, one judged against the master
+
+One game tried its hero three ways (three providers' takes of the same front picture) and picked
+from turntable sheets; another made two to four models of each crew member before one held.
+A model is the most expensive asset a game makes, and the first one is rarely the keeper. The
+bake-off makes the choice cheap to see and puts it on record.
+
+Adapted from scenario-labs/skills (MIT, © 2026 Scenario; the model-comparison skill); see
+THIRD_PARTY_NOTICES.md. The words and the tools are ours.
+
+## The rules, set before the candidates exist
+
+- **One input for all.** Every candidate is made from the same master picture (the cast member's
+  `design/cast/<id>/master.png`, or the item's `from` picture). Changing the input mid-way makes
+  the comparison about the input.
+- **A budget first.** N candidates cost N models (105 credits each at `standard`): price the run
+  (`assets gen --dry-run`) and say it. Three is the hero's default; every other model makes one.
+  Three engines make three honest candidates from one picture: `engine: "meshy"` (~160),
+  `"hunyuan"` (~105) and `"rodin"` (~80, static only; `gen model3d --engine meshy|hunyuan|rodin`).
+- **The same framing for every render.** Each candidate is rendered round by the Blender bench
+  (local and free with your own Blender 4.2+; the same verb the hosted bench runs) and scored on
+  its best view against the master: outline overlap 0.65, colour 0.35.
+- **Measurements before taste.** The numbers remove the wrong design. They do not choose between
+  two good takes: when the top two are within 0.03 the run says it is a tie, and the identity seat
+  or the owner chooses.
+
+## In the manifest
+
+```json
+{ "name": "ren3d", "kind": "model3d", "cast": "ren", "draws": 3, "optimize": { "device": "phone" } },
+{ "name": "renrig", "kind": "rig", "from": "ren3d", "clips": ["idle", "walk"],
+  "retarget": { "character": "<a stocked 3D character>", "clips": ["run"] },
+  "optimize": { "device": "phone", "budget": "character" } }
+```
+
+The kept candidate is the file; every candidate's score and best render are in the lock
+(`bakeoff`), the draws under `.funtools/assets/draws/<name>/`. A mover then runs the rig chain as
+one item: `rig_model`, then authored `motions` (`author_motion`), then clips carried from a stocked
+character (`retarget_clips`), then the optimizer level for the platform. Decimate after rigging,
+never before (step 5 of the skill).
+
+## What it showed on real files
+
+On the first game's own models, rendered by the bench: each prop's model was ranked first against its own
+reference picture, by 0.03 to 0.13 over the next (crate, door, lockers, canister, bell); the three
+providers' takes of the hero scored within 0.03 of each other, and well above any prop. The team
+kept the Rodin take for reasons a silhouette cannot see (triangle budget, separable limbs). That is
+the job of the numbers: a short list of on-model candidates, never the final word on taste.