@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/wow/catalogue.js

@@ -0,0 +1,86 @@
+const m = (id, family, name, hit, build, check) => ({ id, family, name, hit, build, check });
+const ev = (name) => ({ kind: 'event', name });
+const fr = (name) => ({ kind: 'frame', name });
+export const CATALOGUE = {
+    arcade: [
+        m('arcade-train', 'signature', 'The train you drag', 'Pac-Man Championship Edition DX', 'sleeping threats wake as you pass and fall in behind you; one power-up turns the whole line into a single chain of eats, each one worth more', ev('chain')),
+        m('arcade-near-miss', 'juice', 'A near miss slows time', 'Pac-Man Championship Edition DX', 'time drops to about 0.3× for 0.3–0.5 s when a threat comes within one body of the hero, so the escape is a choice', ev('near-miss')),
+        m('arcade-floor-answers', 'presentation', 'The floor answers every hit', 'Geometry Wars', 'the background grid or floor ripples out 2–4 bodies from every shot and death, so the whole screen reacts', fr('playing')),
+        m('arcade-panic-cost', 'feel', 'A panic button that costs', 'Pac-Man Championship Edition DX', 'one screen-clear per run that also drops the multiplier and the speed, so using it is a decision', ev('panic')),
+        m('arcade-one-more', 'feel', 'Back in under a second', 'Downwell', 'death to control again under 1 s, the next run on the same seed if the player wants it', ev('restart')),
+        m('arcade-attract', 'presentation', 'The title is the board playing itself', 'Pac-Man (attract mode)', 'the title runs a bot game on the real board behind the wordmark, so the promise is play', fr('title')),
+    ],
+    shooter: [
+        m('shooter-gun-is-move', 'signature', 'The gun is also how you move', 'Downwell', 'recoil slows the fall or pushes the ship; ammo comes back on landing or a stomp, so shooting and moving are one verb', ev('recoil-move')),
+        m('shooter-kick-sleep', 'juice', 'Kick, flash and a sleep on kills', 'Nuclear Throne', 'a muzzle flash, the gun kicks back, a 2–4 frame freeze on a kill, shells and bodies stay on the floor', ev('kill')),
+        m('shooter-roll-window', 'feel', 'A dodge with a committed tail', 'Enter the Gungeon', 'a 0.7 s roll whose first half is safe and second half is not, so timing it is the skill', ev('dodge')),
+        m('shooter-threat-colour', 'presentation', 'One colour means danger', 'Enter the Gungeon', 'enemy shots large, bright and in one colour no friendly thing uses, readable against a darker floor', fr('playing')),
+        m('shooter-boss-idea', 'signature', 'Each boss one new idea', 'Hollow Knight', 'every boss bends one rule the player has not seen elsewhere in the game, and teaches it in its first phase', ev('boss')),
+        m('shooter-pick-three', 'feel', 'A choice of three after each room', 'Hades', 'after each room three upgrades, each changing how a verb plays, so every run is authored by the player', ev('pick')),
+    ],
+    survival: [
+        m('survival-chest', 'signature', 'The chest that spins', 'Vampire Survivors', 'a reveal of 3–5 s with reels, rising light and a jingle; the rarer the prize, the longer and brighter', ev('chest')),
+        m('survival-vacuum', 'juice', 'Every gem flies to you at once', 'Vampire Survivors', 'a pickup pulls every gem on screen to the hero in under a second, with a rising chime per gem', ev('vacuum')),
+        m('survival-wave-clock', 'presentation', 'A clock with known stops', 'Brotato', 'a visible wave clock: 20 s first wave, +5 s per wave up to 60 s, a shop between waves', fr('playing')),
+        m('survival-evolution', 'signature', 'Two items become one', 'Vampire Survivors', 'a maxed weapon plus its partner item becomes a new weapon with its own look and sound', ev('evolve')),
+        m('survival-first-upgrade', 'feel', 'The first upgrade inside 20 s', 'Brotato', 'the first level-up or shop arrives by 20–30 s, before the player has time to doubt', ev('level-up')),
+        m('survival-late-spectacle', 'presentation', 'Minute ten looks nothing like minute one', 'Vampire Survivors', 'the screen late in a run is filled with the build\'s own effects; capture it as a moment view', fr('late')),
+    ],
+    platformer: [
+        m('platformer-dash-reads', 'signature', 'A dash the hero wears', 'Celeste', 'a dash of about three bodies in 0.15 s with a 50 ms freeze at the start; the hero\'s colour shows whether it is ready', ev('dash')),
+        m('platformer-forgiving-jump', 'feel', 'The jump that forgives', 'Celeste', 'coyote 0.1 s, a buffered press about 0.08 s, a 4 px nudge round corners, half gravity near the apex while held', ev('jump')),
+        m('platformer-pogo', 'signature', 'Bounce off what hurts you', 'Hollow Knight', 'a downward strike on an enemy or a spike bounces the hero up, turning a hazard into a step', ev('pogo')),
+        m('platformer-stretch', 'juice', 'Stretch up, squash down', 'Celeste', 'the hero stretches to about 0.6 × 1.4 on take-off and springs back; landings squash by impact', ev('land')),
+        m('platformer-death-beat', 'juice', 'A death that costs a second', 'Celeste', 'a 0.3–0.6 s readable burst, then the hero back at the last safe point in about 1 s', ev('death')),
+        m('platformer-silhouette', 'presentation', 'The hero is the clearest shape', 'Ori and the Blind Forest', 'the hero is the brightest, cleanest silhouette on a painted darker ground at every moment', fr('playing')),
+    ],
+    racing: [
+        m('racing-drift-tiers', 'signature', 'A drift that charges in colours', 'Mario Kart 8', 'holding a drift charges sparks through three colours; letting go fires a boost sized to the colour reached', ev('boost')),
+        m('racing-speed-lens', 'juice', 'The lens opens with speed', 'Burnout', 'the field of view widens 5–10° with speed, streaks at the edges, a low rumble rising with it', fr('playing')),
+        m('racing-takedown', 'juice', 'The crash you cause, replayed', 'Burnout 3', 'a rival you knock out cuts to a 1–2 s slow shot of the crash, then straight back to the race', ev('takedown')),
+        m('racing-restart', 'feel', 'Back on the line at once', 'Trackmania', 'one press puts the car on the start line or the last checkpoint in under a second', ev('restart')),
+        m('racing-ghost', 'signature', 'Race your best run', 'Trackmania', 'a translucent ghost of the player\'s best lap runs beside them, with the gap at each checkpoint', ev('ghost')),
+        m('racing-low-camera', 'presentation', 'Low behind, the road fills the frame', 'Mario Kart 8', 'the camera sits low behind the kart, the kart in the bottom third, so the road rushes at the player', fr('playing')),
+    ],
+    puzzle: [
+        m('puzzle-top-rung', 'signature', 'The rare top of the ladder', 'Suika Game', 'the last tier is rare and the loudest thing in the game: its own look, sound and a pause around it', ev('top-merge')),
+        m('puzzle-chain-pitch', 'juice', 'Each link a note higher', 'Puyo Puyo', 'every step of a chain plays a note a step higher and grows the pop, so a long chain sounds like a climb', ev('chain')),
+        m('puzzle-faces', 'presentation', 'Pieces with faces', 'Threes!', 'pieces carry faces that gain character up the ladder; warmth on abstract shapes', fr('playing')),
+        m('puzzle-undo', 'feel', 'Undo without shame', 'Baba Is You', 'unlimited undo and an instant restart, so trying an idea costs nothing', ev('undo')),
+        m('puzzle-one-word', 'signature', 'One new rule per level', 'Baba Is You', 'each level puts one new rule in the spotlight with known ones in support, taught by the layout alone', ev('new-rule')),
+        m('puzzle-score-sings', 'presentation', 'Play makes the music', 'Mini Metro', 'each placement adds a note in the line\'s pitch, so the board\'s state is heard', ev('note')),
+    ],
+    card: [
+        m('card-hand-goes-off', 'signature', 'The hand that goes off', 'Balatro', 'scoring as a performance: cards fire in order, chips and mult count up with rising pitch, the score catches fire on a big hand', ev('big-hand')),
+        m('card-intent', 'presentation', 'Every enemy shows its next move', 'Slay the Spire', 'the enemy\'s next action and its damage shown above it before the player commits', fr('playing')),
+        m('card-jiggle', 'juice', 'Cards that feel held', 'Balatro', 'a card tilts toward the pointer, wobbles when picked, snaps when played; numbers never collide', ev('play-card')),
+        m('card-run-breaker', 'signature', 'The pick that breaks the run open', 'Balatro', 'one rare card or relic that changes a rule and turns an ordinary deck into a machine', ev('run-breaker')),
+        m('card-pick-three', 'feel', 'A choice of three after each fight', 'Slay the Spire', 'three cards offered after each fight, with skip allowed, so the deck is the player\'s story', ev('pick')),
+        m('card-table-is-place', 'presentation', 'The table is a place', 'Inscryption', 'the table, the hands and the dealer belong to the world; the menu is a thing on the table', fr('title')),
+    ],
+    strategy: [
+        m('strategy-telegraph', 'signature', 'Every attack shown before your turn', 'Into the Breach', 'enemy attacks are drawn before the player moves, and moves can push enemies into each other', ev('push-kill')),
+        m('strategy-one-frame', 'presentation', 'The whole battle in one frame', 'Bad North', 'the map fits one phone frame, so every unit and threat reads in one look', fr('playing')),
+        m('strategy-upgrade-shape', 'juice', 'An upgrade changes the silhouette', 'Kingdom Rush', 'each tier of a tower or unit has its own shape, so strength reads at a glance', ev('upgrade')),
+        m('strategy-reset', 'feel', 'One reset per battle', 'Into the Breach', 'the player may rewind one turn per battle, so a misclick is never the end', ev('reset')),
+        m('strategy-paced-choice', 'feel', 'One upgrade a week', 'Mini Metro', 'one choice per period paces the ramp; the clock shows when the next one comes', ev('period')),
+        m('strategy-map-twist', 'signature', 'Each map one twist', 'Kingdom Rush', 'every map adds one rule of its own (a river that floods, a path that splits) that debuts alone', ev('twist')),
+    ],
+    simulation: [
+        m('sim-day-ends', 'signature', 'The day ends by itself', 'Stardew Valley', 'a day of about 14 real minutes ends on its own; the summary and the next morning are the hook', ev('day-end')),
+        m('sim-every-action', 'juice', 'Every action answers', 'Stardew Valley', 'each action a small sound and a short animation, never silence', ev('act')),
+        m('sim-calendar', 'presentation', 'What is coming is visible', 'Stardew Valley', 'a calendar or a sky that shows festivals, ripening and deadlines ahead', fr('playing')),
+        m('sim-placing-tells', 'signature', 'Placing things tells a life', 'Unpacking', 'where the player puts things reveals a person; the room at the end is the story', fr('end')),
+        m('sim-world-changes', 'presentation', 'The world changes because of you', 'Animal Crossing', 'a milestone changes the place itself (a bridge, a new district, a lit square), kept from then on', fr('after')),
+        m('sim-energy', 'feel', 'A day has a budget', 'Stardew Valley', 'energy or time caps a day\'s work, so every morning starts with a plan', ev('day-start')),
+    ],
+    rpg: [
+        m('rpg-death-is-story', 'signature', 'Death moves the story on', 'Hades', 'dying returns the hero home where people react to how they died; losing is content', ev('return-home')),
+        m('rpg-dash-strike', 'feel', 'A dash with a safe window', 'Hades', 'a short dash with 0.2–0.35 s of safety and a cooldown, a strike from it hits harder', ev('dash')),
+        m('rpg-hitstop', 'juice', 'Hits freeze by weight', 'Hollow Knight', 'a 50–100 ms freeze on a heavy hit, a flash and a push apart', ev('hit')),
+        m('rpg-remember', 'presentation', 'People remember what you did', 'Undertale', 'characters greet the player differently after a choice; one line per choice, kept', ev('remembered')),
+        m('rpg-boss-card', 'presentation', 'A boss arrives on a shot', 'Hollow Knight', 'the boss enters on its own shot with its name as a title card, then control comes back', fr('boss')),
+        m('rpg-mercy', 'signature', 'A fight you can end without winning it', 'Undertale', 'a second way through each fight (talk, spare, outwit) that the world remembers', ev('spare')),
+    ],
+};
+export const MOVES = new Map(Object.entries(CATALOGUE).flatMap(([card, ms]) => ms.map((x) => [x.id, { ...x, card: card }])));

