@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/init/starter.js

@@ -0,0 +1,166 @@
+import { sectionsForLine, sizeTemplate } from "../gdd/tiers.js";
+export const CARD_WORDS = {
+    card: ['card', 'cards', 'deck', 'decks', 'deckbuilder', 'deck-builder', 'solitaire', 'poker', 'blackjack', 'tarot', 'hand of cards'],
+    platformer: ['platformer', 'platform', 'platforms', 'jump', 'jumps', 'jumping', 'climb', 'climber', 'climbing', 'metroidvania', 'side-scroller', 'sidescroller', 'maze', 'mazes', 'ghosts', 'pac-man', 'wall-jump', 'ledge'],
+    puzzle: ['puzzle', 'puzzles', 'match-3', 'match three', 'merge', 'merging', 'sokoban', 'tiles', 'blocks', 'sliding', 'slide', 'logic', 'riddle', 'riddles', 'word', 'words', 'jigsaw', 'sort', 'sorting', 'nonogram', 'sudoku', 'levels that get harder'],
+    racing: ['race', 'races', 'racing', 'racer', 'kart', 'karts', 'car', 'cars', 'drift', 'drifting', 'lap', 'laps', 'track', 'driving', 'drive', 'motorbike', 'rally'],
+    rpg: ['rpg', 'quest', 'quests', 'dungeon', 'dungeons', 'loot', 'sword', 'knight', 'wizard', 'mage', 'party', 'roguelike', 'adventure', 'hero', 'heroes', 'inventory', 'level up'],
+    shooter: ['shoot', 'shooter', 'shooting', 'shmup', 'shoot-em-up', 'bullet', 'bullets', 'gun', 'guns', 'blaster', 'laser', 'lasers', 'asteroids', 'invaders', 'twin-stick', 'turret', 'aim', 'fps'],
+    simulation: ['sim', 'simulation', 'farm', 'farming', 'garden', 'gardening', 'tycoon', 'manage', 'management', 'shop', 'cafe', 'restaurant', 'town', 'city', 'cozy', 'pet', 'pets', 'aquarium', 'bakery'],
+    strategy: ['strategy', 'tower defense', 'tower defence', 'rts', 'tactics', 'tactical', 'army', 'armies', 'turn-based', 'chess', 'siege', 'conquer', 'territory', 'lanes', 'units', 'kingdom'],
+    survival: ['survive', 'survival', 'survivor', 'survivors', 'horde', 'hordes', 'zombie', 'zombies', 'waves', 'wave', 'crafting', 'craft', 'hunger', 'bullet heaven', 'last stand', 'swarm'],
+};
+export const WEAK_WORDS = new Set([
+    'drift', 'drifting', 'drive', 'driving', 'track', 'car', 'cars',
+    'platform', 'platforms', 'jump', 'jumps', 'jumping', 'climb', 'climber', 'climbing', 'maze', 'mazes', 'ledge', 'ghosts',
+    'tiles', 'blocks', 'sliding', 'slide', 'logic', 'word', 'words', 'sort', 'sorting',
+    'party', 'adventure', 'hero', 'heroes', 'sword', 'knight', 'loot', 'quest', 'quests',
+    'aim', 'bullet', 'bullets', 'laser', 'lasers', 'gun', 'guns', 'turret',
+    'manage', 'shop', 'cafe', 'town', 'city', 'garden', 'gardening', 'pet', 'pets',
+    'army', 'armies', 'lanes', 'units', 'kingdom', 'territory', 'siege', 'conquer',
+    'survive', 'wave', 'waves', 'craft', 'crafting', 'hunger', 'swarm',
+]);
+const ARCADE_WORDS = ['arcade', 'score', 'high score', 'dodge', 'catch', 'collect', 'endless', 'one-button', 'one button', 'tap', 'reflex', 'reflexes', 'chain', 'combo'];
+const THREE_WORDS = ['3d', '3-d', 'three.js', 'threejs', 'first-person', 'first person', 'third-person', 'third person', 'voxel', 'voxels', 'low-poly', 'low poly', 'lowpoly', 'polygonal', 'fps'];
+const TWO_D_WORDS = ['2d', '2-d', 'pixel', 'pixel art', 'pixel-art', 'sprite', 'sprites', 'retro', 'side-scroller', 'sidescroller', 'top-down', 'paper', 'hand-drawn'];
+const PORTRAIT_WORDS = ['portrait', 'vertical', 'one thumb', 'one-thumb', 'one hand', 'one-handed', 'phone', 'mobile', 'iphone'];
+const LANDSCAPE_WORDS = ['landscape', 'sideways', 'widescreen', 'desktop', 'keyboard', 'gamepad', 'controller'];
+const CARD_ORIENTATION = {
+    arcade: null, card: 'portrait', platformer: 'landscape', puzzle: 'portrait', racing: 'landscape', rpg: 'landscape',
+    shooter: null, simulation: 'portrait', strategy: 'landscape', survival: 'landscape',
+};
+export const RECIPE = {
+    arcade: '.agents/skills/funpixel-gdd/references/start.md',
+    card: '.agents/skills/funpixel-gdd/references/genre-card.md',
+    platformer: '.agents/skills/funpixel-gdd/references/genre-platformer.md',
+    puzzle: '.agents/skills/funpixel-gdd/references/genre-puzzle.md',
+    racing: '.agents/skills/funpixel-gdd/references/genre-racing.md',
+    rpg: '.agents/skills/funpixel-gdd/references/genre-rpg.md',
+    shooter: '.agents/skills/funpixel-gdd/references/genre-shooter.md',
+    simulation: '.agents/skills/funpixel-gdd/references/genre-simulation.md',
+    strategy: '.agents/skills/funpixel-gdd/references/genre-strategy.md',
+    survival: '.agents/skills/funpixel-gdd/references/genre-survival.md',
+};
+const STOP = new Set(('a an the game games about of on in with where you your that and for to my me i make build little small polished complete ' +
+    'phone mobile browser which who is are play player plays playing where while into from as it its at by be can will want new fun cute simple ' +
+    'this one some very like just get gets go goes want will more really lot lots things stuff level levels hard harder easy easier ' +
+    'replay replays sound sounds effects effect punchy glowing juicy fast slow good great beautiful')
+    .split(' '));
+const norm = (s) => ` ${s.toLowerCase().replace(/[“”"'’]/g, ' ').replace(/[^a-z0-9.+#-]+/g, ' ').replace(/[.-]+(?=\s|$)/g, ' ').replace(/\s+/g, ' ').trim()} `;
+const hits = (line, words) => words.filter((w) => line.includes(` ${w} `));
+const MULTIPLAYER_WORDS = ['multiplayer', 'multi-player', 'online', 'co-op', 'coop', 'cooperative', 'versus', 'vs', 'pvp', 'deathmatch',
+    'with a friend', 'with friends', 'with my friend', 'with my friends', 'against a friend', 'against friends', 'two friends', 'my friends can',
+    'two players', '2 players', 'two-player', '2-player', 'four players', '4 players', 'with my brother', 'with my sister', 'invite code', 'room code'];
+const PHRASE_END = new Set('to on in at with who that which where while from for of by and or but as into onto over under through across against between so then when if'.split(' '));
+const VERBS = new Set(('rotate turn bring collect gather dodge avoid jump hop run dash race drive fly steer shoot fire throw catch match merge stack sort ' +
+    'build craft grow farm cook serve feed help save rescue escape guide lead push pull swap connect link flip slide tap drag swipe draw paint ' +
+    'fight defend protect guard explore find hide seek sneak steal deliver carry clean fix solve break smash bounce roll swing climb dig mine ' +
+    'survive manage plant water raise tame train breed trade sell buy keep hold let get put take give lose win beat chase hunt eat avoid').split(' '));
+export function nounPhrase(n) {
+    const all = n.trim().split(' ').filter(Boolean);
+    const about = all.indexOf('about');
+    const from = about >= 0 && about < all.length - 1 ? about + 1 : 0;
+    const phrase = [];
+    const words = all.slice(from);
+    for (const [i, w] of words.entries()) {
+        const verb = VERBS.has(w) || (/ing$/.test(w) && !/^games?$/.test(words[i + 1] ?? ''));
+        if (!phrase.length) {
+            if (STOP.has(w) || /^\d+$/.test(w) || /^games?$/.test(w) || PHRASE_END.has(w) || verb)
+                continue;
+            phrase.push(w);
+            continue;
+        }
+        if (PHRASE_END.has(w) || verb || STOP.has(w) || /^games?$/.test(w) || phrase.length >= 3)
+            break;
+        phrase.push(w);
+    }
+    return phrase.map((w) => w[0].toUpperCase() + w.slice(1)).join(' ');
+}
+export function pickStarter(raw) {
+    const line = raw.replace(/\s+/g, ' ').trim();
+    const n = norm(line);
+    const all = Object.entries(CARD_WORDS)
+        .map(([card, words]) => { const because = hits(n, words); const strong = because.filter((w) => !WEAK_WORDS.has(w)); return { card, because, strong: strong.length, score: strong.length * 2 + (because.length - strong.length) }; })
+        .filter((c) => c.because.length);
+    const qualified = all.filter((c) => c.strong >= 1 || c.because.length >= 2).sort((a, b) => b.score - a.score);
+    const statedRe = (w) => new RegExp(` (?:a|an|the|my) (?:[a-z0-9-]+ ){0,4}?${w.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')} (?:game|games|sim)\\b`);
+    const stated = qualified.find((c) => c.because.some((w) => !WEAK_WORDS.has(w) && statedRe(w).test(n)));
+    const scored = stated ? [stated, ...qualified.filter((c) => c !== stated)] : qualified;
+    const arcade = hits(n, ARCADE_WORDS);
+    const best = scored[0];
+    const tie = !stated && scored.length > 1 && scored[0].score === scored[1].score;
+    const weakOnly = all.filter((c) => !qualified.includes(c));
+    const unsure = tie
+        ? { candidates: [scored[0].card, scored[1].card], why: `${scored[0].card} (${scored[0].because.map((w) => `"${w}"`).join(', ')}) and ${scored[1].card} (${scored[1].because.map((w) => `"${w}"`).join(', ')}) match the line equally` }
+        : !best && weakOnly.length && arcade.length <= weakOnly[0].because.length
+            ? { candidates: weakOnly.map((c) => c.card), why: `only words with an everyday sense matched (${weakOnly.map((c) => `${c.card}: ${c.because.map((w) => `"${w}"`).join(', ')}`).join('; ')}), not enough to pick a recipe`, weak: true }
+            : undefined;
+    const card = !unsure && best && (stated || best.because.length >= arcade.length) ? best.card : 'arcade';
+    const because = card === 'arcade' ? (unsure ? [] : arcade) : best.because;
+    const rest = [...scored, ...weakOnly.sort((a, b) => b.score - a.score)];
+    const next = rest.find((c) => c.card !== card);
+    const three = hits(n, THREE_WORDS).filter((w) => !(w === 'fps' && hits(n, TWO_D_WORDS).length));
+    const two = hits(n, TWO_D_WORDS);
+    const engine = three.length && !two.length ? 'three' : 'pixi';
+    const engineBecause = engine === 'three' ? `3D words: ${three.map((w) => `"${w}"`).join(', ')}` : two.length ? `2D words: ${two.map((w) => `"${w}"`).join(', ')}` : 'no 3D word in the line, so Pixi, the 2D default';
+    const port = hits(n, PORTRAIT_WORDS), land = hits(n, LANDSCAPE_WORDS);
+    const byCard = CARD_ORIENTATION[card];
+    const orientation = port.length > land.length ? 'portrait' : land.length > port.length ? 'landscape' : byCard ?? 'landscape';
+    const orientationBecause = port.length !== land.length
+        ? `the line says ${(port.length > land.length ? port : land).map((w) => `"${w}"`).join(', ')}`
+        : byCard ? `how a ${card} game is usually held` : 'the scaffold\'s default';
+    const named = /^([A-Z0-9][\w'’!-]*(?:\s+[A-Z0-9][\w'’!-]*){0,3})\s*(?::|—|–|\s-\s)\s/.exec(line)
+        ?? /\b(?:called|named|titled)\s+["“']?([A-Z0-9][\w'’!-]*(?:\s+[A-Z0-9][\w'’!-]*){0,3})/.exec(line) ?? /["“]([^"”]{2,40})["”]/.exec(line);
+    const words = n.trim().split(' ').filter((w) => w && !STOP.has(w) && !/^\d+$/.test(w));
+    const kind = new Set([...Object.values(CARD_WORDS).flat(), ...ARCADE_WORDS, ...THREE_WORDS, ...TWO_D_WORDS, ...PORTRAIT_WORDS, ...LANDSCAPE_WORDS]);
+    const content = words.filter((w) => !kind.has(w)).slice(0, 3);
+    const pickWords = content.length ? content : words.slice(0, 3);
+    const titleWords = named ? named[1].trim() : nounPhrase(n) || pickWords.map((w) => w[0].toUpperCase() + w.slice(1)).join(' ');
+    const local = / (?:one|same|single|shared) (?:screen|device|phone|keyboard|tablet) | couch | hot ?seat | split ?screen | local /.test(n) && !/ online /.test(n);
+    const multi = local ? [] : hits(n, MULTIPLAYER_WORDS);
+    const folder = (named ? named[1] : titleWords || pickWords.join('-')).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 40) || 'game';
+    return {
+        line, card, because, also: next && next.card !== card ? { card: next.card, because: next.because } : null,
+        ...(unsure ? { unsure } : {}), ...(stated && card === stated.card ? { stated: true } : {}),
+        engine, engineBecause, orientation, orientationBecause,
+        title: titleWords || 'Untitled', titleFromLine: !!named, folder,
+        multiplayer: multi.length > 0, multiplayerBecause: multi,
+    };
+}
+export function templateOf(reference) {
+    if (!reference)
+        return null;
+    const m = /```markdown\n([\s\S]*?)\n```/.exec(reference);
+    return m ? m[1] : null;
+}
+export function seedGdd(p, name, template, date, tier) {
+    const q = (w) => w.map((x) => `"${x}"`).join(', ');
+    const cardLine = p.unsure?.weak
+        ? `**Genre card:** none (decided at init: ${p.unsure.why}; the GDD's own design, not ${p.unsure.candidates.join(' or ')}) · kept: <camera, body, how a run ends> · adapted: <choices for this game>`
+        : p.unsure
+            ? `**Genre card:** none picked yet: ${p.unsure.why}, so the owner is asked (a scope question in the chat) · kept: <camera, body, how a run ends> · adapted: <choices for this game>`
+            : p.card === 'arcade'
+                ? `**Genre card:** none picked (${p.because.length ? `arcade words: ${q(p.because)}` : 'no genre word in the line'}; the scaffold's own arcade round) · kept: <camera, body, how a run ends> · adapted: <choices for this game>`
+                : `**Genre card:** ${p.card} (from the line: ${q(p.because)}; recipe \`${RECIPE[p.card]}\`) · kept: <camera, body, how a run ends> · adapted: <choices for this game>`;
+    const header = [
+        `# ${name}`,
+        '',
+        `**Version:** v0.1 · ${date} · **Stage:** Design`,
+        `**Pitch:** ${p.line}`,
+        '**The 6-second ad:** <what someone sees in the first seconds that makes them want to play>',
+        '**The player\'s journey:** <what they see first and press (the real control) → the first objective → the first payoff>',
+        cardLine,
+        `**Orientation:** ${p.orientation} (${p.orientationBecause}) · **Input:** <keyboard, touch, pad>${p.multiplayer ? ` · **Players:** multiplayer (the line says ${q(p.multiplayerBecause)}; rooms on the relay, host-owned state: skill \`funpixel-game-spine\`)` : ''}`,
+        '',
+        '## Where we are',
+        `Design. Seeded from one line by \`funtools init\` on ${date}: the pitch is the line as written; the engine (${p.engine}: ${p.engineBecause}), the genre card and the orientation are the closest starters it found, each with its reason above. All of it is yours to change: rewrite the pitch, pick another card or none, turn the phone. Next: the rest of this document (skill \`funpixel-gdd\`), then the first playable slice.`,
+    ].join('\n');
+    if (!template)
+        return `${header}\n`;
+    const where = template.indexOf('\n## Where we are');
+    const at = where < 0 ? -1 : template.indexOf('\n## ', where + 1);
+    if (at < 0)
+        return `${header}\n`;
+    const rest = template.slice(at + 1);
+    return `${header}\n\n${tier ? sizeTemplate(rest, tier, tier === 'small' ? [] : sectionsForLine(p.line)).text : rest}\n`;
+}

