@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/greenlight/page.js

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { designDoc, field } from "../gdd/doc.js";
+import { liveDecisions, readDecisions } from "../memory/decisions.js";
+import { BIBLE_FILE, readBible } from "./bible.js";
+import { drift, readLock } from "./lock.js";
+import { anchor, esc, fromDesign, markdown } from "./md.js";
+import { PITCHES_FILE, readPitches } from "./pitches.js";
+export const PAGE_FILE = join('design', 'greenlight.html');
+const stamp = (word, kind) => `<span class="stamp ${kind}">${esc(word)}</span>`;
+export function renderPage(root) {
+    const doc = designDoc(root);
+    const manifest = (() => { try {
+        return JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8'));
+    }
+    catch {
+        return {};
+    } })();
+    const title = /^#\s+(.+)$/m.exec(doc?.text ?? '')?.[1].trim() ?? manifest.name ?? 'Design';
+    const version = /\bv\d+(\.\d+)+\b/.exec((doc?.text ?? '').slice(0, 2000))?.[0] ?? 'no version';
+    const stage = field(doc?.text ?? '', 'Stage');
+    const lock = readLock(root);
+    const moved = lock ? drift(root, lock) : [];
+    const pitches = readPitches(root);
+    const bible = readBible(root);
+    const parts = [];
+    const sections = [];
+    if (pitches?.pitches.length) {
+        parts.push('pitches');
+        const cards = pitches.pitches.map((p) => {
+            const img = p.concept && existsSync(join(root, p.concept)) ? `<img src="${fromDesign(p.concept)}" alt="${esc(p.name)} concept" loading="lazy">` : '';
+            return `<article class="card">${img}<h3>${esc(p.id)} · ${esc(p.name)}</h3><dl>${Object.entries(p.fields).map(([k, t]) => `<dt>${esc(k === 'notGeneric' ? 'not generic because' : k === 'feel' ? 'feels like' : k === 'friend' ? 'tell a friend' : k)}</dt><dd>${esc(t)}</dd>`).join('')}</dl></article>`;
+        }).join('');
+        sections.push({ id: 'pitches', title: 'The pitches', html: `<div class="cards">${cards}</div><p class="muted">From ${esc(PITCHES_FILE)}.</p>` });
+    }
+    if (bible) {
+        parts.push('bible');
+        const body = markdown(readFileSync(join(root, BIBLE_FILE), 'utf8').replace(/^#\s+.*\n/, ''), root, { shift: 1 });
+        const hud = bible.hudMockup?.exists
+            ? bible.hudMockup.path.endsWith('.html') ? `<div class="phone"><iframe src="${fromDesign(bible.hudMockup.path)}" title="HUD mockup" loading="lazy"></iframe></div>` : `<img class="hud" src="${fromDesign(bible.hudMockup.path)}" alt="HUD mockup">`
+            : '';
+        const frames = bible.targets.filter((t) => t.exists).map((t) => {
+            const f = /[\w./-]+\.(png|jpe?g|webp)/i.exec(t.target)[0];
+            return `<figure><img src="${fromDesign(f)}" alt="${esc(t.moment)}" loading="lazy"><figcaption><b>${esc(t.moment)}</b>${t.intent ? ` · ${esc(t.intent)}` : ''}</figcaption></figure>`;
+        }).join('');
+        const read = [...bible.problems.map((p) => `<li class="warn">${esc(p)}</li>`), ...bible.notes.map((p) => `<li>${esc(p)}</li>`)].join('');
+        sections.push({ id: 'targets', title: 'Target frames', html: `${frames ? `<div class="frames">${frames}</div>` : '<p>No target frame on disk yet.</p>'}${hud ? `<h3>HUD mockup</h3>${hud}` : ''}` });
+        sections.push({ id: 'bible', title: `Style bible${bible.direction ? `: ${bible.direction.split(/[—–-]/)[0].trim()}` : ''}`, html: `${read ? `<ul class="read">${read}</ul>` : ''}${body.html}` });
+    }
+    if (doc) {
+        parts.push('gdd');
+        const body = markdown(doc.text.replace(/^#\s+.*\n/, ''), root, { shift: 1 });
+        sections.push({ id: 'design', title: `The design (${esc(doc.rel)})`, html: body.html });
+    }
+    const decisions = liveDecisions(readDecisions(root));
+    if (decisions.length) {
+        parts.push('decisions');
+        sections.push({ id: 'decisions', title: 'Decisions', html: `<ul>${decisions.map((d) => `<li><b>${esc(d.id)}</b> ${esc(d.date)} · ${esc(d.choice)}${d.over ? `, over ${esc(d.over)}` : ''}${d.because ? ` — ${esc(d.because)}` : ''}</li>`).join('')}</ul>` });
+    }
+    const lockLine = lock
+        ? `${stamp(`locked ${lock.version} · ${lock.date}`, moved.length ? 'ask' : 'done')}${moved.length ? ` <span class="muted">changed since the lock: ${esc(moved.join(', '))} — lock a new version</span>` : ''}`
+        : stamp('not locked', 'open');
+    const toc = sections.map((s) => `<a href="#gl-${s.id}">${s.title}</a>`).join('');
+    const html = `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${esc(title)} · design</title>
+<style>
+:root{--bg:#f4f3ef;--ink:#16161a;--muted:#5d5d66;--line:#dcdad3;--card:#fff;--done:#1f7a4d;--ask:#b4441c;--open:#5d5d66}
+@media (prefers-color-scheme:dark){:root{--bg:#111114;--ink:#ecebe6;--muted:#a3a3ad;--line:#2a2a31;--card:#19191e;--done:#5fcf95;--ask:#f08a5d;--open:#a3a3ad}}
+*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--ink);font:16px/1.55 system-ui,sans-serif}
+main{max-width:1100px;margin:0 auto;padding:24px 16px 80px}h1{font-size:clamp(30px,6vw,52px);margin:8px 0 4px}
+h2{font-size:24px;margin:48px 0 12px;padding-top:8px;border-top:1px solid var(--line)}h3{font-size:18px;margin:24px 0 8px}h4,h5,h6{font-size:16px;margin:18px 0 6px}
+nav.toc{position:sticky;top:0;z-index:2;background:var(--bg);border-bottom:1px solid var(--line);padding:8px 0;display:flex;flex-wrap:wrap;gap:4px 14px;font-size:14px}
+nav.toc a{color:var(--muted);text-decoration:none}nav.toc a:hover{color:var(--ink)}
+.muted{color:var(--muted);font-size:14px}.stamp{display:inline-block;font-size:12px;font-weight:600;letter-spacing:.06em;text-transform:uppercase;border:1.5px solid currentColor;border-radius:4px;padding:1px 6px;margin-right:6px}
+.stamp.done{color:var(--done)}.stamp.ask{color:var(--ask)}.stamp.open{color:var(--open)}
+.cards{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,300px),1fr));gap:14px}.card{background:var(--card);border:1px solid var(--line);border-radius:12px;padding:14px}
+.card.chosen{border:2px solid var(--done)}.card img{width:100%;border-radius:8px}dl{margin:0}dt{font-size:12px;text-transform:uppercase;letter-spacing:.06em;color:var(--muted);margin-top:8px}dd{margin:0}
+.scores{font-size:14px;color:var(--muted)}
+.frames{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,220px),1fr));gap:14px}figure{margin:0}figure img,img.hud{display:block;width:100%;height:auto;border-radius:10px;border:1px solid var(--line)}img.hud{max-width:393px}
+figcaption{font-size:14px;color:var(--muted);margin-top:6px}a.pic img{max-width:160px;border-radius:6px;border:1px solid var(--line);vertical-align:middle}
+.phone{background:#0b0b0e;border-radius:28px;padding:10px;max-width:420px}.phone iframe{display:block;width:100%;aspect-ratio:393/852;border:0;border-radius:18px;background:#000}
+.table{overflow-x:auto}table{border-collapse:collapse;font-size:14px;margin:8px 0}th,td{border-bottom:1px solid var(--line);padding:6px 10px;text-align:left;vertical-align:top}th{font-weight:600}
+pre{background:var(--card);border:1px solid var(--line);border-radius:8px;padding:10px;overflow-x:auto;font-size:13px}code{font-size:.92em}
+ul.read li.warn{color:var(--ask)}blockquote{margin:8px 0;padding-left:12px;border-left:3px solid var(--line);color:var(--muted)}
+</style></head><body><main>
+<p class="muted">Design page · rendered by funtools greenlight page from the design folder; edit the files, not this page</p>
+<h1>${esc(title)}</h1>
+<p>${stamp(version, 'open')}${stage ? stamp(stage, 'open') : ''}${lockLine}</p>
+<nav class="toc">${toc}</nav>
+${sections.map((s) => `<section id="gl-${anchor(s.id)}"><h2>${s.title}</h2>${s.html}</section>`).join('\n')}
+</main></body></html>
+`;
+    return { html, parts };
+}
+export function writePage(root) {
+    const { html, parts } = renderPage(root);
+    writeFileSync(join(root, PAGE_FILE), html);
+    return { file: PAGE_FILE, parts };
+}

package/dist/greenlight/pitches.js

@@ -0,0 +1,66 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { sections } from "../playtest/fidelity.js";
+export const GREENLIGHT_DIR = join('design', 'greenlight');
+export const PITCHES_FILE = join(GREENLIGHT_DIR, 'pitches.md');
+export const PITCH_FIELDS = [
+    { key: 'do', name: 'Do', label: /^(do|the player can do|verbs?)$/i, asks: 'what the player can do, in verbs, before any look or tech' },
+    { key: 'feel', name: 'Feels like', label: /^(feels? like|constraints?|experience)$/i, asks: 'the experiential constraints: session length, hands, pace, the feeling' },
+    { key: 'hook', name: 'Hook', label: /^hook$/i, asks: 'the hook in one sentence' },
+    { key: 'signature', name: 'Signature moment', label: /^signature( moment)?$/i, asks: 'the signature moment a trailer would open on' },
+    { key: 'friend', name: 'Tell a friend', label: /^(tell a friend|what a player tells a friend|the friend line)$/i, asks: 'what a player tells a friend, in their words' },
+    { key: 'notGeneric', name: 'Not generic because', label: /^(not generic( because)?|why not generic|unlike the genre)$/i, asks: 'why it is not the generic version of its genre' },
+];
+const LINE = /^\s*[-*]?\s*\*\*([^*:]+?):?\*\*:?\s*(.+)$/;
+const STOP = new Set('a an and the of to in on at for with by from as is are be it its their your you they this that into over under one two three who what when where which while not no but or so than then each every his her he she we our'.split(' '));
+const words = (s) => new Set((s.toLowerCase().match(/[a-z][a-z'-]{2,}/g) ?? []).filter((w) => !STOP.has(w)));
+export function overlap(a, b) {
+    const wa = words(`${a.fields.hook ?? ''} ${a.fields.signature ?? ''}`), wb = words(`${b.fields.hook ?? ''} ${b.fields.signature ?? ''}`);
+    const union = new Set([...wa, ...wb]).size;
+    return union ? [...wa].filter((w) => wb.has(w)).length / union : 0;
+}
+export const ALIKE = 0.4;
+export function parsePitches(text, file = PITCHES_FILE) {
+    const pitches = [];
+    for (const s of sections(text)) {
+        const m = /^(P\d+)\s*[·:|-]?\s*(.*)$/i.exec(s.title.trim());
+        if (!m || s.level !== 2)
+            continue;
+        const fields = {};
+        let concept;
+        for (const line of s.body.split('\n')) {
+            const l = LINE.exec(line);
+            if (!l)
+                continue;
+            const label = l[1].trim(), value = l[2].trim();
+            if (/^concept( image| frame)?$/i.test(label)) {
+                concept = /[\w./-]+\.(png|jpe?g|webp)/i.exec(value)?.[0];
+                continue;
+            }
+            const f = PITCH_FIELDS.find((x) => x.label.test(label));
+            if (f && value)
+                fields[f.key] = value;
+        }
+        pitches.push({ id: m[1].toUpperCase(), name: m[2].trim() || m[1], fields, ...(concept ? { concept } : {}), missing: PITCH_FIELDS.filter((f) => !fields[f.key]).map((f) => f.key) });
+    }
+    const alike = [];
+    for (let i = 0; i < pitches.length; i++)
+        for (let j = i + 1; j < pitches.length; j++) {
+            const o = overlap(pitches[i], pitches[j]);
+            if (o >= ALIKE)
+                alike.push({ a: pitches[i].id, b: pitches[j].id, overlap: Math.round(o * 100) / 100 });
+        }
+    const problems = [
+        ...(pitches.length < 3 ? [`${pitches.length} pitch(es); the concept pass wants three genuinely different ones (## P1 · <name>, ## P2 …, ## P3 …)`] : []),
+        ...pitches.filter((p) => p.missing.length).map((p) => `${p.id} lacks: ${p.missing.map((k) => PITCH_FIELDS.find((f) => f.key === k).asks).join('; ')}`),
+        ...alike.map((x) => `${x.a} and ${x.b} read as one idea (${Math.round(x.overlap * 100)}% of their hook and signature words shared): make one of them a different game`),
+    ];
+    return { file, pitches, alike, problems };
+}
+export function readPitches(root) {
+    const f = join(root, PITCHES_FILE);
+    return existsSync(f) ? parsePitches(readFileSync(f, 'utf8'), PITCHES_FILE) : null;
+}
+export function pitchText(p) {
+    return [`### ${p.id} · ${p.name}`, ...PITCH_FIELDS.map((f) => `- ${f.name}: ${p.fields[f.key] ?? '(not written)'}`)].join('\n');
+}

package/dist/greenlight/worth.js

@@ -0,0 +1,90 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { CATALOGUE, readPipeline } from "../pipeline/pipeline.js";
+import { appendEntry, nextCard, nextQuestion, readProgress } from "../progress/progress.js";
+import { addDecision } from "../memory/decisions.js";
+import { lastWorthQuestion, needsOwner, OPTION_WORDS, PROTOTYPE_STAGE, readWorth, topicOf, worthAskText, worthQuestion, WORTH_FILE } from "../gdd/worth.js";
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+const writeJson = (p, v) => { mkdirSync(dirname(p), { recursive: true }); writeFileSync(p, JSON.stringify(v, null, 2) + '\n'); };
+export function recordWorth(root, o = {}) {
+    const now = o.now ?? new Date();
+    const read = readWorth(root, { now, env: o.env });
+    if (!read)
+        return { read: null, asked: null, question: null, superseded: [] };
+    const was = readJson(join(root, WORTH_FILE));
+    writeJson(join(root, WORTH_FILE), was?.key === read.key ? { ...read, at: was.at } : read);
+    const s = readProgress(root);
+    const superseded = [];
+    for (const q of s.questions) {
+        if (!q.topic?.startsWith('worth:') || q.topic === topicOf(read) || q.state !== 'open')
+            continue;
+        appendEntry(root, { type: 'answer', q: q.id, at: now.toISOString(), pick: 'superseded', by: 'default', words: 'the plan changed: a new worth read replaces this question' });
+        superseded.push(q.id);
+    }
+    const have = worthQuestion(readProgress(root), read);
+    if (!needsOwner(read) || have || o.ask === false || (!read.complete && o.ask !== 'always'))
+        return { read, asked: null, question: have?.id ?? null, superseded };
+    const q = { type: 'ask', id: nextQuestion(readProgress(root)), at: now.toISOString(), kind: 'scope', stage: 'pitch', topic: topicOf(read), text: worthAskText(read), options: read.options };
+    appendEntry(root, q);
+    return { read, asked: q.id, question: q.id, superseded };
+}
+export function setTarget(root, minutes, o) {
+    if (!(Number.isFinite(minutes) && minutes >= 1 && minutes <= 6000))
+        throw new Error('the target is minutes of play, 1 to 6000');
+    let by = o.by;
+    if (o.by !== 'owner') {
+        const q = o.from ? readProgress(root).questions.find((x) => x.id === o.from) : null;
+        if (!q || !q.topic?.startsWith('worth:') || q.answer?.pick !== 'shrink' || q.answer.by !== 'owner')
+            throw new Error('the target is the owner\'s: they say it in the chat and you record it with --target <minutes> --by owner; you may write it only from their "shrink" answer (--from <Q>)');
+        by = `the owner's shrink answer ${q.id}`;
+    }
+    const file = join(root, 'funpixel.json');
+    const m = readJson(file) ?? {};
+    m.target_minutes = Math.round(minutes * 10) / 10;
+    m.target_set = { by, at: (o.now ?? new Date()).toISOString() };
+    writeFileSync(file, JSON.stringify(m, null, 2) + '\n');
+    return { minutes: m.target_minutes, by };
+}
+export function chooseWorth(root, pick, why, now = new Date()) {
+    const go = readJson(join(root, 'funpixel.json'))?.flow?.autonomy === 'go';
+    if (!go)
+        throw new Error('the worth question is the owner\'s: they answer it in the chat (record it with progress answer); only under their own autonomy "go" (funpixel.json flow.autonomy) do you record a choice');
+    if (!why.trim())
+        throw new Error('say why: --why "<the reason, in numbers>"');
+    if (pick === 'drop')
+        throw new Error(`dropping the game is the owner's act, never the agent's, even under go: recommend it on a card with the numbers; they answer the worth question "drop" in the chat, or run \`npx @funpixel/tools flow drop --by owner "<their words>"\``);
+    const rec = readWorth(root, { now });
+    if (!rec)
+        throw new Error('no GDD to read worth on');
+    const s = readProgress(root);
+    const q = worthQuestion(s, rec);
+    if (!q)
+        throw new Error('no worth question on this plan: run `greenlight worth` first (it asks when the verdict is not fits)');
+    if (!q.options.includes(pick))
+        throw new Error(`${q.id} takes one of: ${q.options.join(', ')}`);
+    appendEntry(root, { type: 'answer', q: q.id, at: now.toISOString(), pick, by: 'default', words: why.trim().slice(0, 500) });
+    const d = addDecision(root, { choice: `Worth: ${pick} (${q.id}, verdict ${rec.verdict})`, over: q.options.filter((x) => x !== pick).join(', '), because: `${why.trim()} — under the owner's autonomy go` }, now);
+    appendEntry(root, { type: 'card', n: nextCard(readProgress(root)), at: now.toISOString(), kind: 'decided', stage: 'pitch', line: `Worth building at this length? ${rec.verdict}: the agent chose ${pick} under your "go"`, observed: false, why_not: 'a decision, not a frame', decisions: [`${pick}: ${why.trim().slice(0, 200)} (${d.id})`], asks: q.id });
+    if (pick === 'prototype')
+        ensurePrototype(root, now);
+    return { q: q.id, pick: pick, decision: d.id };
+}
+export function ensurePrototype(root, now = new Date(), p0 = null) {
+    const q = lastWorthQuestion(readProgress(root));
+    if (q?.answer?.pick !== 'prototype')
+        return false;
+    const p = p0 ?? readPipeline(root);
+    if (!p || p.stages.some((x) => x.id === PROTOTYPE_STAGE))
+        return false;
+    const c = CATALOGUE[PROTOTYPE_STAGE];
+    const at = p.stages.findIndex((x) => x.id === 'pitch');
+    p.stages.splice(at + 1, 0, { id: PROTOTYPE_STAGE, title: c.title, why: `${c.why} (${q.id}, ${q.answer.by === 'owner' ? 'the owner' : 'the agent under go'}, ${now.toISOString().slice(0, 10)})`, gates: [...c.gates, { kind: 'play' }, { kind: 'worth', played: true }].map((g) => ({ ...g })), status: 'open' });
+    writeJson(join(root, 'design', 'pipeline.json'), p);
+    return true;
+}
+export const optionWords = (o) => OPTION_WORDS[o] ?? o;

package/dist/guidance.js

@@ -0,0 +1,24 @@
+import { createHash } from 'node:crypto';
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const isGuidance = (rel) => rel === 'AGENTS.md' || rel === 'CLAUDE.md' || rel.startsWith('.agents/');
+function walk(root, rel = '', out = []) {
+    for (const e of readdirSync(join(root, rel), { withFileTypes: true })) {
+        const child = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory())
+            walk(root, child, out);
+        else if (isGuidance(child))
+            out.push(child);
+    }
+    return out;
+}
+export function guidanceHash(common) {
+    return guidanceHashOf(walk(common).map((rel) => [rel, readFileSync(join(common, rel), 'utf8')]));
+}
+export function guidanceHashOf(files) {
+    const h = createHash('sha256');
+    for (const [rel, text] of [...files].filter(([rel]) => isGuidance(rel)).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) {
+        h.update(rel).update('\0').update(text.replace(/\r\n/g, '\n')).update('\0');
+    }
+    return h.digest('hex').slice(0, 16);
+}

package/dist/init/bare.js

@@ -0,0 +1,114 @@
+import { probeSkeletonFor } from "../sim/skeleton.js";
+export const BARE_SRC = new Set([
+    'src/assets.ts', 'src/frame.ts', 'src/fpx-hooks.ts', 'src/look.ts', 'src/look.json', 'src/platform.ts', 'src/probe-kit.ts',
+    'src/probe-human.ts', 'src/save.ts', 'src/sound.ts', 'src/beat.ts', 'src/store.ts', 'src/styles.css', 'src/motion.ts', 'src/motion-sample.ts', 'src/pin.ts',
+    'src/cutouts.ts', 'src/cutout-math.ts', 'src/cutout-atlas.ts',
+    'src/models.ts', 'src/palette.ts',
+]);
+const BARE_TEST = new Set(['test/resolve.mjs']);
+const MAIN = `// The spine (funtools init --bare): the platform seams, the safe band and the look tokens, then the game.
+// The demo round was left out on purpose; your game starts in game.ts.
+import { render } from 'preact';
+import { useEffect, useRef, useState } from 'preact/hooks';
+import './platform'; // pause when hidden, storage that never throws, first-tap fullscreen (yours to change)
+import './frame'; // the safe HUD band: --band-* and __FPX_FRAME__ (yours to change)
+import { applyLook } from './look'; // src/look.json onto :root, before the first paint
+import { go, useStore } from './store';
+
+function App() {
+  const s = useStore();
+  const stage = useRef<HTMLDivElement>(null), [failed, setFailed] = useState(false);
+  useEffect(() => {
+    const host = stage.current;
+    if (host) import('./game').then((m) => m.startGame(host)).catch((e) => { console.error('the game did not load', e); setFailed(true); });
+  }, []);
+  return (
+    <>
+      <div ref={stage} class="stage" data-fpx-play />
+      {/* The front door verify presses (data-fpx-start): make the title the game's first promise (skill funpixel-art, ui.md). */}
+      {s.screen === 'title' && <div class="title" role="dialog"><h1>{document.title}</h1><button class="primary" data-fpx-start onClick={() => go('playing')}>Play</button></div>}
+      {failed && <div class="load-failed" role="alert"><p>The game did not load.</p><button onClick={() => location.reload()}>Try again</button></div>}
+    </>
+  );
+}
+
+applyLook();
+render(<App />, document.getElementById('app')!);
+`;
+const GAME_THREE = `// Your game starts here (funtools init --bare). The engine is open and the hooks verify reads are wired;
+// the rest is yours: the rules engine-free beside it (skill funpixel-game-logic), the world built from the
+// first look's kit (skill funpixel-art), people and creatures that animate (funpixel-world-and-story).
+import * as THREE from 'three';
+import { exposeHooks } from './fpx-hooks';
+import { useRenderer } from './models';
+import { go, store } from './store';
+
+export function startGame(host: HTMLElement): void {
+  const renderer = new THREE.WebGLRenderer({ antialias: true });
+  renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
+  renderer.outputColorSpace = THREE.SRGBColorSpace;
+  host.appendChild(renderer.domElement);
+  // Generated models carry KTX2 textures: the loader picks their format from this renderer, before any
+  // model loads. Load every .glb through src/models.ts (model(name, height, placeholder)).
+  useRenderer(renderer);
+  const scene = new THREE.Scene();
+  const camera = new THREE.PerspectiveCamera(50, 1, 0.1, 800);
+  camera.position.set(0, 2.2, 6);
+  scene.add(new THREE.HemisphereLight(0xffffff, 0x444466, 1.2));
+  const size = () => {
+    const w = host.clientWidth || innerWidth, h = host.clientHeight || innerHeight;
+    renderer.setSize(w, h); camera.aspect = w / h; camera.updateProjectionMatrix();
+  };
+  addEventListener('resize', size); size();
+  // The scene graph the checks read (look --3d, boxes, life, walk).
+  Object.assign(window, { __THREEJS_SCENE__: scene, __THREEJS_RENDERER__: renderer, __THREEJS_CAMERA__: camera });
+  exposeHooks({ state: () => ({ screen: store.screen }), views: { playing: { enter: () => go('playing'), motion: true } } });
+  renderer.setAnimationLoop(() => renderer.render(scene, camera));
+}
+`;
+const GAME_PIXI = `// Your game starts here (funtools init --bare). The engine is open and the hooks verify reads are wired;
+// the rest is yours: the rules engine-free beside it (skill funpixel-game-logic), the art from the first
+// look (skill funpixel-art), people and creatures that animate (funpixel-world-and-story).
+import { Application } from 'pixi.js';
+import { exposeHooks } from './fpx-hooks';
+import { go, store } from './store';
+
+export async function startGame(host: HTMLElement): Promise<void> {
+  const app = new Application();
+  await app.init({ resizeTo: host, antialias: true, background: '#101018' });
+  host.appendChild(app.canvas);
+  // The stage the checks read (life, look).
+  Object.assign(window, { __PIXI_APP__: app });
+  exposeHooks({ state: () => ({ screen: store.screen }), views: { playing: { enter: () => go('playing'), motion: true } } });
+}
+`;
+const BARE_TITLE_CSS = `
+/* The bare title (funtools init --bare): over the stage, the name and one start control. Make it the game's. */
+.title { position: fixed; inset: 0; z-index: 10; display: grid; place-content: center; justify-items: center; gap: 18px; text-align: center; }
+.title h1 { margin: 0; font-family: var(--font-display); font-size: clamp(32px, 8vw, 56px); }
+`;
+const TODO_TEST = `// The rules as tests, named in the design before code (skill funpixel-gdd, ### Behaviour tests).
+import { test } from 'node:test';
+
+test.todo('the first rule of this game, as a test');
+`;
+const withoutModels = (game) => game
+    .replace("import { useRenderer } from './models';\n", '')
+    .replace(/  \/\/ Generated models carry KTX2[^\n]*\n[^\n]*\n  useRenderer\(renderer\);\n/, '');
+export function bareFiles(files, framework) {
+    const out = {};
+    for (const [rel, text] of Object.entries(files)) {
+        if (rel.startsWith('src/') ? BARE_SRC.has(rel) : rel.startsWith('test/') ? BARE_TEST.has(rel) : true)
+            out[rel] = text;
+    }
+    if (out['src/styles.css'])
+        out['src/styles.css'] = out['src/styles.css'].replace(/^@import '\.\/[\w-]+\.css';\n/gm, '') + BARE_TITLE_CSS;
+    out['src/main.tsx'] = MAIN;
+    out['src/game.ts'] = framework === 'pixi' ? GAME_PIXI : out['src/models.ts'] ? GAME_THREE : withoutModels(GAME_THREE);
+    out['test/rules.test.ts'] = TODO_TEST;
+    out['test/probes.ts'] = probeSkeletonFor(null, 'funtools init --bare');
+    return out;
+}
+export function demoLeftOut(files) {
+    return Object.keys(files).filter((rel) => (rel.startsWith('src/') && !BARE_SRC.has(rel)) || (rel.startsWith('test/') && !BARE_TEST.has(rel)));
+}

package/dist/init/git.js

@@ -0,0 +1,56 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+const git = (dir, args) => spawnSync('git', ['-C', dir, ...args], { encoding: 'utf8', timeout: 20_000 });
+export function gitInit(dir, name, opts = {}) {
+    const push = 'push it somewhere it survives this machine: `git remote add origin <url>`, then `git push -u origin HEAD`';
+    if (opts.skip)
+        return { state: 'skipped', says: 'no git repository (--no-git)', next: `a game only in this folder can be lost: \`git init\`, commit, then ${push}` };
+    const inside = git(dir, ['rev-parse', '--show-toplevel']);
+    if (inside.error)
+        return { state: 'no-git', says: 'git is not installed: the game has no history yet', next: 'install git, then `git init` and commit; keep the game out of temp folders' };
+    if (inside.status === 0)
+        return { state: 'inside', says: `inside the git repository at ${inside.stdout.trim()}: no new repository`, next: 'commit the new game there and push' };
+    const steps = [['init', '-q'], ['add', '-A']];
+    for (const s of steps) {
+        const r = git(dir, s);
+        if (r.status !== 0)
+            return { state: 'failed', says: `git ${s[0]} failed: ${(r.stderr || r.stdout).trim().split('\n')[0]}`, next: 'run it by hand in the game folder' };
+    }
+    const who = git(dir, ['config', 'user.email']).stdout.trim() ? [] : ['-c', 'user.name=funtools init', '-c', 'user.email=init@funtools.invalid'];
+    const c = git(dir, [...who, 'commit', '-q', '--no-verify', '-m', `funtools init: ${name}`]);
+    if (c.status !== 0)
+        return { state: 'failed', says: `git commit failed: ${(c.stderr || c.stdout).trim().split('\n')[0]}`, next: 'commit by hand in the game folder' };
+    return { state: 'committed', says: 'git repository with a first commit (funtools init)', next: `${push}; commit as you go (--no-git skips this)` };
+}
+export const PLAN_PATHS = ['design', 'funpixel.json', 'assets/assets.json', 'assets/style.json'];
+export function commitPlan(dir, message) {
+    const top = git(dir, ['rev-parse', '--show-toplevel']);
+    if (top.error)
+        return { state: 'no-git', says: 'git is not installed: the plan is not committed', next: 'install git, then commit design/' };
+    if (top.status !== 0)
+        return { state: 'skipped', says: 'the game is not in git: the plan is not committed', next: '`git init`, commit, and push it somewhere it survives this machine' };
+    const real = (p) => { try {
+        return realpathSync(p);
+    }
+    catch {
+        return p;
+    } };
+    if (real(top.stdout.trim()) !== real(dir))
+        return { state: 'inside', says: `inside the repository at ${top.stdout.trim()}: commit the plan there`, next: 'git add design && git commit' };
+    const paths = PLAN_PATHS.filter((p) => existsSync(join(dir, p)));
+    if (!paths.length)
+        return { state: 'skipped', says: 'no plan files to commit' };
+    const add = git(dir, ['add', '--', ...paths]);
+    if (add.status !== 0)
+        return { state: 'failed', says: `git add failed: ${(add.stderr || add.stdout).trim().split('\n')[0]}`, next: 'commit design/ by hand' };
+    const changed = git(dir, ['diff', '--cached', '--quiet', '--', ...paths]);
+    if (changed.status === 0)
+        return { state: 'committed', says: 'the plan as put to the owner is already committed' };
+    const who = git(dir, ['config', 'user.email']).stdout.trim() ? [] : ['-c', 'user.name=funtools', '-c', 'user.email=flow@funtools.invalid'];
+    const c = git(dir, [...who, 'commit', '-q', '--no-verify', '-m', message, '--', ...paths]);
+    if (c.status !== 0)
+        return { state: 'failed', says: `git commit failed: ${(c.stderr || c.stdout).trim().split('\n')[0]}`, next: 'commit design/ by hand' };
+    const sha = git(dir, ['rev-parse', '--short', 'HEAD']).stdout.trim();
+    return { state: 'committed', says: `the plan committed (${sha}: ${message})`, next: 'push it: `git push` (or add a remote first)' };
+}