package/dist/wow/picks.js

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

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@funpixel/tools",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "private": false,
+  "description": "funtools \u2014 the Funpixel CLI: init, dev, doctor, upgrade, smoke, verify, pack, login and publish.",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "bin": {
+    "funtools": "dist/bin.js"
+  },
+  "main": "dist/cli.js",
+  "files": [
+    "LICENSE",
+    "dist",
+    "plugins",
+    "unity",
+    "templates",
+    "bench",
+    "panel",
+    "NOTICE",
+    "!**/__pycache__",
+    "!**/*.pyc",
+    "!**/.DS_Store"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node -e \"require('node:fs').chmodSync('dist/bin.js', 0o755)\"",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "node --test \"test/*.test.ts\"",
+    "prepack": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && npm run build && node scripts/bundle-bench.ts && node scripts/bundle-verify.ts && node scripts/bundle-devtools.ts && node scripts/bundle-plugins.ts && node scripts/bundle-unity.ts && node ../../scripts/publish-leak-check.mjs --package .",
+    "leak-check": "node ../../scripts/publish-leak-check.mjs --package .",
+    "gen:api": "openapi-typescript ../../../docs/agent-platform/openapi.yaml -o src/api/generated/openapi.ts"
+  },
+  "dependencies": {
+    "playwright-core": "^1.63.0"
+  },
+  "peerDependencies": {
+    "hyperframes": "0.8.145"
+  },
+  "peerDependenciesMeta": {
+    "hyperframes": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@funpixel/verify": "file:../funpixel-verify",
+    "@types/node": "^22.0.0",
+    "openapi-typescript": "7.13.0",
+    "typescript": "5.9.3"
+  },
+  "engines": {
+    "node": ">=20.11"
+  }
+}