package/dist/init/starters.js

@@ -0,0 +1,179 @@
+const sheetPath = (name) => `design/first-look/${name}.png`;
+const ref = (name, subject) => ({ name, kind: 'image', subject, out: sheetPath(name) });
+const sfx = (name, subject) => ({ name: `sfx-${name}`, kind: 'sound', subject, out: `public/assets/sfx/${name}.mp3`, params: { duration_seconds: 0.6 } });
+const theme = (subject) => ({ name: 'theme', kind: 'music', subject, params: { instrumental: true } });
+const ui = (refs) => [
+    { name: 'wordmark', kind: 'sprite', subject: 'the game\'s title lettered as art, made of the world\'s own material', references: refs, role: { w: 640 } },
+    { name: 'plate', kind: 'sprite', subject: 'one UI panel in the world\'s material, plain centre, a border that can nine-slice', references: refs, role: { w: 256 } },
+];
+const hero2d = (subject) => [
+    ref('ref-hero', `a character turnaround reference sheet of ${subject}: front, side and back on a plain light ground, the same proportions in every view`),
+    { name: 'player', kind: 'sprite', subject: `${subject}, whole, facing right`, references: ['ref-hero', 'ref-world'], role: { h: 96 } },
+];
+export const STARTERS = {
+    world3d: {
+        loop: 'you run and jump through a lit 3D space to collect what is scattered there before the clock runs out, while hazards with a visible tell push you to move',
+        conventions: [
+            'The camera follows behind and frames where you are going; it never clips into walls and never turns by itself, so up on the stick always means away.',
+            'A jump just after a ledge still counts and an early press fires on landing (0.1 s each); a held jump goes higher than a tap.',
+            'A shadow under the hero shows where a jump will land.',
+            'On a phone: a stick that appears where the left thumb lands, jump under the right thumb.',
+        ],
+        screens: [],
+        playLength: '15–20 minutes for a first-time player, to an ending (starter default: one round is 45 s; make rounds, places or chapters reach it)',
+        actors: [
+            ['hero', 'player-controlled', 'moves', 'idle, run (leans into speed), jump (stretch), fall, land (squash by impact), dash, toppled', '3D model from ref-hero (rigged: idle, run, jump)'],
+            ['pickup', 'goal', 'idles', 'bobbing and turning while there; a burst of sparks when taken', '3D model'],
+            ['flare', 'threat', 'still', 'a glowing ring through the tell (0.7 s), a column of light through the burn', 'code'],
+        ],
+        places: [['the square', 'drifting motes, the hero', 'one ambient bed', 'a pickup: sparks and a chime; the win: the view kicks wide', 'code scatter + ref-world']],
+        assets: [
+            ref('ref-hero', 'a character turnaround reference sheet of the hero: front, three-quarter, side and back on a plain light ground, about four heads tall, the same proportions in every view'),
+            ref('ref-world', 'a style frame of the play space from the play camera: the open ground, raised platforms and pillars, the light and the sky at the game\'s time of day'),
+            { name: 'hero', kind: 'model3d', subject: 'the hero, standing in a relaxed A-pose', from: 'ref-hero', references: ['ref-hero'], params: { animations: ['idle', 'run', 'jump'] } },
+            { name: 'pickup', kind: 'model3d', subject: 'the collectible, small and readable from far away, glowing', references: ['ref-world'] },
+            ...ui(['ref-world']),
+            sfx('pickup', 'a bright short chime for collecting a light'), sfx('jump', 'a soft quick whoosh of a jump'), sfx('land', 'a light thump of feet landing on stone'),
+            sfx('tell', 'a low rising hum of a ring of fire about to flare'), sfx('win', 'a short triumphant flourish'), sfx('lose', 'a deflating low sting'),
+            theme('a warm looping ambient theme for the place, gentle and adventurous'),
+        ],
+    },
+    arcade: {
+        loop: 'you make one quick choice over and over against a clock or a rising threat, chasing a best score',
+        conventions: ['A retry is under a second away.', 'The score and the best are always visible; a new best is announced.', 'Danger shows a tell before it can hurt.'],
+        screens: [], playLength: '15 minutes across many runs, to a last stage or an ending (one run 30–90 s)',
+        actors: [['player', 'player-controlled', 'moves', 'idle, act, hit, toppled', 'sprite from ref-hero'], ['threat', 'threat', 'moves', 'tell, strike, rest', 'sprite']],
+        places: [['the arena', 'ambient motion at the edges', 'one bed', 'a new best: a flourish', 'background image']],
+        assets: [...hero2d('the hero'), ref('ref-world', 'a style frame of the arena with the hero in play'), { name: 'background', kind: 'image', subject: 'the arena\'s backdrop, quiet in the middle', references: ['ref-world'] }, ...ui(['ref-world']), sfx('pickup', 'a bright short chime'), theme('a punchy looping arcade theme')],
+    },
+    card: {
+        loop: 'you draw, choose and play cards to beat a hand, a rival or a target, building a better deck or hand as you go',
+        conventions: ['A card lifts under the finger and shows what it will do before it is played.', 'The draw, the discard and the counts are visible.', 'An undo for a misplay where the rules allow it.'],
+        screens: [['deck view', 'every card owned', 'see what the deck is', 'a button on the play', 'play']], playLength: '15–20 minutes: a run of three acts to a final fight',
+        actors: [['card', 'piece', 'still', 'in hand, lifted, played, discarded', 'card frame + art per card'], ['rival', 'opponent', 'idles', 'thinking, playing, beaten', 'portrait']],
+        places: [['the table', 'the rival\'s hands, a candle', 'one bed', 'a big play: the table shakes', 'background image']],
+        assets: [ref('ref-world', 'a style frame of the table with cards in play'), { name: 'card-frame', kind: 'sprite', subject: 'a blank card frame in the world\'s material', references: ['ref-world'], role: { h: 280 } }, { name: 'table', kind: 'image', subject: 'the table seen from above', references: ['ref-world'] }, ...ui(['ref-world']), sfx('play', 'a crisp card slap'), theme('a calm looping theme for a card table')],
+    },
+    platformer: {
+        loop: 'you run and jump through rooms of hazards to reach the exit, dying fast and retrying faster',
+        conventions: ['Coyote time and a jump buffer (about 0.1 s each); a held jump goes higher than a tap.', 'Death costs seconds: back at the last checkpoint in about a second.', 'Maze chase: a turn pressed early is queued and taken at the next corner.'],
+        screens: [['level select', 'the rooms, the ones cleared', 'pick a room', 'title', 'play']], playLength: '15–20 minutes: 20–30 rooms of 30–60 s and a last room',
+        actors: [['hero', 'player-controlled', 'moves', 'idle, run, jump (stretch), fall, land (squash), dead', 'sheet from ref-hero'], ['enemy', 'threat', 'moves', 'patrol, notice, hit', 'sheet'], ['checkpoint', 'save', 'still', 'unlit, lit', 'sprite']],
+        places: [['each area', 'birds, drifting leaves', 'a bed per area', 'a checkpoint: it lights with a chime', 'parallax layers']],
+        assets: [...hero2d('the hero'), ref('ref-world', 'a style frame of a platforming room: ground, ledges, a hazard, the hero mid-jump'), { name: 'tiles', kind: 'texture', subject: 'the ground and ledge tiles', references: ['ref-world'] }, { name: 'enemy', kind: 'sprite', subject: 'a patrolling enemy whose shape says how it moves', references: ['ref-world'], role: { h: 80 } }, ...ui(['ref-world']), sfx('jump', 'a light jump'), sfx('land', 'a soft landing'), theme('a bright looping platformer theme')],
+    },
+    puzzle: {
+        loop: 'you place, swap, slide or merge pieces on a board to reach a goal, each move a small decision',
+        conventions: ['Undo and restart are one tap away.', 'Merge or drop: a drop line and the next piece shown.', 'A move pressed during an animation is queued, never lost.'],
+        screens: [['level select', 'the levels, stars per level', 'pick a level', 'title', 'play']], playLength: '15–20 minutes: 20–30 levels of 30–60 s and a final level',
+        actors: [['piece', 'piece', 'idles', 'resting, held, moving, cleared', 'sprite per kind'], ['board', 'place', 'still', 'calm, nearly full', 'image']],
+        places: [['the board', 'a small companion that reacts', 'one bed', 'a clear: pieces burst, the bed lifts', 'background image']],
+        assets: [ref('ref-world', 'a style frame of the board mid-play with every piece kind'), { name: 'pieces', kind: 'sheet', subject: 'every piece kind on one sheet, each readable at 48 px', references: ['ref-world'] }, { name: 'board', kind: 'image', subject: 'the board and its frame', references: ['ref-world'] }, ...ui(['ref-world']), sfx('merge', 'a satisfying soft pop'), theme('a calm looping puzzle theme')],
+    },
+    racing: {
+        loop: 'you steer around a track against rivals and the clock, taking the racing line and the risks it offers',
+        conventions: ['Rivals stay close (catch-up): the race is decided late.', 'The position and the lap are always on screen.', 'A crash costs time, never the race outright.'],
+        screens: [['results', 'positions, times, the best lap', 'race again or go on', 'the finish', 'play or title']], playLength: '15–20 minutes: a cup of 5 races of 3 laps',
+        actors: [['car', 'player-controlled', 'moves', 'drive, drift, boost, crash', 'model or sprite from ref-hero'], ['rival', 'opponent', 'moves', 'drive, overtake, crash', 'same, recoloured']],
+        places: [['the stands', 'an instanced crowd', 'a crowd murmur', 'an overtake: a roar; the finish: confetti', 'instanced cards']],
+        assets: [ref('ref-hero', 'a vehicle reference sheet: front, side, back and top'), ref('ref-world', 'a style frame of the track from the chase camera'), { name: 'car', kind: 'sprite', subject: 'the player\'s vehicle from above', references: ['ref-hero'], role: { h: 96 } }, { name: 'track', kind: 'image', subject: 'the track surface and its edges', references: ['ref-world'] }, ...ui(['ref-world']), sfx('boost', 'a short boost whoosh'), theme('a driving looping race theme')],
+    },
+    rpg: {
+        loop: 'you explore, fight and grow stronger to take on a quest a person asked of you',
+        conventions: ['The hero heals at a safe place; saving is automatic.', 'A new item shows what it changes before you take it.', 'Enemies telegraph their attacks.'],
+        screens: [['inventory', 'what you carry and wear', 'equip in one tap', 'a button on the play', 'play']], playLength: '15–25 minutes: 4 areas and a final boss',
+        actors: [['hero', 'player-controlled', 'moves', 'idle, walk, attack, hit, down', 'sheet from ref-hero'], ['enemy', 'threat', 'moves', 'patrol, wind-up, strike, recover', 'sheet'], ['quest giver', 'speaker', 'idles', 'waiting, talking, thanking', 'portrait + sprite']],
+        places: [['the village', 'people who greet you', 'a bed per place', 'a quest done: the village celebrates', 'tiles + props']],
+        assets: [...hero2d('the hero'), ref('ref-world', 'a style frame of the first area with the hero and a person to talk to'), { name: 'enemy', kind: 'sheet', subject: 'the first enemy', references: ['ref-world'] }, { name: 'tiles', kind: 'texture', subject: 'ground tiles of the first area', references: ['ref-world'] }, ...ui(['ref-world']), sfx('hit', 'a meaty hit'), theme('an adventurous looping theme')],
+    },
+    shooter: {
+        loop: 'you move and fire at waves of enemies, weaving through their shots',
+        conventions: ['Fire is automatic or one held press on a phone.', 'The hitbox is smaller than the ship.', 'Enemy shots stand out from everything else.'],
+        screens: [], playLength: '15 minutes: waves to a final boss',
+        actors: [['ship', 'player-controlled', 'moves', 'fly, fire, hit, invulnerable', 'sprite from ref-hero'], ['enemy', 'threat', 'moves', 'enter, fire, break', 'sprite'], ['boss', 'threat', 'moves', 'phases with tells', 'sprite']],
+        places: [['the sky', 'clouds and debris drifting', 'one driving bed', 'a boss down: the screen clears in light', 'parallax layers']],
+        assets: [...hero2d('the ship'), ref('ref-world', 'a style frame of a wave with shots on screen'), { name: 'enemy', kind: 'sprite', subject: 'a basic enemy', references: ['ref-world'], role: { h: 64 } }, { name: 'background', kind: 'strip', subject: 'a scrolling backdrop', references: ['ref-world'] }, ...ui(['ref-world']), sfx('shoot', 'a short laser zap'), theme('a driving looping shooter theme')],
+    },
+    simulation: {
+        loop: 'you build, tend and sell to grow a place, one small decision at a time',
+        conventions: ['Time pauses while you decide; a speed-up exists.', 'Every cost and gain is shown before you commit.', 'Progress keeps between sessions.'],
+        screens: [['shop', 'what you can buy and its price', 'buy in one tap', 'a button on the play', 'play']], playLength: '15–20 minutes to the last big upgrade and its ending',
+        actors: [['customer', 'visitor', 'moves', 'arrive, wait, happy, leave', 'sprite'], ['station', 'piece', 'still', 'idle, working, ready', 'sprite']],
+        places: [['the shop', 'customers coming and going', 'a cosy bed', 'a sale: coins chime; a level-up: lights', 'background image + props']],
+        assets: [ref('ref-world', 'a style frame of the place busy with people'), { name: 'customer', kind: 'sheet', subject: 'a customer walking', references: ['ref-world'] }, { name: 'station', kind: 'sprite', subject: 'the first work station', references: ['ref-world'], role: { h: 96 } }, ...ui(['ref-world']), sfx('coin', 'a cheerful coin chime'), theme('a cosy looping theme')],
+    },
+    strategy: {
+        loop: 'you place and command units to hold or take ground, reading what the other side will do',
+        conventions: ['Tactics: an undo for the turn and a preview of every move\'s result.', 'Tower defence: the next wave is shown; speed-up exists.', 'Ranges and paths show before you commit.'],
+        screens: [['level select', 'the maps, the stars won', 'pick a map', 'title', 'play']], playLength: '15–20 minutes: 5–7 maps and a last map',
+        actors: [['unit', 'player-controlled', 'moves', 'idle, move, attack, hurt, down', 'sheet from ref-hero'], ['enemy unit', 'opponent', 'moves', 'same states, another colour', 'sheet']],
+        places: [['the field', 'banners in the wind', 'a bed that swells in battle', 'a map won: banners rise', 'tiles + props']],
+        assets: [...hero2d('a unit'), ref('ref-world', 'a style frame of the field with both sides'), { name: 'tiles', kind: 'texture', subject: 'ground tiles of the field', references: ['ref-world'] }, ...ui(['ref-world']), sfx('order', 'a short command horn'), theme('a tactical looping theme')],
+    },
+    survival: {
+        loop: 'you move through growing hordes while your weapons fire on their own, picking an upgrade at every level',
+        conventions: ['Weapons fire automatically; you only move.', 'A level-up pauses for a pick of three.', 'Experience gems pull in when near.'],
+        screens: [['level-up pick', 'three upgrades with what each does', 'pick in one tap', 'a level gained', 'play']], playLength: '15 minutes: one run to the last wave and its boss',
+        actors: [['hero', 'player-controlled', 'moves', 'idle, walk, hit, down', 'sheet from ref-hero'], ['enemy', 'threat', 'moves', 'chase, hit, die', 'sheet per kind'], ['gem', 'pickup', 'idles', 'glint, pulled, taken', 'sprite']],
+        places: [['the field', 'the horde itself', 'a bed that rises with the count', 'a level-up: time slows, light', 'tiles']],
+        assets: [...hero2d('the hero'), ref('ref-world', 'a style frame of a horde closing in'), { name: 'enemy', kind: 'sheet', subject: 'the first enemy kind walking', references: ['ref-world'] }, { name: 'gem', kind: 'sprite', subject: 'an experience gem', references: ['ref-world'], role: { h: 32 } }, ...ui(['ref-world']), sfx('levelup', 'a rising level-up chime'), theme('an intense looping survival theme')],
+    },
+};
+export function starterPlaceholders(manifest) {
+    const key = manifest?.starter;
+    if (typeof key !== 'string' || !Object.hasOwn(STARTERS, key) || !Array.isArray(manifest.items))
+        return [];
+    const wrote = new Map(STARTERS[key].assets.map((a) => [a.name, a.subject]));
+    return manifest.items
+        .filter((it) => typeof it?.name === 'string' && typeof it.subject === 'string' && wrote.get(it.name) === it.subject)
+        .map((it) => it.name);
+}
+const BASE_SCREENS = [
+    ['title', 'the world behind, the name as art, one start control', 'start in one tap', 'load, or quit from pause', 'play'],
+    ['how to play', 'the verbs with their keys and gestures', 'say the controls in one look', 'title or pause', 'back'],
+    ['play', 'the HUD at the edges, the play in the middle', 'keep the play clear', 'start, resume, retry', 'pause, the endings'],
+    ['pause', 'resume, sound, how to play, quit', 'resume in one tap', 'the pause control, Escape', 'play or title'],
+    ['win / lose', 'the result, the score and the best, play again', 'retry in under a second', 'the round ending', 'play or title'],
+];
+const D = '(starter default)';
+const table = (head, rows) => [head, `|${head.split('|').slice(1, -1).map(() => '---').join('|')}|`, ...rows.map((r) => `| ${r.join(' | ')} |`)].join('\n');
+export function fillGdd(gdd, key) {
+    const s = STARTERS[key];
+    let out = gdd;
+    const put = (at, text) => { if (at.test(out))
+        out = out.replace(at, text); };
+    put(/^<one sentence: you <verb> <what> to <goal> while <what pushes back>>$/m, `${s.loop[0].toUpperCase()}${s.loop.slice(1)}. ${D}`);
+    put(/^Play length: <[^\n]*$/m, `Play length: ${s.playLength} ${D}`);
+    put(/^\| <hero> \| player-controlled[^\n]*\n\| <piece>[^\n]*$/m, s.actors.map((r) => `| ${r.join(' | ')} ${D} |`).join('\n'));
+    put(/^\| <stands, streets, rooftops>[^\n]*$/m, s.places.map((r) => `| ${r.join(' | ')} ${D} |`).join('\n'));
+    put(/^\| <title> \| <the title, one start control>[^\n]*$/m, [...BASE_SCREENS, ...s.screens].map((r) => `| ${r.join(' | ')} |`).join('\n'));
+    if (key === 'world3d') {
+        put(/^Cold open: <[^\n]*$/m, `Cold open: none: Play blends the title's orbit into the follow in 1.1 s and hands over at once ${D}`);
+        put(/^First control: <[^\n]*$/m, `First control: 0:01 · Objective on screen: "Gather the gems" · Distance: "N m" to the nearest gem, beside the count ${D}`);
+        put(/^\| <0:00> \| <title>[^\n]*\n\| <0:03>[^\n]*\n\| <0:08>[^\n]*$/m, [
+            `| 0:00 | title | the square the round is played on, orbiting slowly behind the wordmark | tap Play | hook: title vs play alike ${D} |`,
+            `| 0:01 | play | the hero, the gems, the HUD's "Gems 0 / 16 · 9 m" | move, jump, dash | hook: control at 1 s, objective on screen ${D} |`,
+        ].join('\n'));
+        put(/^\| <title> \| <title> \| <50°>[^\n]*\n\| <play>[^\n]*\n\| <the first beat>[^\n]*$/m, [
+            `| title | title | 50° | 7.5 m up, 21 m out | slow orbit over the square (0.07 rad/s) | <design/first-look/title.png> ${D} |`,
+            `| play | play | 50° | 4.4 m up, 9.5 m behind | follow, framing 0.35 s ahead, pulls in off walls | <design/first-look/play.png> ${D} |`,
+            `| a beat | reveal | 45° | 9 m up, 15 m behind | shoot('reveal', 1.2) at the beat, shoot('play', 0.8) after | <> ${D} |`,
+        ].join('\n'));
+    }
+    const block = ['', '## Conventions players bring', `Starter defaults from \`funtools init\` (the genre card's list): keep each, or break it on purpose and say so here and in the game.`, ...s.conventions.map((c) => `- ${c}`), ''].join('\n');
+    out = out.includes('\n## The numbers') ? out.replace('\n## The numbers', `${block}\n## The numbers`) : `${out.trimEnd()}\n${block}`;
+    if (!/\| win \/ lose \|/.test(out))
+        out = `${out.trimEnd()}\n\n## Screens (starter default)\n${table('| Screen | What is on it | The one thing it must do | Entered by | Leaves to |', [...BASE_SCREENS, ...s.screens])}\n`;
+    return out;
+}
+export function assetManifest(key, idea) {
+    const PICTURE = new Set(['image', 'sprite', 'sheet', 'texture', 'strip']);
+    const items = [...STARTERS[key].assets]
+        .map(({ references, ...it }) => (references && PICTURE.has(it.kind) ? { ...it, references: references.map(sheetPath) } : it))
+        .sort((a, b) => Number(b.name.startsWith('ref-')) - Number(a.name.startsWith('ref-')));
+    return JSON.stringify({
+        starter: key,
+        about: `The ${key === 'world3d' ? '3D world' : key} starter's placeholder art and sound${idea ? `, written for its demo round and not for "${idea.length > 80 ? `${idea.slice(0, 79)}…` : idea}"` : ''}, to make with \`npx @funpixel/tools assets gen\` (the hosted jobs; dry run first: --dry-run; estimate before paying). Reference sheets (ref-*) come first and every later picture names them in "references", so the cast and the world stay one design. Each subject is composed with assets/style.json; rewrite every subject for your game before generating (\`assets gen --dry-run\` names the ones still as the starter wrote them). Until a file lands the game draws its placeholder.`,
+        items,
+    }, null, 2) + '\n';
+}

