@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/gdd/rubric.js

@@ -0,0 +1,250 @@
+export const RUBRIC_VERSION = 'v2';
+const indentOf = (l) => /^\s*/.exec(l)[0].replace(/\t/g, '  ').length;
+const LIST_ITEM = /^\s*(?:[-*+]|\d+[.)])\s+/;
+export function underLabel(lines, at, isLabel) {
+    const out = [];
+    const labelIndent = indentOf(lines[at]);
+    const labelIsItem = LIST_ITEM.test(lines[at]);
+    for (const l of lines.slice(at + 1)) {
+        if (!l.trim())
+            continue;
+        if (/^\s*#{1,6}\s/.test(l) || isLabel(l))
+            break;
+        const under = labelIsItem ? indentOf(l) > labelIndent : LIST_ITEM.test(l) || indentOf(l) > labelIndent;
+        if (!under)
+            break;
+        out.push(l.replace(LIST_ITEM, '').trim());
+    }
+    return out;
+}
+export const SECTIONS = [
+    'pitch', 'core_loop_numbers', 'journey_first_60s', 'content_plan', 'art_direction', 'actors_animation',
+    'juice_feedback', 'audio_plan', 'screens_hud', 'criteria', 'depth_replay', 'scope_cuts',
+];
+export const SOLID = {
+    pitch: 'a one-line promise, plus the thesis in one frame, the 6-second ad or the pillars with what each reference gives',
+    core_loop_numbers: 'the loop in a sentence and the numbers that are the whole game (10+ with units), each with why exactly that value',
+    journey_first_60s: 'the first minute beat by beat with seconds: first input, first payoff, the signature on screen (a moment ladder)',
+    content_plan: 'a roster, levels or stages, a climax and how it escalates, with a table (kind, one idea, debut)',
+    art_direction: 'the look, AD rules checkable in one frame, target frames, palette roles and a font',
+    actors_animation: 'a cast table with each actor\'s motion and states (idle, move, act, hit) and how it is made',
+    juice_feedback: 'a juice row per event (visual, motion, sound, camera and time), with numbers',
+    audio_plan: 'the sound cues in the world\'s own words and one music identity',
+    screens_hud: 'the HUD and every screen (title, how to play, settings, pause, win, loss) and the controls per device',
+    criteria: 'criteria a player can check from the screen (C1…), or a behaviour contract of named tests',
+    depth_replay: 'why a second run: retry, a best or rank to beat, and progression (levels, unlocks, seeds)',
+    scope_cuts: 'what is in, cut or later, the track with a gate per stage, and the risks',
+};
+export const TRACK = ['Design', 'First look', 'Style test', 'Gray-box', 'Slice', 'Panel 7.3', 'Ship'];
+function sectionsOf(text) {
+    const lines = text.split('\n');
+    const heads = [];
+    lines.forEach((l, at) => {
+        const m = /^\s{0,3}(#{1,4})\s+(.+?)\s*#*\s*$/.exec(l);
+        if (m)
+            heads.push({ at, level: m[1].length, title: m[2] });
+    });
+    return heads.map((h, i) => {
+        const end = heads.slice(i + 1).find((n) => n.level <= h.level)?.at ?? lines.length;
+        return { level: h.level, title: h.title, body: lines.slice(h.at + 1, end).join('\n') };
+    });
+}
+const tableRows = (body) => body.split('\n').filter((l) => /^\s*\|.*\|\s*$/.test(l) && !/^\s*\|[\s:|-]+\|\s*$/.test(l) && /[^\s|]/.test(l)).length - 1;
+const items = (body) => (body.match(/^\s*(?:[-*+]|\d+[.)])\s+\S/gm) ?? []).length;
+const has = (text, re) => re.test(text);
+const count = (text, re) => (text.match(new RegExp(re.source, re.flags.includes('g') ? re.flags : `${re.flags}g`)) ?? []).length;
+const find = (secs, re) => secs.filter((s) => re.test(s.title));
+const solidSec = (secs, re, ok) => find(secs, re).some((s) => ok(s.body));
+const names = (groups) => groups.filter(([, ok]) => !ok).map(([n]) => n);
+const NUM = /(?<![\w#.])\d+(?:[.,]\d+)?\s*(?:ms\b|s\b|sec|seconds?|minutes?|min\b|px\b|pt\b|u\/s|m\/s|units?\b|u\b|m\b|km\b|%|x\b|×|hz\b|fps\b|bpm\b|hp\b|hearts?\b|lives\b|waves?\b|levels?\b|tiers?\b|moves?\b|points?\b|pts\b|°|deg\b|kb\b|mb\b|credits?\b|gas\b|links?\b|hits?\b|lights?\b|bars?\b|tickets?\b|sparks?\b|crew\b|kinds?\b|laps?\b|rounds?\b|lanes?\b)/gi;
+const REASON = /\bwhy\b|\bbecause\b|\bso that\b|\blong enough\b|\bshort enough\b|\benough to\b|\bso (the|a|you|every|it)\b/gi;
+const JUICE_KINDS = [/shake|trauma/i, /hit-?stop|freeze[- ]frame|slow[- ]?mo|0\.\d+×/i, /flash/i, /particle|burst|confetti|sparks?\b/i, /squash|stretch/i, /haptic|vibrat/i, /\bpops?\b|punch/i];
+function clean(text) {
+    return text.replace(/\r/g, '').replace(/<[^<>\n]{2,}>/g, '').replace(/^\s*[-*\d.)]*\s*….*$/gm, '')
+        .replace(/^[^|#\n]{1,60}:\**\s*(·\s*)?$/gm, '').replace(/^\s*\*\*[^*\n]+:\*\*\s*$/gm, '');
+}
+export function scoreGdd(text) {
+    const t = clean(text);
+    const secs = sectionsOf(t);
+    const s = {};
+    const set = (k, score, lacking) => { s[k] = { score, why: score === 2 ? '' : lacking || SOLID[k] }; };
+    {
+        const sec = find(secs, /promise|pitch|premise|logline|thesis|fantasy|pillars|\bhook\b|the game\b|chosen design/i).length > 0;
+        const label = has(t, /^\s*\**(pitch|promise|premise|logline)\**\s*:\**\s*\S/im);
+        const afterTitle = t.replace(/^[\s\S]*?^#\s+.*$/m, '');
+        const first = afterTitle.split(/\n\s*\n/).map((p) => p.trim()).find((p) => p && !/^[#|>*-]/.test(p)) ?? '';
+        const opener = first.split(/\s+/).filter(Boolean).length;
+        const extras = [
+            ['the thesis in one frame', has(t, /thesis|in one (frame|number|image)/i)],
+            ['the 6-second ad', has(t, /\b(6|six)[- ]second/i)],
+            ['pillars or references (what you take, what you leave)', solidSec(secs, /pillars?|references?|dna|decisions/i, (b) => tableRows(b) >= 1 || items(b) >= 1)],
+        ];
+        const got = extras.filter(([, ok]) => ok).length;
+        if ((sec || label) && got >= 2)
+            set('pitch', 2, '');
+        else
+            set('pitch', sec || label || (opener >= 8 && opener <= 90) ? 1 : 0, sec || label ? `a pitch, but not yet: ${names(extras).join('; ')}` : 'no pitch: one line a stranger understands, then the thesis in one frame and the 6-second ad');
+    }
+    {
+        const loop = find(secs, /core loop|\bloops?\b|\brules\b|numbers|contract|tuning|balance|mechanic|how it plays|the game\b/i).length > 0;
+        const nums = count(t, NUM);
+        const table = solidSec(secs, /numbers|tuning|balance|constants|rules|contract|loop|the game\b/i, (b) => tableRows(b) >= 3);
+        const reasons = count(t, REASON) >= 3;
+        const lacking = names([['a core-loop section', loop], [`10+ numbers with units (${nums} found)`, nums >= 10], ['a reason for each number (a "why exactly this" column)', table || reasons]]);
+        set('core_loop_numbers', loop && nums >= 10 && (table || reasons) ? 2 : loop || nums >= 4 ? 1 : 0, lacking.length ? `missing: ${lacking.join('; ')}` : '');
+    }
+    {
+        const sec = find(secs, /first\s*(30|60|thirty|sixty|minute|seconds?|run|slice|session)|opening|onboarding|journey|moment ladder|tutorial|the first/i);
+        const long = sec.some((x) => x.body.replace(/<[^<>\n]*>/g, '').replace(/[|\s:-]+/g, ' ').trim().length >= 150);
+        const ladder = t.split('\n').filter((l) => /(?<![\d:])\d{1,2}:\d{2}(?![\d:])/.test(l) && (l.match(/[a-z]{3,}/gi) ?? []).length >= 3).length >= 3;
+        const kw = has(t, /first (30|60|thirty|sixty|ten|10|five|5) ?(s|sec|seconds)\b|first minute|onboarding|tutorial|moment ladder/i);
+        set('journey_first_60s', long || (ladder && (sec.length > 0 || kw)) ? 2 : sec.length || kw || ladder ? 1 : 0, sec.length || kw ? 'named, but not beat by beat: seconds for the first input, the first payoff and the signature on screen' : '');
+    }
+    {
+        const groups = [
+            ['a roster (kinds, each with one idea)', has(t, /roster|enem(y|ies)|\bfoes?\b|\bcast\b|\bkinds?\b|creatures|monsters|critters|opponents|rivals/i)],
+            ['levels or stages', has(t, /\b(stages?|waves?|levels?|chapters?|worlds?|islands?|floors?|tracks?|acts?|rooms?|areas?|regions?|cups?|boards?|gardens?)\b/i)],
+            ['a climax (boss phases or a final challenge)', has(t, /\bboss(es)?\b|climax|finale|final (challenge|stage|level|wave|room)/i)],
+            ['escalation (debuts, what each stage adds)', has(t, /debut|escalat|\bramp|introduc|teach(es)?\b|harder|difficulty/i)],
+        ];
+        const got = groups.filter(([, ok]) => ok).length;
+        const table = solidSec(secs, /roster|content|levels?|chapters?|stages?|worlds?|waves?|bosses|cast|kinds|the choir|repertoire|acts|tracks|cups|titans|enem/i, (b) => tableRows(b) >= 3);
+        const lacking = [...names(groups), ...(table ? [] : ['a content table (kind or stage, its one idea, its debut)'])];
+        set('content_plan', got >= 3 && table ? 2 : got ? 1 : 0, lacking.length ? `missing: ${lacking.join('; ')}` : '');
+    }
+    {
+        const adSec = find(secs, /\bAD rules|art rules|art direction/i);
+        const adRules = adSec.some((x) => items(x.body) >= 3 || tableRows(x.body) >= 3) || count(t, /\bAD-?\d\b/g) >= 3;
+        const groups = [
+            ['the look in one sentence', has(t, /art (bible|direction|style)|^#{1,4}\s*(the )?look\b|\blook\b[^.\n]{0,40}\b(sentence|is)\b/im) || find(secs, /\blook\b|style|art bible/i).length > 0],
+            ['AD rules checkable in one frame', adRules],
+            ['target frames', has(t, /target (frame|picture)s?|target\.png|key art|style frames?|first look/i)],
+            ['palette roles', count(t, /#[0-9a-f]{6}\b/gi) >= 3 || has(t, /palette|colou?rs? (as|by) (assignment|role|meaning)|colou?r (means|is assignment)|\bswatch/i)],
+            ['a font', has(t, /\bfonts?\b|typeface|display (type|face)|lettering|typography/i)],
+        ];
+        const got = groups.filter(([, ok]) => ok).length;
+        const lacking = names(groups);
+        set('art_direction', got >= 3 && adRules ? 2 : got ? 1 : 0, lacking.length ? `missing: ${lacking.join('; ')}` : '');
+    }
+    {
+        const sec = find(secs, /actors|\bcast\b|animation|characters|roster|the choir|puppets?|racers|crew/i);
+        const table = sec.some((x) => tableRows(x.body) >= 3 || items(x.body) >= 3);
+        const anim = has(t, /\bidle\b|animat|sprite ?sheet|\bframes?\b|\bposed?\b|\brigs?\b|\bclips?\b|\bIK\b|procedural|keyframe|squash|skeleton/i);
+        const lacking = names([['a cast table (actor, role, motion, states)', table], ['how each one moves (idle, states, sheet or rig)', anim]]);
+        set('actors_animation', table && anim ? 2 : sec.length || anim ? 1 : 0, lacking.length ? `missing: ${lacking.join('; ')}` : '');
+    }
+    {
+        const table = solidSec(secs, /juice|game ?feel|\bfeel\b|feedback|effects/i, (b) => tableRows(b) >= 3 || items(b) >= 4);
+        const kinds = JUICE_KINDS.filter((re) => re.test(t)).length;
+        const lacking = names([['a juice table (a row per event)', table], ['at least two kinds of response (shake, hitstop, flash, burst, squash, haptic)', kinds >= 2]]);
+        set('juice_feedback', table && kinds >= 2 ? 2 : table || kinds >= 2 || find(secs, /juice|feel|feedback/i).length ? 1 : 0, lacking.length ? `missing: ${lacking.join('; ')}` : '');
+    }
+    {
+        const sfx = has(t, /\bsfx\b|sound effects?|\bsounds?\b|\bcues?\b/i);
+        const music = has(t, /\bmusic\b|\bbgm\b|soundtrack|\bmotif\b|leitmotif|\bband\b|\bmelody\b/i);
+        const sec = find(secs, /audio|sound|music/i).some((x) => x.body.trim().length >= 150);
+        const lacking = names([['sound cues', sfx], ['a music identity', music], ['an audio section in the world\'s words', sec]]);
+        set('audio_plan', sfx && music && sec ? 2 : sfx || music ? 1 : 0, lacking.length ? `missing: ${lacking.join('; ')}` : '');
+    }
+    {
+        const groups = [
+            ['a HUD', has(t, /\bhud\b|top bar|score display|health (bar|pips|lights)/i)],
+            ['a title screen', has(t, /\btitle( screen)?\b|lock screen|main menu/i)],
+            ['pause', has(t, /\bpause/i)],
+            ['a win or end card', has(t, /\bwin\b|\bwon\b|victory|end card|chapter end|results?\b|\bclear(ed)?\b/i)],
+            ['a loss or retry screen (or a stated lossless design)', has(t, /\blose\b|\blost\b|game over|\bdeath\b|\bdie(s)?\b|\bretry\b|\bfail(ed|s)?\b|lossless|no (loss|fail)/i)],
+            ['settings or how to play', has(t, /settings|how[- ]to[- ]play|how-to|instructions/i)],
+            ['controls per device (touch and keys or pad)', has(t, /touch|thumb|\btap\b|swipe/i) && has(t, /keyboard|\bkeys\b|wasd|arrows?\b|gamepad|\bpad\b/i)],
+        ];
+        const got = groups.filter(([, ok]) => ok).length;
+        const hud = groups[0][1];
+        const lacking = names(groups);
+        set('screens_hud', got >= 5 && hud ? 2 : got >= 2 ? 1 : 0, lacking.length ? `missing: ${lacking.join('; ')}` : '');
+    }
+    {
+        const ok = solidSec(secs, /criteria|acceptance|definition of done|behaviou?r contract|success/i, (b) => items(b) >= 3 || tableRows(b) >= 3);
+        const ids = new Set(t.match(/\bC\d{1,2}\b/g) ?? []).size;
+        set('criteria', ok || ids >= 3 ? 2 : find(secs, /criteria|acceptance|contract/i).length || has(t, /criteri|acceptance/i) ? 1 : 0, 'criteria a player can check from the screen (C1…, copied to funpixel.json), or tests named after the rules');
+    }
+    {
+        const groups = [
+            ['retry or replay', has(t, /replay|play again|\bretry\b|restart|one more|\bagain\b/i)],
+            ['a best, rank or grade to beat', has(t, /\bbest\b|high ?score|leaderboard|\brank|\bgrades?\b|\bstars?\b|medals?|time trial|ghosts?\b/i)],
+            ['progression (levels, unlocks, seeds, endless)', has(t, /unlock|progression|\bmeta\b|daily|endless|\bseeds?\b|new game\+|mastery|chapters?|worlds?|\bcups?\b|levels?\b/i)],
+        ];
+        const got = groups.filter(([, ok]) => ok).length;
+        set('depth_replay', got === 3 ? 2 : got ? 1 : 0, `missing: ${names(groups).join('; ')}`);
+    }
+    {
+        const groups = [
+            ['what is cut or later (a cut list)', find(secs, /\bcuts?\b|out of scope|not in|non[- ]goals|backlog|\blater\b|deferred|won.t|\bscope\b|stand-?ins/i).some((x) => x.body.trim().length >= 80)],
+            ['the track or milestones with gates', has(t, /milestones?|build plan|\btrack\b|runbook|\bM\d\b|\bW\d\b|gr[ae]y-?box|vertical slice|first slice|\bgates?\b/i)],
+            ['the risks or open questions', has(t, /\brisks?\b|risky|open questions?|unknowns?|unproven|honestly/i)],
+        ];
+        const got = groups.filter(([, ok]) => ok).length;
+        set('scope_cuts', got >= 2 && groups.some(([, ok], i) => ok && i === 0) ? 2 : got ? 1 : 0, `missing: ${names(groups).join('; ')}`);
+    }
+    const total = SECTIONS.reduce((n, k) => n + s[k].score, 0);
+    const named = /\*{0,2}stage\*{0,2}\s*:\*{0,2}\s*([^\n·|;(]+)/i.exec(t)?.[1] ?? '';
+    const stage = TRACK.find((st) => new RegExp(`^\\s*${st.replace('.', '\\.').replace(/[- ]/g, '[- ]?')}\\b`, 'i').test(named)) ?? null;
+    return {
+        rubric: RUBRIC_VERSION,
+        score: Math.round((total / (2 * SECTIONS.length)) * 100) / 10,
+        sections: s,
+        asBuilt: find(secs, /part 2|as[- ]built|port spec|build spec/i).length > 0,
+        version: /\bv(\d+\.\d+)\b/i.exec(t.slice(0, 2000))?.[0] ?? null,
+        stage,
+        experience: scoreExperience(text),
+    };
+}
+export function thinSections(g) {
+    return SECTIONS.filter((k) => g.sections[k].score < 2).sort((a, b) => g.sections[a].score - g.sections[b].score);
+}
+const LABEL = {
+    pitch: 'promise', core_loop_numbers: 'core loop and numbers', journey_first_60s: 'first minute', content_plan: 'content',
+    art_direction: 'art direction', actors_animation: 'actors and animation', juice_feedback: 'juice', audio_plan: 'audio',
+    screens_hud: 'HUD and screens', criteria: 'criteria', depth_replay: 'depth and replay', scope_cuts: 'scope, track and risks',
+};
+export const sectionLabel = (k) => LABEL[k];
+export const EXPERIENCE_VERSION = 'x1';
+export const DIMENSIONS = ['depth', 'content', 'replay', 'story', 'world', 'arc', 'originality'];
+const X = {
+    depth: { label: /^\s*[-*]?\s*\**depth (and|&) mastery\**\s*:\**/im, words: [/skill ceiling|mastery|expert|master(ed|s)?\b/i, /naive|novice|skilled/i, /risk that pays|\bpar\b|combo|optimi[sz]/i], asks: 'what a skilled player does that a new one cannot, and how the bots will show the spread' },
+    content: { label: /^\s*[-*]?\s*\**content (and|&) progression\**\s*:\**/im, words: [/debut/i, /escalat|\bramp|each (level|stage|world|room) adds/i, /\b\d+\s*(levels?|stages?|worlds?|rooms?|areas?|chapters?|enem(y|ies)|kinds)\b/i], asks: 'how many distinct things, and when each arrives' },
+    replay: { label: /^\s*[-*]?\s*\**replay\**\s*:\**/im, words: [/come back|return tomorrow|one more (run|try|go)/i, /daily|\bseeds?\b|unlock|new game\+|leaderboard|best (score|time)/i, /second run|why (again|replay)/i], asks: 'why a player comes back tomorrow' },
+    story: { label: /^\s*[-*]?\s*\**story (and|&) storytelling\**\s*:\**/im, words: [/\bwants?\b|longs? for/i, /\bturn\b|twist|reveal|betray|midpoint/i, /payoff|ending|resolution|finale|homecoming/i], asks: 'a want, a turn, a payoff, and how play tells them' },
+    world: { label: /^\s*[-*]?\s*\**world building\**\s*:\**/im, words: [/landmark/i, /(its|their) own (rule|music|palette|look)/i, /\b(places|regions|biomes|districts|worlds)\b/i], asks: 'the places, each with its own rule and a landmark' },
+    arc: { label: /^\s*[-*]?\s*\**(emotional arc( (and|&) pacing)?|arc and pacing|pacing)\**\s*:\**/im, words: [/tension|intensity|pressure/i, /release|\brest\b|breather|calm|quiet/i, /climax|crescendo|\bpeaks?\b|finale/i], asks: 'where tension rises and where it rests over a session' },
+    originality: { label: /^\s*[-*]?\s*\**(originality|signature idea)\**\s*:\**/im, words: [/signature|the one (idea|mechanic)|never seen|no other game/i, /unlike|instead of|we leave|what'?s new/i], asks: 'the one idea the genre hit does not have' },
+};
+const HEADING_OF = {
+    depth: /^(depth|mastery|skill)\b/i, content: /^(content|progression)\b/i, replay: /^(replay|why (come )?back|retention)\b/i,
+    story: /^(the )?(story|narrative|plot)\b/i, world: /^(the )?(world|places|setting)\b/i, arc: /^(pacing|emotional arc|the arc|tension)\b/i,
+    originality: /^(signature|originality|the (one )?idea)\b/i,
+};
+export function scoreExperience(text) {
+    const t = clean(text);
+    const secs = sectionsOf(t);
+    const prose = (body) => body.split('\n').filter((l) => !/^\s*(\||#)/.test(l)).join(' ').match(/[A-Za-zÀ-ÿ0-9'’]+/g)?.length ?? 0;
+    const addressed = {}, why = {};
+    const raw = text.replace(/\r/g, '').replace(/<[^<>\n]{2,}>/g, '').replace(/^\s*[-*\d.)]*\s*….*$/gm, '');
+    const rawLines = raw.split('\n');
+    const isLabel = (l) => DIMENSIONS.some((d) => X[d].label.test(l));
+    for (const k of DIMENSIONS) {
+        const lab = X[k].label.exec(raw);
+        const at = lab ? raw.slice(0, lab.index + lab[0].length).split('\n').length - 1 : -1;
+        const rest = lab ? [raw.slice(lab.index + lab[0].length).split('\n')[0], ...underLabel(rawLines, at, isLabel)].join(' ') : '';
+        const words = (rest.match(/[A-Za-zÀ-ÿ0-9'’]+/g) ?? []).length;
+        const own = secs.some((s) => HEADING_OF[k].test(s.title) && prose(s.body) >= 25);
+        const hits = X[k].words.filter((re) => re.test(t)).length;
+        const fromLabel = words >= 8 || own ? 2 : words >= 1 ? 1 : 0;
+        addressed[k] = Math.max(fromLabel, hits ? 1 : 0);
+        why[k] = addressed[k] === 2 ? '' : `${addressed[k] ? 'named, not answered' : 'not addressed'}: ${X[k].asks}`;
+    }
+    const total = DIMENSIONS.reduce((n, k) => n + addressed[k], 0);
+    return { version: EXPERIENCE_VERSION, addressed, why, score: Math.round((total / (2 * DIMENSIONS.length)) * 100) / 10 };
+}
+export const EXPERIENCE_LABEL = {
+    depth: 'depth and mastery', content: 'content and progression', replay: 'replay', story: 'story and storytelling',
+    world: 'world building', arc: 'emotional arc and pacing', originality: 'originality',
+};

package/dist/gdd/size.js

@@ -0,0 +1,83 @@
+import { sections } from "../playtest/fidelity.js";
+const CLASSES = [
+    ['other', /\bliving\b|who (reacts|lives)|\bbeds?\b|ambien|atmospher|set[- ]pieces?|reactions?/i],
+    ['bosses', /boss|climax|final (challenge|fight)/i],
+    ['endings', /ending/i],
+    ['beats', /beat|story|cutscene|scene/i],
+    ['areas', /area|level|stage|chapter|world|floor|room|galler(y|ies)|hall|wing|region|track|zone|\bacts?\b|island|biome|district|board|wave/i],
+    ['kinds', /kind|enem|piece|creature|monster|foe|threat|unit|critter|opponent|rival|obstacle|hazard/i],
+];
+export const classOf = (what) => CLASSES.find(([, re]) => re.test(what))?.[0] ?? 'other';
+const PLACEHOLDER = /<[^<>\n]{2,}>|^…$/;
+const TOTAL = /^\W*(totals?|sum)\b/i;
+const cells = (l) => l.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim());
+const isRule = (l) => /^\s*\|[\s:|-]+\|\s*$/.test(l);
+const num = (c) => { const m = /(?<![\w.])(\d+(?:\.\d+)?)/.exec((c ?? '').replace(/[~≈]/g, '')); return m ? Number(m[1]) : null; };
+function table(body) {
+    const lines = body.split('\n').filter((l) => /^\s*\|.*\|\s*$/.test(l));
+    if (lines.length < 2)
+        return null;
+    const head = cells(lines[0]).map((h) => h.toLowerCase());
+    const rows = lines.slice(1).filter((l) => !isRule(l)).map(cells).filter((r) => r[0] && !PLACEHOLDER.test(r[0]) && !TOTAL.test(r[0]));
+    return { head, rows };
+}
+const col = (head, re, fallback) => { const i = head.findIndex((h) => re.test(h)); return i < 0 ? fallback : i; };
+const body = (text, re) => sections(text).find((s) => s.level === 2 && re.test(s.title))?.body ?? null;
+export const CONTENT_HEADING = /^content list\b/i;
+export const BUDGET_HEADING = /^art budget\b/i;
+export const AD_HEADING = /^(ad rules|art direction)\b/i;
+export function contentList(text) {
+    const b = body(text, CONTENT_HEADING);
+    const t = b === null ? null : table(b);
+    if (!t)
+        return b === null ? null : bullets(b);
+    const c = col(t.head, /count|how many|^n$/, 1), n = col(t.head, /names?|which|list/, 2), r = col(t.head, /reached|in play|built/, -1);
+    return t.rows.map((row) => ({ what: row[0], count: num(row[c]), names: PLACEHOLDER.test(row[n] ?? '') ? '' : row[n] ?? '', reached: r < 0 || PLACEHOLDER.test(row[r] ?? '') ? '' : row[r] ?? '' }));
+}
+function bullets(b) {
+    const out = [];
+    for (const m of b.matchAll(/^\s*[-*]\s+([^:(\n]{2,40}?)\s*(?:\((\d+)[^)]*\)\s*:?|:\s*(\d+)\b)([^\n]*)/gm)) {
+        out.push({ what: m[1].trim(), count: Number(m[2] ?? m[3]), names: m[4].replace(/^[\s.:,-]+/, '').trim().slice(0, 120), reached: '' });
+    }
+    return out;
+}
+export function artBudget(text) {
+    const b = body(text, BUDGET_HEADING);
+    const t = b === null ? null : table(b);
+    if (!t)
+        return b === null ? null : [];
+    const c = col(t.head, /count|how many|pieces|^n$/, 1), h = col(t.head, /made|how|route/, 2), k = col(t.head, /credit|cost|\$/, -1);
+    return t.rows.map((row) => ({ what: row[0], count: num(row[c]), how: PLACEHOLDER.test(row[h] ?? '') ? '' : row[h] ?? '', credits: k < 0 ? null : num(row[k]) }));
+}
+export function artDirection(text) {
+    const b = body(text, AD_HEADING);
+    if (b === null)
+        return null;
+    const lines = b.split('\n').map((l) => /^\s*(?:\d+[.)]|[-*]|AD-?\d+[:.]?)\s+(.+)$/.exec(l)?.[1].trim() ?? '').filter((l) => l && !PLACEHOLDER.test(l) && !/^…/.test(l) && !/^\**declined\b/i.test(l));
+    const d = /^\s*\**declined\**\s*:\**\s*(.+)$/im.exec(b)?.[1].trim() ?? null;
+    return { lines, declined: d && !PLACEHOLDER.test(d) ? d : null };
+}
+export function contentTotals(rows) {
+    const out = { areas: 0, kinds: 0, bosses: 0, endings: 0, beats: 0, other: 0 };
+    for (const r of rows)
+        out[classOf(r.what)] += r.count ?? 0;
+    return out;
+}
+const WORD = {
+    areas: ['area', 'areas'], kinds: ['kind', 'kinds'], bosses: ['boss', 'bosses'], endings: ['ending', 'endings'], beats: ['story beat', 'story beats'],
+};
+export function contentLine(rows) {
+    const t = contentTotals(rows);
+    const parts = Object.keys(WORD).filter((k) => t[k] > 0).map((k) => `${t[k]} ${WORD[k][t[k] === 1 ? 0 : 1]}`);
+    return parts.join(' · ') || `${rows.length} row${rows.length === 1 ? '' : 's'}, no counts yet`;
+}
+export function budgetLine(rows) {
+    const pieces = rows.reduce((n, r) => n + (r.count ?? 0), 0);
+    const priced = rows.filter((r) => r.credits !== null);
+    const credits = priced.reduce((n, r) => n + (r.credits ?? 0), 0);
+    return `${pieces} piece${pieces === 1 ? '' : 's'}${priced.length ? ` · about ${credits} credits` : ''}`;
+}
+export function oneLevelScope(text, rows) {
+    const said = /on purpose|by choice|one[- ]screen|a toy\b|jam\b|single[- ](level|screen) (is|by)/i.test(body(text, CONTENT_HEADING) ?? '');
+    return !said && contentTotals(rows).areas <= 1;
+}

package/dist/gdd/tiers.js

@@ -0,0 +1,148 @@
+const RANK = { core: 0, small: 1, mid: 2, deep: 3 };
+export const SECTION_TIER = {
+    'Where we are': 'core',
+    'Chapters': 'deep',
+    'Where the build moved': 'core',
+    'Linked pages': 'core',
+    'The invention': 'core',
+    'The studio pitch': 'core',
+    'Core loop': 'core',
+    'The hook': 'core',
+    'Opening': 'core',
+    'Shots': 'mid',
+    'Wow': 'mid',
+    'Hits, per axis': 'small',
+    'Worth against the genre': 'small',
+    'The numbers': 'small',
+    'Look': 'small',
+    'AD rules': 'small',
+    'Actors': 'small',
+    'Juice': 'small',
+    'Controls': 'small',
+    'Fix round (only while a round is unfinished)': 'small',
+    'Part 2 · Build spec (targets now; rewritten from the code once it runs, and from then on Part 2 wins)': 'small',
+    'Versions': 'mid',
+    'The promise': 'mid',
+    'The vision': 'small',
+    'Pillars and references': 'mid',
+    'Content': 'mid',
+    'Content list': 'small',
+    'Places': 'mid',
+    'Story': 'mid',
+    'Living world': 'small',
+    'Audio': 'small',
+    'HUD and screens': 'mid',
+    'Identity lock': 'mid',
+    'Asset script': 'mid',
+    'Art budget': 'mid',
+    'Criteria': 'mid',
+    'Lessons that apply': 'mid',
+    'First look': 'mid',
+    'Scope': 'mid',
+    'Build plan': 'mid',
+    'Risks': 'mid',
+    'Open questions': 'mid',
+    'Experience': 'deep',
+    'Getting around': 'deep',
+    'Track': 'deep',
+    'Pause points': 'deep',
+    'The spine': 'deep',
+    'Elements': 'deep',
+};
+export const RUBRIC_TIER = {
+    pitch: 'core', core_loop_numbers: 'small', journey_first_60s: 'small', art_direction: 'small',
+    actors_animation: 'small', juice_feedback: 'small', criteria: 'small',
+    content_plan: 'mid', audio_plan: 'mid', screens_hud: 'mid', depth_replay: 'mid', scope_cuts: 'mid',
+};
+export const seeds = (section, game) => RANK[section] <= RANK[game];
+export const SPINE = {
+    small: [],
+    mid: ['Versions', 'Scope', 'Build plan', 'Open questions'],
+    deep: ['Versions', 'Scope', 'Build plan', 'Open questions', 'Experience', 'Identity lock'],
+};
+export const seedsAt = (title, tier) => seeds(SECTION_TIER[title] ?? 'mid', 'small') || SPINE[tier].includes(title.replace(/ \(.*$/, ''));
+export const STAGE_SECTIONS = {
+    'key-look': ['First look'],
+    pitch: ['Wow'],
+    'first-look': ['First look', 'Identity lock', 'Asset script', 'Art budget', 'HUD and screens', 'Shots'],
+    'core-test': ['Content list'],
+    chapters: ['Chapters'],
+    slice: ['Places', 'Living world', 'Audio'],
+    hook: ['Opening'],
+    accuracy: ['Criteria'],
+    walk: ['Places', 'Getting around'],
+    panel: ['Criteria'],
+};
+export function sectionsForLine(line) {
+    const out = [];
+    if (/\b(story|stories|tale|narrat\w*|chapters?|characters?|cutscenes?)\b/i.test(line))
+        out.push('Story');
+    if (/\b(levels?|places?|world|towns?|islands?|valleys?|explore|exploring|3d|maps?|routes?|moons?|planets?)\b/i.test(line))
+        out.push('Places');
+    return out;
+}
+function split(md) {
+    const parts = md.split(/\n(?=## )/);
+    const head = parts[0].startsWith('## ') ? '' : parts.shift();
+    return { head, sections: parts.map((text) => ({ title: /^## (.+)$/m.exec(text)[1].trim(), text })) };
+}
+export function sizeTemplate(template, tier, also = []) {
+    const { head, sections } = split(template);
+    const kept = [], later = [], out = head ? [head] : [];
+    const extra = new Set(also.map((x) => x.replace(/ \(.*$/, '').toLowerCase()));
+    for (const s of sections) {
+        if (seedsAt(s.title, tier) || extra.has(s.title.replace(/ \(.*$/, '').toLowerCase())) {
+            kept.push(s.title);
+            out.push(s.text);
+        }
+        else
+            later.push(s.title);
+    }
+    if (later.length) {
+        out.push(`## Grows with the game\nThis GDD holds the core and what a ${tier} game needs. When the game calls for more, add the section from the template (skill funpixel-gdd, references/gdd-template.md): ${later.map((t) => t.replace(/ \(.*$/, '')).join(', ')}. Never fill a section to complete the template.`);
+    }
+    return { text: out.join('\n'), kept, later };
+}
+export const GROWS_HEADING = 'Grows with the game';
+export function sectionsForPicks(picks, focus) {
+    const out = new Set();
+    for (const c of picks.core ?? [])
+        for (const t of focus[c]?.sections ?? [])
+            out.add(t);
+    const story = picks.story?.[0];
+    if (story === 'light' || story === 'deep')
+        out.add('Story');
+    for (const x of picks.extras ?? []) {
+        if (x === 'voice') {
+            out.add('Audio');
+            out.add('Story');
+        }
+        if (x === 'cutscenes')
+            out.add('Story');
+    }
+    return [...out];
+}
+const short = (t) => t.replace(/ \(.*$/, '');
+const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+export function growFromShelf(gdd, template, wanted) {
+    const shelfAt = gdd.search(new RegExp(`^## ${GROWS_HEADING}[ \\t]*$`, 'm'));
+    if (shelfAt < 0)
+        return { text: gdd, grown: [] };
+    const next = gdd.slice(shelfAt + 1).search(/^## /m);
+    const shelfEnd = next < 0 ? gdd.length : shelfAt + 1 + next;
+    const shelf = gdd.slice(shelfAt, shelfEnd);
+    const { sections } = split(template);
+    const onShelf = (t) => new RegExp(`(:|,)\\s*${esc(short(t))}(?=[,.])`).test(shelf);
+    const want = (t) => (wanted.tier ? seedsAt(t, wanted.tier) : false)
+        || (wanted.sections ?? []).some((w) => short(w).toLowerCase() === short(t).toLowerCase());
+    const add = sections.filter((s) => onShelf(s.title) && want(s.title) && !new RegExp(`^## ${esc(short(s.title))}(?:[ \\t]*$| \\()`, 'm').test(gdd));
+    if (!add.length)
+        return { text: gdd, grown: [] };
+    const grown = add.map((s) => short(s.title));
+    const left = sections.filter((s) => onShelf(s.title) && !grown.includes(short(s.title))).map((s) => short(s.title));
+    const newShelf = left.length ? shelf.replace(/: [^\n]*?\. Never fill/, `: ${left.join(', ')}. Never fill`).trimEnd() : '';
+    const before = gdd.slice(0, shelfAt).trimEnd();
+    const after = gdd.slice(shelfEnd).replace(/^\n+/, '');
+    const parts = [before, add.map((s) => s.text.trimEnd()).join('\n\n'), newShelf, after.trimEnd()].filter(Boolean);
+    return { text: `${parts.join('\n\n')}\n`, grown };
+}

package/dist/gdd/world.js

@@ -0,0 +1,98 @@
+import { sections } from "../playtest/fidelity.js";
+import { classOf, contentList } from "./size.js";
+import { statedLength } from "../sim/judge.js";
+const PLACEHOLDER = /<[^<>\n]{2,}>|^…$/;
+const cells = (l) => l.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim());
+const rowsOf = (body) => body.split('\n')
+    .filter((l) => /^\s*\|.*\|\s*$/.test(l) && !/^\s*\|[\s:|-]+\|\s*$/.test(l)).slice(1)
+    .map(cells).filter((r) => r[0] && !PLACEHOLDER.test(r[0]));
+const items = (body) => body.split('\n').filter((l) => /^\s*(?:[-*]|\d+[.)])\s+\S/.test(l) && !PLACEHOLDER.test(l));
+const words = (s) => s.toLowerCase().replace(/[^a-z0-9à-ÿ ]+/g, ' ').split(/\s+/).filter((w) => w.length > 2 && !STOP.has(w));
+const STOP = new Set(['the', 'and', 'run', 'level', 'area', 'stage', 'chapter', 'world', 'moon', 'act', 'zone', 'map']);
+const splitNames = (s) => s.replace(/\([^)]*\)/g, '').replace(/\*/g, '').split(/\s*(?:,|·|;|\/)\s*/)
+    .map((x) => x.replace(/^and\s+/i, '').replace(/^.*:\s*/, '').replace(/^[\d.)\s]+/, '').trim()).filter((x) => x && !PLACEHOLDER.test(x));
+export function readWorld(text) {
+    const secs = sections(text);
+    const top = (re) => secs.filter((s) => s.level === 2 && re.test(s.title));
+    const rows = contentList(text) ?? [];
+    const areaRows = rows.filter((r) => classOf(r.what) === 'areas');
+    const areaCount = areaRows.reduce((n, r) => n + (r.count ?? 0), 0);
+    const areas = areaRows.flatMap((r) => splitNames(r.names));
+    const placeSecs = top(/^(places|the places|where it happens|locations)\b/i);
+    const placeBody = placeSecs.map((s) => s.body).join('\n');
+    const places = [...rowsOf(placeBody).map((r) => r[0]), ...items(placeBody).map((l) => l.replace(/^\s*(?:[-*]|\d+[.)])\s+/, '').split(/[:—–]/)[0].trim())];
+    const placesDeclined = /on purpose|one place|single (place|screen)|declined/i.test(placeBody) || /one (place|screen|level) on purpose/i.test(text);
+    const lockSecs = top(/^identity lock\b/i);
+    const lockBody = lockSecs.map((s) => s.body).join('\n');
+    const identityLock = lockSecs.length > 0 && (rowsOf(lockBody).length > 0 || /^\s*\**declined\**\s*:/im.test(lockBody) || /\bref-[\w-]+/i.test(lockBody));
+    const castSecs = secs.filter((s) => /^(actors|cast|characters|crew|roster)\b/i.test(s.title));
+    const recurring = castSecs.some((s) => rowsOf(s.body).length > 0 || items(s.body).length > 0);
+    const notes = [];
+    const n = areaCount || areas.length;
+    const many = n >= 2;
+    if (many && recurring && !identityLock) {
+        notes.push({ state: 'warn', what: `${n} places and a recurring cast, but no \`## Identity lock\`: across many pictures the hero, the vehicle and the companion drift (hair, outfit, silhouette, colours) unless each recurring design has a reference sheet and one verbatim style block every picture is drawn to (first-look.md, "Identity lock"); a "Declined:" line there is kept` });
+    }
+    if (many && !placesDeclined) {
+        if (!placeSecs.length) {
+            notes.push({ state: 'warn', what: `${n} places in the content list, no \`## Places\`: a row per place (atmosphere, the one play number it changes, its landmark, its picture) is what makes them places rather than one level repainted` });
+        }
+        else {
+            const placeWords = places.map(words);
+            const missing = areas.filter((a) => { const w = words(a); return w.length > 0 && !placeWords.some((pw) => w.some((x) => pw.includes(x))); });
+            if (missing.length)
+                notes.push({ state: 'warn', what: `levels without a place row: ${missing.join(', ')}` });
+            else if (!areas.length && places.length < areaCount)
+                notes.push({ state: 'warn', what: `${areaCount} places counted, ${places.length} place row(s)` });
+            const noPicture = rowsOf(placeBody).filter((r) => !r.slice(1).some((c) => /\.(png|jpe?g|webp)\b/i.test(c))).map((r) => r[0]);
+            if (noPicture.length)
+                notes.push({ state: 'note', what: `place rows with no picture yet: ${noPicture.join(', ')} (one picture per place: first-look.md)` });
+        }
+    }
+    notes.push(...hookNotes(text));
+    return { areas, areaCount, places, identityLock, recurring, notes };
+}
+const tableOf = (body) => body.split('\n')
+    .filter((l) => /^\s*\|.*\|\s*$/.test(l) && !/^\s*\|[\s:|-]+\|\s*$/.test(l)).map(cells);
+export function planHookCells(text) {
+    const out = [];
+    for (const s of sections(text).filter((x) => x.level === 2 && /^(hud and screens|screens|places|the places)\b/i.test(x.title))) {
+        const table = tableOf(s.body);
+        if (table.length < 2)
+            continue;
+        const head = table[0].map((c) => c.toLowerCase().replace(/\*/g, ''));
+        const at = (r, k) => { const i = head.indexOf(k); return i >= 0 && r[i] && !PLACEHOLDER.test(r[i]) ? r[i] : ''; };
+        if (!['wow', 'fun', 'hook'].some((k) => head.includes(k)))
+            continue;
+        for (const r of table.slice(1))
+            if (r[0] && !PLACEHOLDER.test(r[0]))
+                out.push({ name: r[0], wow: at(r, 'wow'), fun: at(r, 'fun'), hook: at(r, 'hook') });
+    }
+    return out;
+}
+export function hookNotes(text) {
+    const notes = [];
+    const length = statedLength(text);
+    if (!length || length.seconds < 300)
+        return notes;
+    const secs = sections(text);
+    if (!secs.some((s) => s.level === 2 && /^the hook\b/i.test(s.title))) {
+        notes.push({ state: 'warn', what: `a game of ${Math.round(length.seconds / 60)} min or more with no \`## The hook\`: the title and the first minutes decide whether people keep playing; name 2 to 4 wow moments on the clock and how each is proven (gdd-template.md)` });
+    }
+    for (const [label, re] of [['screen', /^(hud and screens|screens)\b/i], ['place', /^(places|the places)\b/i]]) {
+        const body = secs.filter((s) => s.level === 2 && re.test(s.title)).map((s) => s.body).join('\n');
+        const table = tableOf(body);
+        if (table.length < 2)
+            continue;
+        const head = table[0].map((c) => c.toLowerCase().replace(/\*/g, ''));
+        const wow = head.indexOf('wow'), hook = head.indexOf('hook');
+        const rows = table.slice(1).filter((r) => r[0] && !PLACEHOLDER.test(r[0]));
+        if (!rows.length)
+            continue;
+        const empty = (i, r) => i < 0 || !r[i] || PLACEHOLDER.test(r[i]) || /^[-–—]?$/.test(r[i]);
+        const missing = rows.filter((r) => empty(wow, r) || empty(hook, r)).map((r) => r[0]);
+        if (missing.length)
+            notes.push({ state: 'warn', what: `${label} rows with no Wow or Hook: ${missing.slice(0, 6).join(', ')}${missing.length > 6 ? ` and ${missing.length - 6} more` : ''} (what a player remembers there, and why they keep going)` });
+    }
+    return notes;
+}