@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/studio/forks.js

@@ -0,0 +1,93 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { readProgress } from "../progress/progress.js";
+import { labelOf, standing } from "./pitch.js";
+export const PITCH_FORK = { genre: 'taste', core: 'taste', story: 'taste', depth: 'scope', extras: 'scope', sound: 'spend', budget: 'spend' };
+export const forkOf = (choice) => PITCH_FORK[choice] ?? 'taste';
+export const topicOf = (choice) => `pitch:${choice}`;
+const choiceOfTopic = (topic) => (topic?.startsWith('pitch:') ? topic.slice(6) : null);
+export function ownerAutonomy(root) {
+    try {
+        const a = JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8'))?.flow?.autonomy;
+        return a === 'ask' || a === 'plan-then-go' || a === 'go' ? a : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const ownerPicksPitch = (root) => ownerAutonomy(root) === 'ask';
+function pitchQuestions(s) {
+    const out = new Map();
+    for (const q of s.questions) {
+        const c = choiceOfTopic(q.topic);
+        if (c)
+            out.set(c, q);
+    }
+    return out;
+}
+export function pitchForks(root, studio, s = readProgress(root)) {
+    const needed = ownerPicksPitch(root);
+    const qs = pitchQuestions(s);
+    const out = { needed, settled: [], open: [], unasked: [] };
+    for (const c of studio?.choices ?? []) {
+        const q = qs.get(c.id);
+        if (c.pickedOn === 'page' && c.picked.length)
+            out.settled.push(c.id);
+        else if (q?.answer?.by === 'owner')
+            out.settled.push(c.id);
+        else if (q && q.state === 'open')
+            out.open.push(q);
+        else
+            out.unasked.push(c);
+    }
+    return out;
+}
+export function foldPitchAnswers(studio, s) {
+    let moved = false;
+    for (const [id, q] of pitchQuestions(s)) {
+        if (q.answer?.by !== 'owner')
+            continue;
+        const c = studio.choices.find((x) => x.id === id);
+        if (!c)
+            continue;
+        const ids = q.answer.pick.split(',').map((x) => x.trim()).filter((x) => c.options.some((o) => o.id === x));
+        if (!ids.length || (!c.multi && ids.length > 1))
+            continue;
+        if (c.picked.join(',') !== ids.join(',') || c.pickedOn !== 'page') {
+            c.picked = ids;
+            c.pickedOn = 'page';
+            moved = true;
+        }
+        if (q.answer.words && c.note !== q.answer.words) {
+            c.note = q.answer.words;
+            moved = true;
+        }
+    }
+    return moved;
+}
+export function pitchAsk(studio, c, id, now) {
+    const st = standing(c);
+    const proposal = st.by === 'agent' ? ` The agent proposes ${labelOf(studio, c.id, st.ids)}${c.proposedWhy ? `: ${c.proposedWhy}` : ''}.` : '';
+    const options = c.options.map((o) => `${o.label}${o.cost ? ` (${o.cost})` : ''}`).join(' · ');
+    return {
+        type: 'ask', id, at: now.toISOString(), kind: forkOf(c.id), stage: 'pitch', topic: topicOf(c.id),
+        text: `${c.title}: ${c.asks}.${proposal} Options: ${options}.`,
+        options: c.options.map((o) => o.id),
+    };
+}
+export function lockRefusal(root, studio, s = readProgress(root)) {
+    if (!studio)
+        return null;
+    const f = pitchForks(root, studio, s);
+    if (!f.needed || (!f.open.length && !f.unasked.length))
+        return null;
+    const auto = ownerAutonomy(root);
+    const parts = [
+        ...(f.unasked.length ? [`not put to the owner yet: ${f.unasked.map((c) => c.id).join(', ')} (\`npx @funpixel/tools pitch ask\` puts each to them in the chat with your proposal)`] : []),
+        ...(f.open.length ? [`waiting for the owner: ${f.open.map((q) => `${q.id} ${choiceOfTopic(q.topic)}`).join(', ')}`] : []),
+    ];
+    return {
+        says: `the pitch's choices are the owner's to pick (autonomy ${auto ?? 'plan-then-go, the default'}; only the owner's own "go" lets your proposals lock): ${parts.join('; ')}`,
+        open: f.open, unasked: f.unasked.map((c) => c.id),
+    };
+}

package/dist/studio/pitch.js

@@ -0,0 +1,294 @@
+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/dist/studio/widen.js

@@ -0,0 +1,212 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+export const WIDEN_FILE = join('design', 'widen.json');
+export const WIDEN_MD = join('design', 'widen.md');
+export const GAME_LEDGER = join('design', 'wow-ledger.json');
+export const homeLedger = (env = process.env) => join(env.FUNPIXEL_LEDGER_DIR || join(homedir(), '.funpixel'), 'wow-ledger.json');
+export function rng(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+export const DIALS = ['tight', 'open', 'wide'];
+export const OPERATORS = [
+    { id: 'invert', label: 'Constraint inversion', ask: 'List three rules the brief takes for granted without saying them. Break exactly one, keep the rest, and describe the game that is left.' },
+    { id: 'inject', label: 'Constraint injection', ask: 'Add the card\'s structure as a hard rule the brief never asked for, and say what the core verb becomes under it.' },
+    { id: 'bisociate', label: 'Bisociation', ask: 'Read the brief through the card\'s domain as if it were the same problem: what in that domain already does what the player does, and what does it add?' },
+    { id: 'blend', label: 'Blend', ask: 'Fuse the brief\'s core object with one thing from the card\'s domain into a single object that plays both parts. Name it and its one rule.' },
+    { id: 'purpose', label: 'Purpose over surface', ask: 'State what the brief is FOR in one feeling, not its theme. Keep the feeling, throw away the surface, and rebuild it with the card\'s domain.' },
+    { id: 'nth', label: 'Nth association', ask: 'Write the first three things the brief makes everyone think of, ban them by name, and build from the fourth.' },
+    { id: 'cross', label: 'Cross-brief', ask: 'Answer this brief as if it were the card\'s domain brief: what would a studio that makes games about that domain ship here?' },
+];
+export const CLUSTERS = {
+    kitchen: ['sourdough starter', 'a pressure cooker', 'a spice rack', 'a dumpling fold', 'a cutting board', 'a slow braise', 'a fridge door of notes', 'a burnt pan'],
+    sea: ['a tide pool', 'a lighthouse rota', 'a kelp forest', 'a ship in a bottle', 'a whale fall', 'a fishing net mend', 'a harbour crane', 'a message buoy'],
+    paperwork: ['a stamp queue', 'a lost-property office', 'a census form', 'a filing cabinet', 'a library due date', 'a ration book', 'a tax deadline', 'a pneumatic tube'],
+    music: ['a metronome', 'a choir round', 'a jukebox', 'a tuning fork', 'a marching band', 'a broken music box', 'a call and response', 'a drum circle'],
+    weather: ['a fog bank', 'a hailstorm', 'a heat shimmer', 'a rain gauge', 'a weather vane', 'a monsoon gutter', 'a frost pattern', 'a lightning count'],
+    textiles: ['a loom', 'a darned sock', 'a quilt of scraps', 'a knot board', 'a dye vat', 'a moth hole', 'a spool race', 'a tailor\'s chalk line'],
+    digging: ['an archaeology grid', 'a seed vault', 'a mole tunnel', 'a buried time capsule', 'a fossil layer', 'a mine canary', 'a sinkhole', 'a root map'],
+    insects: ['an ant trail', 'a bee dance', 'a firefly signal', 'a spider web repair', 'a termite mound', 'a moth to a lamp', 'a beetle roll', 'a cicada year'],
+    transit: ['a night bus', 'a signal box', 'a lost luggage carousel', 'a cable car', 'a ticket punch', 'a level crossing', 'a postal sorting train', 'a ferry timetable'],
+    ritual: ['a lantern festival', 'a wedding seating plan', 'a funeral procession', 'a harvest count', 'a coming-of-age test', 'a house blessing', 'a tea ceremony', 'a midnight market'],
+};
+export const FACETS = {
+    verb: ['trade', 'carry', 'mend', 'herd', 'hide', 'listen', 'sort', 'grow', 'signal', 'trace', 'balance', 'lure', 'stack', 'swap', 'pour', 'guard'],
+    camera: ['a fixed diorama', 'a slow side scroll', 'an overhead map', 'a first-person hand', 'a security camera', 'a window you look through', 'a tilted isometric table', 'a long telephoto', 'a periscope', 'a puppet stage', 'a microscope slide', 'a rear-view mirror', 'a satellite pass', 'a keyhole', 'a dashboard', 'a photo album page'],
+    light: ['one candle', 'blue hour', 'a flashlight cone', 'neon through rain', 'noon with no shadow', 'a lighthouse sweep', 'an eclipse', 'firelight on faces', 'aquarium glow', 'a strobe', 'snow light', 'a projector beam', 'lightning only', 'golden dust', 'a fridge at night', 'aurora'],
+    palette: ['two inks on cream paper', 'sodium orange and teal', 'chalk pastels', 'bruise purple and bone', 'risograph pink and green', 'rust and moss', 'monochrome with one red', 'sun-faded primaries', 'cobalt and egg yolk', 'tea-stained sepia', 'mint and maroon', 'black on hazard yellow', 'oil-slick iridescent', 'terracotta and sage', 'night-vision green', 'candy wrapper foil'],
+    material: ['folded paper', 'felt and yarn', 'glazed clay', 'cut tin', 'stained glass', 'wet ink', 'carved soap', 'stacked cardboard', 'blown glass', 'chalk on slate', 'woven reed', 'lacquered wood', 'wax', 'beaded thread', 'rubber stamps', 'sugar glass'],
+    mood: ['tender', 'uncanny', 'mischievous', 'lonely then warm', 'frantic', 'solemn', 'smug', 'hopeful against odds', 'nosy', 'bittersweet', 'reckless', 'sleepy', 'proud', 'guilty', 'giddy', 'stubborn'],
+    structure: ['one day, replayed', 'a single room that changes', 'a relay of strangers', 'a countdown you can bargain with', 'a map that remembers you', 'seasons of one place', 'a letter per level', 'a shop you never leave', 'a debt paid in turns', 'a tournament bracket', 'a journey one way only', 'a festival night hour by hour', 'a family tree', 'a recipe in steps', 'a rumour that spreads', 'two players who never meet'],
+};
+const FACET_KEYS = Object.keys(FACETS);
+const LADDER = {
+    tight: { distances: ['near', 'near', 'near', 'middle'], wildcard: false },
+    open: { distances: ['near', 'middle', 'middle', 'far'], wildcard: true },
+    wide: { distances: ['middle', 'far', 'far', 'far'], wildcard: true },
+};
+const STRETCH = {
+    near: 'Near: keep the genre, the camera and how a run ends; change one thing a player would notice in the first minute.',
+    middle: 'Middle: keep the brief\'s feeling; the verb or the place may change.',
+    far: 'Far: keep only the brief\'s feeling. Far raises the spread, not the average: one good far card is the point, the others may fail.',
+};
+const pickFrom = (r, xs) => xs[Math.floor(r() * xs.length)];
+export const freshSeed = (now = Date.now()) => (now ^ Math.floor(Math.random() * 0x7fffffff)) >>> 0;
+export function draw(brief, seed, dial = 'open', avoid = [], genre, now = new Date()) {
+    const r = rng(seed);
+    const avoidSet = new Set([...avoid].map(norm));
+    const avoided = new Set();
+    const usedClusters = new Set(), usedValues = new Set(), usedOps = new Set();
+    const choose = (pool) => {
+        const fresh = pool.filter((v) => !usedValues.has(norm(v)));
+        const notAvoided = fresh.filter((v) => !avoidSet.has(norm(v)));
+        for (const v of fresh)
+            if (avoidSet.has(norm(v)) && notAvoided.length)
+                avoided.add(v);
+        const v = pickFrom(r, notAvoided.length ? notAvoided : fresh.length ? fresh : pool);
+        usedValues.add(norm(v));
+        return v;
+    };
+    const ladder = LADDER[dial];
+    const slots = [...ladder.distances.map((d) => ({ distance: d, wildcard: false })), ...(ladder.wildcard ? [{ distance: 'far', wildcard: true }] : [])];
+    const cards = slots.map((slot, i) => {
+        const clusters = Object.keys(CLUSTERS).filter((c) => !usedClusters.has(c));
+        const cluster = pickFrom(r, clusters);
+        usedClusters.add(cluster);
+        const thing = choose(CLUSTERS[cluster]);
+        const ops = OPERATORS.filter((o) => !usedOps.has(o.id));
+        const op = slot.wildcard ? { id: 'wildcard', label: 'Wildcard (labelled random)', ask: 'Take every facet on this card at face value, however strange, and make one game where they all belong. Say what is unexpected about it, what connects it to the brief, and why a player would care.' } : pickFrom(r, ops.length ? ops : OPERATORS);
+        usedOps.add(op.id);
+        const facets = Object.fromEntries(FACET_KEYS.map((k) => [k, choose(FACETS[k])]));
+        const id = `W${i + 1}`;
+        const prompt = [
+            `${op.label} · ${slot.wildcard ? 'wildcard' : slot.distance}`,
+            `Brief: ${brief}`,
+            `Domain: ${thing} (${cluster}).`,
+            `Facets: verb ${facets.verb}; camera ${facets.camera}; light ${facets.light}; palette ${facets.palette}; material ${facets.material}; mood ${facets.mood}; structure ${facets.structure}.`,
+            op.ask,
+            STRETCH[slot.distance],
+            'Use what serves the game and drop the rest; say which facets you dropped. Answer in 2–4 sentences in "answer".',
+        ].join('\n');
+        return { id, distance: slot.distance, wildcard: slot.wildcard, operator: op, domain: { cluster, thing }, facets, stretch: STRETCH[slot.distance], prompt, answer: '' };
+    });
+    return { version: 1, brief, seed, dial, baseline: baseline(brief, genre), avoided: [...avoided].sort(), cards, at: now.toISOString() };
+}
+export const valuesOf = (w) => w.cards.flatMap((c) => [c.domain.thing, ...Object.values(c.facets)]);
+export function overlap(a, b) {
+    const x = new Set(valuesOf(a).map(norm)), y = new Set(valuesOf(b).map(norm));
+    const inter = [...x].filter((v) => y.has(v)).length;
+    return inter / (x.size + y.size - inter || 1);
+}
+export const GENRE_DEFAULTS = [
+    { genre: 'platformer', words: /platform|jump|runner|precision/i, defaults: ['jump', 'run', 'coins', 'spikes', 'levels', 'double jump', 'checkpoint', 'enemies', 'side view', 'boss'] },
+    { genre: 'puzzle', words: /puzzle|merge|match|tile|block/i, defaults: ['match', 'merge', 'grid', 'tiles', 'combo', 'score', 'levels', 'stars', 'moves', 'colours'] },
+    { genre: 'survivors', words: /survivor|horde|bullet|roguelite|wave/i, defaults: ['waves', 'enemies', 'upgrades', 'xp', 'weapons', 'level up', 'survive', 'boss', 'horde', 'auto attack'] },
+    { genre: 'shooter', words: /shoot|shooter|gun|fps|blaster/i, defaults: ['shoot', 'enemies', 'ammo', 'guns', 'waves', 'health', 'boss', 'cover', 'aim', 'explosions'] },
+    { genre: 'racing', words: /rac(e|ing)|kart|driv|track|lap/i, defaults: ['race', 'cars', 'laps', 'track', 'boost', 'drift', 'finish line', 'rivals', 'speed', 'checkpoints'] },
+    { genre: 'arcade', words: /arcade|chase|maze|dodge|score attack/i, defaults: ['score', 'dodge', 'collect', 'lives', 'enemies', 'high score', 'speed up', 'power ups', 'maze', 'chase'] },
+    { genre: 'adventure', words: /adventure|explor|quest|story|walk/i, defaults: ['explore', 'quest', 'hero', 'village', 'treasure', 'map', 'npc', 'dungeon', 'collect', 'forest'] },
+    { genre: 'action', words: /action|brawl|fight|combat|melee|sword/i, defaults: ['fight', 'combo', 'sword', 'enemies', 'boss', 'health bar', 'dodge roll', 'arena', 'attack', 'upgrades'] },
+    { genre: 'strategy', words: /strategy|tower|defen[cs]e|tactic|build/i, defaults: ['towers', 'waves', 'path', 'upgrade', 'gold', 'enemies', 'base', 'build', 'resources', 'units'] },
+    { genre: 'stealth', words: /stealth|heist|sneak|thief/i, defaults: ['sneak', 'guards', 'shadows', 'alarm', 'vision cone', 'loot', 'escape', 'keycard', 'distraction', 'night'] },
+];
+const ALWAYS_GENERIC = ['player', 'game', 'fun', 'unique', 'levels', 'score', 'enemies', 'collect', 'power ups', 'upgrade', 'unlock'];
+export function baseline(brief, genre) {
+    const hay = `${genre ?? ''} ${brief}`;
+    const g = GENRE_DEFAULTS.find((x) => x.words.test(genre ?? '')) ?? GENRE_DEFAULTS.find((x) => x.words.test(hay)) ?? null;
+    const own = tokens(brief);
+    const words = [...new Set([...(g?.defaults ?? []), ...own, ...ALWAYS_GENERIC])];
+    const d = g?.defaults ?? ['collect', 'enemies', 'power ups', 'levels'];
+    const said = [...new Set((brief.toLowerCase().match(/[a-z][a-z'-]+/g) ?? []).filter((w) => w.length > 2 && !STOP.has(w) && !STOP.has(w.replace(/s$/, ''))))];
+    return { genre: g?.genre ?? null, words, sentence: `A ${g?.genre ?? 'casual'} game about ${said.slice(0, 3).join(', ') || 'the brief'}: ${d[0]} through ${d[3] ?? 'levels'}, ${d[1]} and ${d[2]}, a score at the end.` };
+}
+const STOP = new Set('a an the and or but of to in on at for with by from as is are be it its this that these those you your we our they their he she his her i me my into onto over under about through game games where when which who what while so then than just also very can will would one two some each every all any no not more most less like across around between my'.split(' '));
+export function tokens(text) {
+    return [...new Set((text.toLowerCase().match(/[a-z][a-z'-]+/g) ?? []).map((w) => w.replace(/'s$/, '').replace(/(?<=[a-z]{3})s$/, '')).filter((w) => w.length > 2 && !STOP.has(w)))];
+}
+const norm = (s) => s.toLowerCase().trim();
+export function unexpectedness(text, base, brief, kept = []) {
+    const t = tokens(text);
+    if (t.length < 4)
+        return { score: 0, generic: [], connected: false, archive: null, verdict: 'empty' };
+    const lower = text.toLowerCase();
+    const phrases = base.words.filter((w) => w.includes(' ') && lower.includes(w));
+    const single = new Set(base.words.filter((w) => !w.includes(' ')).flatMap(tokens));
+    const genericTok = t.filter((w) => single.has(w));
+    const hits = genericTok.length + phrases.length * 2;
+    const score = Math.max(0, Math.round(100 * (1 - hits / t.length)));
+    const briefTok = new Set(tokens(brief));
+    const connected = t.some((w) => briefTok.has(w)) || (!!base.genre && lower.includes(base.genre));
+    let archive = null;
+    for (const k of kept) {
+        const o = jaccard(t, tokens(k.text));
+        if (!archive || o > archive.overlap)
+            archive = { overlap: Math.round(o * 100) / 100, with: k.text.slice(0, 80) };
+    }
+    const verdict = archive && archive.overlap >= 0.5 ? 'restates' : score < 40 ? 'generic' : connected ? 'unexpected' : 'disconnected';
+    return { score, generic: [...new Set([...genericTok, ...phrases])], connected, archive, verdict };
+}
+const jaccard = (a, b) => { const x = new Set(a), y = new Set(b); const i = [...x].filter((v) => y.has(v)).length; return i / (x.size + y.size - i || 1); };
+export const briefKey = (brief) => tokens(brief).sort().join(' ');
+export function readLedger(path) {
+    try {
+        const l = JSON.parse(readFileSync(path, 'utf8'));
+        return Array.isArray(l?.entries) ? l : { version: 1, entries: [] };
+    }
+    catch {
+        return { version: 1, entries: [] };
+    }
+}
+export function appendLedger(path, e) {
+    const l = readLedger(path);
+    l.entries.push(e);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(l, null, 2) + '\n');
+}
+export function sameBrief(a, b) {
+    const x = a.split(' ').filter(Boolean), y = b.split(' ').filter(Boolean);
+    return x.length > 0 && y.length > 0 && jaccard(x, y) >= 0.6;
+}
+export function keptFor(brief, ledgers) {
+    const k = briefKey(brief);
+    const entries = ledgers.flatMap((l) => l.entries).filter((e) => sameBrief(e.briefKey, k));
+    return { values: [...new Set(entries.flatMap((e) => e.values))], texts: entries.filter((e) => e.text).map((e) => ({ text: e.text })) };
+}
+export function readWiden(root) {
+    try {
+        const w = JSON.parse(readFileSync(join(root, WIDEN_FILE), 'utf8'));
+        return w && Array.isArray(w.cards) ? w : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeWiden(root, w) {
+    const p = join(root, WIDEN_FILE);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(w, null, 2) + '\n');
+    writeFileSync(join(root, WIDEN_MD), widenMd(w));
+}
+export function widenMd(w) {
+    return [
+        `# Widen · seed ${w.seed} · dial ${w.dial}`,
+        '',
+        `Brief: ${w.brief}`,
+        '',
+        `**The control (the generic answer every card has to beat):** ${w.baseline.sentence}`,
+        '',
+        `Replay this exact draw: \`npx @funpixel/tools pitch widen --seed ${w.seed} --dial ${w.dial}\`. A new session, a new seed.${w.avoided.length ? ` Left out because a ledger already kept them for this brief: ${w.avoided.join(', ')}.` : ''}`,
+        '',
+        ...w.cards.flatMap((c) => [`## ${c.id} · ${c.wildcard ? 'wildcard' : c.distance} · ${c.operator.label}`, '', c.prompt.split('\n').slice(1).join('\n\n'), '', `Answer: ${c.answer || '(write it in design/widen.json "answer")'}`, '']),
+        'Fill each card\'s "answer" in design/widen.json, then `pitch widen score`. Keep the one you pitch with `pitch widen keep W2`.',
+        '',
+    ].join('\n');
+}
+export const existsWiden = (root) => existsSync(join(root, WIDEN_FILE));