package/dist/inspect/describe.js

@@ -0,0 +1,125 @@
+export function sourceOf(m) {
+    if (m.originalSource && m.originalLine)
+        return `${cleanPath(m.originalSource)}:${m.originalLine}`;
+    if (m.sourceFile && m.sourceLine)
+        return `${cleanPath(m.sourceFile)}:${m.sourceLine}`;
+    return null;
+}
+export function cleanPath(p) {
+    let path = p;
+    try {
+        if (/^[a-z]+:\/\//i.test(p))
+            path = new URL(p).pathname;
+    }
+    catch { }
+    return path.replace(/\?.*$/, '').replace(/^\/+/, '').replace(/^(\.\.\/)+/, '');
+}
+const num = (n, dp = 1) => (typeof n === 'number' && Number.isFinite(n) ? +n.toFixed(dp) : null);
+export function stateLine(m) {
+    const parts = [];
+    const p = m.position;
+    if (p)
+        parts.push(`at ${['x', 'y', 'z'].filter((k) => k in p).map((k) => `${k} ${num(p[k])}`).join(' ')}`);
+    const s = m.scale;
+    if (s && Object.values(s).some((v) => v !== 1))
+        parts.push(`scale ${Object.values(s).map((v) => num(v, 2)).join('×')}`);
+    const r = m.rotation;
+    if (r && Object.values(r).some((v) => typeof v === 'number' && Math.abs(v) > 1e-3))
+        parts.push(`rotation ${Object.values(r).map((v) => num(v, 2)).join(',')}`);
+    if (typeof m.alpha === 'number' && m.alpha !== 1)
+        parts.push(`alpha ${num(m.alpha, 2)}`);
+    if (m.visible === false)
+        parts.push('HIDDEN');
+    if (m.childCount)
+        parts.push(`${m.childCount} children`);
+    const b = m.bounds;
+    if (b && b.width > 0 && b.height > 0)
+        parts.push(`on screen ${Math.round(b.x)},${Math.round(b.y)} ${Math.round(b.width)}x${Math.round(b.height)}`);
+    if (m.parentLabel)
+        parts.push(`in ${m.parentLabel}`);
+    return parts.join(' · ');
+}
+export function describeHit(h) {
+    const m = h.metadata;
+    const what = h.kind === 'hud'
+        ? `HUD ${h.name}${m.cssClass ? ` .${m.cssClass.split(/\s+/)[0]}` : ''}`
+        : h.name === m.typeName ? h.name : `${h.name} (${m.typeName})`;
+    const lines = [what];
+    const state = stateLine(m);
+    if (state)
+        lines.push(`  ${state}`);
+    const data = { ...(h.data ?? {}), ...(m.componentProps ?? {}) };
+    if (Object.keys(data).length)
+        lines.push(`  data ${JSON.stringify(data).slice(0, 240)}`);
+    const src = sourceOf(m);
+    const none = h.kind === 'hud'
+        ? 'an element, not an engine object: find it by its text or class (its component is the "in" above when Preact rendered it)'
+        : 'none recorded (made by the engine itself, or before the inspector hooked it)';
+    lines.push(src ? `  made at ${src}${m.originalSourceLine ? `  ${m.originalSourceLine.slice(0, 120)}` : ''}` : `  made at — ${none}`);
+    return lines;
+}
+export function describeError(e) {
+    const where = sourceOf({ originalSource: e.originalSource, originalLine: e.originalLine, sourceFile: e.filename, sourceLine: e.line });
+    const lines = [`${e.type === 'unhandledrejection' ? 'unhandled rejection' : e.type === 'console_error' ? 'console.error' : 'uncaught'}: ${e.message.slice(0, 240)}`];
+    lines.push(where ? `  at ${where}${e.originalSourceLine ? `  ${e.originalSourceLine.slice(0, 120)}` : ''}` : '  at — no source line (no frame of the game in its stack)');
+    return lines;
+}
+export function mergeErrors(inspector, page) {
+    const key = (m) => m.trim().replace(/^Uncaught\s+/, '').replace(/^[A-Za-z]*Error:\s*/, '');
+    const seen = new Set(inspector.map((e) => key(e.message)));
+    return [...inspector, ...page.filter((e) => !seen.has(key(e.message)))];
+}
+export function sourceRefFromStack(stack) {
+    if (!stack)
+        return null;
+    for (const line of stack.split('\n')) {
+        if (/funpixel-|__FUNPIXEL|hooked-|hookFactory|makeHooked|node_modules|\/@vite\/|\/@fs\/|webpack|rollup|chunk-/.test(line))
+            continue;
+        const m = line.match(/(?:\(|@)((?:https?|file):\/\/[^\s)]+):(\d+):(\d+)/) || line.match(/at\s+((?:https?|file):\/\/[^\s)]+):(\d+):(\d+)/);
+        if (m)
+            return { f: m[1], l: +m[2], c: +m[3] };
+    }
+    return null;
+}
+export function treeLines(root, max = 120) {
+    if (!root)
+        return [];
+    const out = [];
+    let total = 0;
+    const walk = (n, depth) => {
+        total++;
+        if (out.length < max)
+            out.push(`${'  '.repeat(depth)}${n.name}${n.type && n.type !== n.name ? ` (${n.type})` : ''}${n.layer && n.layer !== 'canvas' ? ` [${n.layer}]` : ''}`);
+        for (const c of n.children ?? [])
+            walk(c, depth + 1);
+    };
+    walk(root, 0);
+    if (total > out.length)
+        out.push(`… ${total - out.length} more (--json has them all)`);
+    return out;
+}
+export const givenName = (n) => !!n.name && n.name !== n.type && !/^[A-Z][A-Za-z]*_\d+$/.test(n.name);
+export function givenNames(root, max = 24) {
+    const out = new Set();
+    const walk = (n) => {
+        if (out.size >= max)
+            return;
+        if (givenName(n))
+            out.add(n.name);
+        for (const c of n.children ?? [])
+            walk(c);
+    };
+    if (root)
+        walk(root);
+    return [...out];
+}
+export function parseAt(raw, viewport) {
+    const m = /^\s*(-?[\d.]+)(%?)\s*,\s*(-?[\d.]+)(%?)\s*$/.exec(raw);
+    if (!m)
+        return null;
+    const x = m[2] ? (Number(m[1]) / 100) * viewport.width : Number(m[1]);
+    const y = m[4] ? (Number(m[3]) / 100) * viewport.height : Number(m[3]);
+    if (!Number.isFinite(x) || !Number.isFinite(y) || x < 0 || y < 0 || x > viewport.width || y > viewport.height)
+        return null;
+    return { x: Math.round(x), y: Math.round(y) };
+}