package/panel/asset-identity.md

@@ -0,0 +1,61 @@
+# Concept identity check
+
+You are checking whether {{WHAT}} still carries the identity of the concept image it was made from.
+Generation from a concept drifts: a scarf goes missing, a red coat turns orange, a stocky hero grows
+long legs, a horn moves to the other side. You judge identity, not quality, and you give no score.
+
+## The concept
+
+{{CONCEPT}}
+
+## The views
+
+{{VIEWS}}
+
+{{MEDIUM}}
+
+## First: list the concept's key features
+
+Before you open any view, study the concept and write down the parts that make this subject THIS
+subject and not another of its kind: named parts, markings, accessories, which side each is on
+(the subject's own left and right), and the main colours by where they sit. Three to ten short
+items. Every view is judged against this list and the concept, never against another view.
+
+## Then: judge each view on each trait
+
+{{TRAITS}}
+
+For each view and trait give one level, with evidence (which part, where, what changed):
+
+- `none`: holds.
+- `minor`: noticeably off, but a player would still call it the same subject.
+- `major`: a player would call it a different subject or a different version of it.
+- `unseen`: this view cannot show the trait (the face in a back view). Not drift.
+
+Rules:
+
+- A named part gained, lost, recoloured or reshaped is drift. A part that moves with the pose or the
+  action (an arm raised, a wing up, a coat swinging) is animation, not drift.
+- A part hidden by the angle is `unseen` for that part, not lost; say which view shows it instead.
+- Light is not palette: judge the colour of each part under the view's light, by hue family and
+  where it sits, not by exact values.
+- A level other than `unseen` needs evidence; one with none is not counted. For `features`, name
+  what was lost, gained or changed in the lists as well.
+
+## Your answer
+
+JSON only:
+
+```json
+{
+  "features": ["the key features you listed, one per item"],
+  "views": [
+    {
+      "view": "V1",
+      "traits": {
+{{ANSWER_KEYS}}
+      }
+    }
+  ]
+}
+```

package/panel/asset-structure.md

@@ -0,0 +1,55 @@
+# Asset structure check
+
+You are checking generated game art for STRUCTURAL mistakes: the kind a quick glance forgives and a
+player notices on the tenth look. You are not judging beauty, style or taste, and you give no score.
+A lovely picture with two different wheels fails here; an ugly picture built right passes.
+
+## What each picture should be
+
+{{SUBJECT}}
+
+## The pictures
+
+{{IMAGES}}
+
+Open each file and look at the whole picture, then at each part up close.
+
+## The questions
+
+Answer every question for every picture with `yes`, `no` or `n/a`, and give the evidence you saw:
+which part, where in the picture, what it looks like. `yes` means the picture is sound on that point.
+
+{{QUESTIONS}}
+
+Rules:
+
+- A `no` needs the part and the place ("the left eye, upper left, is round with a highlight; the
+  right one is a narrow oval with none"). An answer with no evidence is not counted.
+- Perspective and pose are not defects: a far part drawn smaller, a leg bent mid-stride, an eye
+  hidden by a turned head, the far-side wheels or legs hidden in a side view. Say so in the
+  evidence and answer `yes`.
+- The style is not a defect: chunky pixels, a flat cartoon or missing outlines are the art's choice.
+  Judge what the parts ARE, not how they are drawn.
+- `n/a` only where the question names something the picture has none of (no paired parts, no
+  lettering) — never because you are unsure. If you cannot tell, write `unsure` and why.
+- Look for the mistakes image models make: a sixth finger, a third ear, mismatched eyes, a limb
+  growing from the chest, a handle that joins nothing, a tail fused into a leg, letters that are
+  almost words, a head or foot sliced off by the frame.
+
+## Your answer
+
+JSON only, one entry per picture, in the order given:
+
+```json
+{
+  "images": [
+    {
+      "image": "A",
+      "seen": "what the picture shows, in one line",
+      "answers": {
+{{ANSWER_KEYS}}
+      }
+    }
+  ]
+}
+```

package/panel/blockers.md

@@ -0,0 +1,47 @@
+# Blind ledger judge: are last round's blockers still there, and does what worked still work?
+
+You judge TWO things from this round's evidence: for each blocker the last playtest of this game named,
+whether it is fixed, still there, or changed; and for each thing an earlier playtest named as already
+working (the do-not-regress list), whether it still works. You are not scoring the game, and you do not look
+for new problems; other seats do that. You were given only the blockers below, this round's evidence
+and last round's frames: no code, no scores, no account of what was changed. Open every image by its
+full path.
+
+## Last round's blockers (in the order they were ranked)
+
+{{BLOCKERS}}
+
+## What already worked (do not regress)
+
+{{KEEP}}
+
+## This round's evidence
+
+{{EVIDENCE}}
+
+## How to judge each one
+
+- **fixed**: this round's evidence shows the thing the blocker names working, at the same place
+  (the same view, the same moment on the route, the same step of play). Name what you saw.
+- **still there**: the same failure shows again, in the same place or another. Name where.
+- **changed**: the failure is different, not gone (worse, better, or moved: "the camera no longer
+  enters walls; it drops to straight overhead beside them"). Say what it is now.
+- **not observed**: nothing in this round's evidence reaches where the blocker lives (the blind
+  player never got there, no frame shows it). Absence of evidence is never "fixed".
+
+And for each thing that already worked:
+
+- **held**: this round's evidence shows it working as described. Name where.
+- **lost**: this round's evidence shows it gone or broken where it used to show. Name the frame or step.
+  This is a regression: be sure, and cite it.
+- **not observed**: nothing this round reaches it. Absence of evidence is never "lost".
+
+A blocker from a blind player is judged from this round's blind round first; one from a frame, from
+the same frame this round. Cite the frame or the step for every answer.
+
+## Answer with ONLY this JSON (no prose around it)
+
+```json
+{"blockers": [{"id": "B1", "status": "fixed|still there|changed|not observed", "evidence": "what this round shows, citing a frame or a step", "now": "for changed: what it is now"}],
+ "keep": [{"id": "K1", "status": "held|lost|not observed", "evidence": "what this round shows, citing a frame or a step"}]}
+```

package/panel/brief.md

@@ -0,0 +1,89 @@
+# Blind critic brief
+
+You are one of four critics scoring a browser game from what a player would see. You were given ONLY
+the store description below and the captures attached to this message: no design document, no code,
+no history, no one else's scores. Judge only what the evidence shows. Sound, haptics, input latency
+and screen shake cannot be judged from stills: say so rather than guess, and do not score them up or
+down for it.
+
+## The game (its store description)
+
+{{PREMISE}}
+
+## The evidence
+
+{{EVIDENCE}}
+
+Every image is named in the line of text just before it; cite captures by that name (for example
+`playing-phone`, `clip-play frames 5–7`). Measured numbers, when given, are facts: use them, do not
+re-measure them.
+
+## Numbers first, then your eyes
+
+When the evidence includes a **Measured facts** block, read it before the captures. Each fact is numbered
+(F1, F2, …) and names the free instrument that measured this build: its layout, its HUD in play,
+how well the player and the threats stand out from the ground, bots on its rules, frame times.
+Then look at the captures and judge as you would without them.
+
+- Where a score or a finding rests on a fact, cite it by its number beside the capture it shows
+  in, for example "HUD labels too small to read (F3, `playing-phone`)".
+- A passing number never excuses what you see: a contrast that measures fine but reads as mush in a
+  capture is still a problem. Your eyes decide the score.
+- A failing number you cannot see in any capture: say so, and weigh what the captures show.
+- With no facts given, judge from the captures alone.
+
+## Your persona
+
+You are the **{{PERSONA}}** critic:
+
+{{PERSONA_TEXT}}
+
+## Score (1–10, one decimal allowed)
+
+- **lookAndFeel**: art direction, coherence, does it look like one world from title to end card.
+- **readability**: can you read the state of play at a glance: you, the threats, what just happened.
+- **intuitiveness**: would a new player know what to do and why.
+- **juice**: the feel of the moments: impacts, feedback, payoffs.
+- **fun**: the loop and its decisions, as far as the evidence shows it.
+- **mobile**: not a rubric of its own: your `phone.overall` (below), the same axes re-read on the
+  phone captures.
+- **hud**: the HUD and UI: placement, clutter, overlaps, consistency.
+- **overall**: your own overall verdict (not an average).
+
+## Phone captures: the same rubric, re-pointed
+
+A capture named `…-phone` (or `ios-…`) is the game in a hand. Judge it on the same axes, re-read for a
+hand-held screen: **readability** at arm's length (pieces, numbers, words at the size the phone shows
+them), **intuitiveness** (where a thumb goes and what a touch does), **hud** (placement against thumbs,
+the notch and the home bar), **lookAndFeel** (framing in the orientation it is held: play gets the
+screen, nothing squeezed in). Fun and juice are the game's, on any screen.
+
+- Touch controls on a phone capture are never clutter for being there, and a missing key hint there is
+  never a defect. A button that repeats a gesture the play area already takes is a finding.
+- One capture, one platform: never average a desktop and a phone capture into one reading. A finding
+  names the platform whose capture shows it.
+- No phone capture: `phone` is `null`, and `mobile` is your read of phone fit from what is shown, with
+  "no phone capture" in `why.mobile`.
+
+Scale: 5 = a generic prototype; 6 = competent but forgettable; 7 = solid, store-ready; 8 = a hit a
+publisher would feature; 9–10 = best in class. Be specific and cite evidence by name. Praise nothing
+you cannot point at; criticise nothing you cannot point at.
+
+## Answer with ONLY this JSON (no prose around it)
+
+```json
+{
+  "critic": "{{PERSONA}}",
+  "read": 0,
+  "scores": { "lookAndFeel": 0, "readability": 0, "intuitiveness": 0, "juice": 0, "fun": 0, "mobile": 0, "hud": 0, "overall": 0 },
+  "phone": { "lookAndFeel": 0, "readability": 0, "intuitiveness": 0, "hud": 0, "overall": 0 },
+  "why": { "lookAndFeel": "…", "readability": "…", "intuitiveness": "…", "juice": "…", "fun": "…", "mobile": "…", "hud": "…" },
+  "best": ["3–5 things that work, each with its evidence"],
+  "worst": ["3–5 problems, each with its evidence"],
+  "fixFirst": ["5 concrete fixes in priority order, each saying which captures it would change"],
+  "quote": "one or two sentences a store page could quote (honest, yours)"
+}
+```
+
+`read` is how many of the captures you looked at. `phone` scores the phone captures alone, and
+`scores.mobile` equals `phone.overall`.

package/panel/clip.md

@@ -0,0 +1,54 @@
+# Clip critic brief
+
+You are one of the critics judging how a browser game FEELS in motion, from strips of consecutive
+frames of real play. You were given ONLY the store description below and the strips: no design
+document, no code, no other critic's answer. This is not the still-frame panel: judge what happens
+between frames. Sound, haptics and input latency cannot be seen here; say so rather than guess, and
+do not score them up or down for it.
+
+## The game (its store description)
+
+{{PREMISE}}
+
+## The strips
+
+{{EVIDENCE}}
+
+Each strip is 12 consecutive frames laid out left to right, top to bottom (frame 1 top left, frame
+12 bottom right), {{FRAME_MS}} ms apart, so one strip is about {{STRIP_MS}} ms of play. Cite what you
+saw by strip and frames, for example `strip-2 frames 5–8`.
+
+## What to judge (1–10 each)
+
+- **feel**: does an action read as cause and effect across the frames (a press, then the thing
+  answering within a frame or two), and does the motion have weight: anticipation, acceleration,
+  a landing?
+- **juice**: the answer to a payoff — impact frames, squash and stretch, flashes, particles, shake,
+  numbers that pop. How many frames does it last, and does it fit the action's size? Too much hides
+  play as surely as too little flattens it.
+- **motion**: can the eye follow the player and the threats from frame to frame, with no pops,
+  teleports, frozen actors or smears that hide where things are?
+- **clarity**: at speed, is it still clear what is happening and what to do next?
+
+A strip where nothing moves is evidence too: say which strip and score on what it shows.
+
+## Your persona
+
+You are the **{{PERSONA}}** critic:
+
+{{PERSONA_TEXT}}
+
+## Your answer
+
+JSON only:
+
+```json
+{
+  "scores": { "feel": 0, "juice": 0, "motion": 0, "clarity": 0 },
+  "why": { "feel": "…", "juice": "…", "motion": "…", "clarity": "…" },
+  "best": ["the moment that felt best, with its strip and frames"],
+  "worst": ["the moment that felt worst, with its strip and frames"],
+  "fixFirst": ["the one change to the motion or the juice that would help most"],
+  "unseen": ["what these strips cannot show (sound, latency, …)"]
+}
+```

package/panel/experience-personas.json

@@ -0,0 +1,4 @@
+{
+  "designer": "a systems and level designer who has shipped games in this genre. Where is the skill, what keeps arriving, what does a player master by hour one and hour ten, and why would they start another run? You weigh depth, content, replay and the arc of a session most.",
+  "storyteller": "a narrative and world designer. Who wants what, what turns, what pays off, and how much of it does play itself tell rather than text beside it? Which places would a player remember and describe to a friend? You weigh story, world, the arc and the signature idea most."
+}

package/panel/experience.md

@@ -0,0 +1,96 @@
+# Experience critic brief
+
+You are one of the critics judging a browser game on what still frames cannot show: depth, content,
+replay, story, world, the arc of a session and the signature idea. A separate panel already scored
+its look, readability and HUD from captures; do not score those here. You were given ONLY what is
+below: no code, no other critic's answer, no one's scores.
+
+## The game (its store description)
+
+{{PREMISE}}
+
+## The evidence
+
+{{EVIDENCE}}
+
+Read the **experience facts** (X1, X2, …) first: each is measured for free on this build by a named
+instrument (bots on the rules, real play on game time, the shipped files, the blind player's own
+words). Then the in-game text, the beat strip and the frames, then the design document.
+
+**Delivered, not claimed.** The design document says what the maker intended. Credit only what the
+play evidence, the frames or the text a player can read show; name what the document claims and
+nothing shows as `claimed`, and score as if it were absent. A document that promises seven worlds
+of which play reached one scores one.
+
+## Your persona
+
+You are the **{{PERSONA}}** critic:
+
+{{PERSONA_TEXT}}
+
+## Score each dimension 0–10 on these anchors
+
+Score what this build delivers, as a player would meet it. The anchors are the same for every game,
+from a jam toy to Hollow Knight, so a one-level slice will score low where only a longer game can go
+high; that is honest, not a fault of the slice. When the evidence cannot show a dimension at all,
+give `null` and say what would show it, rather than guessing.
+
+- **depth** (depth and mastery: does skill grow, and does play reward it?)
+  0 any input wins · 2 one verb, a naive player does as well as a skilled one · 4 a skill gap on
+  one axis, mastered within minutes; one thing to beat (a best score) · 6 a clear gap (skilled well
+  ahead of naive, a novice still gets a first success), two or more systems that interact, a target
+  most first-time players miss · 8 layered mastery: optional hard challenges, techniques experts
+  practise for tens of hours, expert play looks unlike novice play · 10 a ceiling people compete on
+  for years.
+- **content** (content and progression: how much is there, and does it keep arriving?)
+  0 one screen, nothing new after the first 30 s · 2 one level or loop, everything seen in the first
+  minutes · 4 a handful of levels or stages (3–10), each adding one thing, 15–30 minutes of new
+  content · 6 dozens of levels or 3–5 areas, a debut every few minutes over 1–3 hours, a climax ·
+  8 10–25 hours, many areas, dozens of kinds, bosses, unlocks paced across the whole ·
+  10 30+ hours, 100+ kinds, 20+ areas.
+- **replay** (would a player come back tomorrow, and why?)
+  0 nothing differs a second time, no reason given · 2 retry after a loss, nothing more ·
+  4 a best to beat (score, stars, par) or a new seed; "maybe" · 6 variety that changes the next run
+  (seeds, modes, unlocks) and a concrete reason to return · 8 runs that differ by the player's own
+  choices (builds, decks, boons) with progress carried between them · 10 an endless loop players
+  report hundreds of hours in.
+- **story** (story and storytelling: a want, a turn, a payoff, told through play)
+  0 no fiction · 2 a premise or setting only; no one wants anything · 4 a character with a want
+  stated in text, an ending card; the story sits beside play · 6 want, turn and payoff all delivered
+  in the game, at least one beat carried by play itself (a mechanic, a place, an action) ·
+  8 the story is told mostly through play and reacts to it (a death, a choice), characters with
+  arcs · 10 story and mechanic are one thing.
+- **world** (world building: places with their own rules, landmarks, consistency)
+  0 an abstract board, no place · 2 one backdrop with a named setting · 4 one coherent place with a
+  landmark, or several palette swaps of one place · 6 three or more places, each with its own look,
+  sound and at least one rule of its own, and landmarks to navigate by · 8 an interconnected world
+  whose history is told by its places, six or more areas each with their own rules, inhabitants and
+  music · 10 a world players map, theorise about and return to.
+- **arc** (emotional arc and pacing: tension and release across a session)
+  0 flat: nothing rises or falls · 2 one ramp to a fail, no release · 4 a tension-and-release cycle
+  inside a run, the same every time · 6 an arc across a session: ramps with rests, a climax, sound
+  or music that follows the state · 8 an authored arc over hours: peaks (bosses, finales), quiet
+  valleys, pacing shaped by the player's state · 10 an arc people remember as a whole.
+- **originality** (the signature idea, against its genre's hit)
+  0 a reskin of the genre hit · 2 the genre's standard rules under a new theme · 4 one twist that
+  changes a decision, not just the look · 6 a signature mechanic the genre hit does not have,
+  shaping play throughout · 8 a new combination others would copy · 10 a genre of its own.
+
+Cite evidence by fact id (X3), frame name, text line or beat (`beats 0:56 won`). Praise nothing you
+cannot point at; criticise nothing you cannot point at.
+
+## Answer with ONLY this JSON (no prose around it)
+
+```json
+{
+  "critic": "{{PERSONA}}",
+  "scores": { "depth": 0, "content": 0, "replay": 0, "story": 0, "world": 0, "arc": 0, "originality": 0 },
+  "why": { "depth": "…", "content": "…", "replay": "…", "story": "…", "world": "…", "arc": "…", "originality": "…" },
+  "claimed": ["what the design document promises that no evidence shows"],
+  "comeBack": "would you, as this persona, come back tomorrow? yes, maybe or no, and why in one sentence",
+  "best": ["2–4 things that give the game depth, story or world, each with its evidence"],
+  "worst": ["2–4 gaps, each with its evidence"],
+  "fixFirst": ["4 concrete changes in priority order that would raise the lowest dimensions most, each naming the dimension"],
+  "unseen": ["what this evidence cannot show (sound, hours of play, …)"]
+}
+```