package/dist/inspect/devserver.js

@@ -0,0 +1,40 @@
+import { readFileSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { join, resolve } from 'node:path';
+import { devtoolsPlugin, findDevtools } from "../dev/devtools.js";
+import { gameVite } from "../commands/dev.js";
+async function freePort() {
+    return new Promise((ok, fail) => {
+        const s = createServer();
+        s.once('error', fail);
+        s.listen(0, '127.0.0.1', () => {
+            const port = s.address().port;
+            s.close(() => ok(port));
+        });
+    });
+}
+export async function startDevServer(target) {
+    const dir = resolve(target);
+    const vite = await gameVite(dir);
+    if (!vite)
+        return `vite is not installed in ${dir} — run npm install (or pnpm install) first`;
+    let pkg = null;
+    try {
+        pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+    }
+    catch { }
+    const tools = findDevtools(pkg, dir);
+    if (typeof tools === 'string')
+        return tools;
+    const port = await freePort();
+    const server = await vite.createServer({
+        root: dir,
+        configFile: undefined,
+        logLevel: 'silent',
+        clearScreen: false,
+        plugins: [devtoolsPlugin(tools, [vite.searchForWorkspaceRoot(dir)])],
+        server: { host: '127.0.0.1', port, strictPort: true, hmr: false, watch: null, open: false },
+    });
+    await server.listen();
+    return { url: `http://127.0.0.1:${port}/`, tools, close: () => server.close() };
+}

package/dist/journey/diff.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { changedShare, sideBySide, UNCHANGED } from "../commands/compare.js";
+import { decodePng, encodePng } from "../look/png.js";
+export function notSameTest(a, b) {
+    const out = [];
+    if (a.script !== b.script)
+        out.push('the script changed');
+    if (a.seed !== b.seed)
+        out.push(`seed ${a.seed} → ${b.seed}`);
+    if (a.viewport !== b.viewport || a.size !== b.size)
+        out.push(`${a.viewport} ${a.size} → ${b.viewport} ${b.size}`);
+    if ((a.orientation || '') !== (b.orientation || ''))
+        out.push(`held ${a.orientation || 'as the game says'} → ${b.orientation || 'as the game says'}`);
+    return out;
+}
+const loadPng = (f) => (existsSync(f) ? decodePng(readFileSync(f)) : null);
+export async function diffRuns(a, b, out) {
+    const names = (r) => r.marks.map((m) => m.name);
+    const marks = [];
+    if (out)
+        await mkdir(out, { recursive: true });
+    for (const mb of b.marks) {
+        const ma = a.marks.find((m) => m.name === mb.name);
+        if (!ma)
+            continue;
+        const fa = loadPng(ma.frame), fb = loadPng(mb.frame);
+        const same = fa && fb && fa.width === fb.width && fa.height === fb.height;
+        let sheet = null;
+        if (out && fa && fb) {
+            sheet = join(out, `${mb.name}.png`);
+            await writeFile(sheet, encodePng(sideBySide(fa, fb)));
+        }
+        const keys = [...new Set([...Object.keys(ma.counters), ...Object.keys(mb.counters)])];
+        const counters = keys.filter((k) => JSON.stringify(ma.counters[k]) !== JSON.stringify(mb.counters[k]))
+            .map((k) => ({ field: k, before: ma.counters[k], after: mb.counters[k] }));
+        const verdicts = mb.expect.flatMap((e) => {
+            const was = ma.expect.find((x) => x.field === e.field && x.op === e.op && x.want === e.want);
+            return was && was.verdict !== e.verdict ? [{ field: `${e.field}${e.op}${e.want}`, before: was.verdict, after: e.verdict }] : [];
+        });
+        marks.push({ mark: mb.name, changed: same ? Math.round(changedShare(fa, fb) * 1000) / 1000 : null, counters, verdicts, sheet });
+    }
+    const not_same = notSameTest(a, b);
+    return {
+        before: a.run, after: b.run, same_test: !not_same.length, not_same,
+        same_build: !!a.fingerprint && a.fingerprint === b.fingerprint,
+        marks,
+        only_before: names(a).filter((n) => !names(b).includes(n)),
+        only_after: names(b).filter((n) => !names(a).includes(n)),
+        unchanged: marks.filter((m) => m.changed !== null && m.changed < UNCHANGED && !m.counters.length).map((m) => m.mark),
+    };
+}
+export function diffLines(d) {
+    const lines = [];
+    for (const m of d.marks) {
+        const bits = [];
+        if (m.changed === null)
+            bits.push('frame not comparable');
+        else if (m.changed >= UNCHANGED)
+            bits.push(`${Math.round(m.changed * 1000) / 10}% of the frame changed`);
+        if (m.counters.length)
+            bits.push(m.counters.slice(0, 6).map((c) => `${c.field} ${JSON.stringify(c.before) ?? '—'} → ${JSON.stringify(c.after) ?? '—'}`).join(', ') + (m.counters.length > 6 ? ` (+${m.counters.length - 6})` : ''));
+        for (const v of m.verdicts)
+            bits.push(`${v.field}: ${v.before} → ${v.after}`);
+        if (bits.length)
+            lines.push(`${m.mark}: ${bits.join(' · ')}`);
+    }
+    if (d.only_before.length)
+        lines.push(`reached before, not now: ${d.only_before.join(', ')}`);
+    if (d.only_after.length)
+        lines.push(`new marks: ${d.only_after.join(', ')}`);
+    return lines;
+}