@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/status/status.js

@@ -0,0 +1,311 @@
+import { existsSync, readdirSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { readAssetManifest, targetOf } from "../assets/manifest.js";
+import { readChapters, chapterStage } from "../gdd/chapters.js";
+import { GDD_PAGE, sectionStates, takeAgreements, writeBook } from "../gdd/book.js";
+import { designDoc } from "../gdd/doc.js";
+import { readPipeline, openNotes, sectionBody, TIER_NAME } from "../pipeline/pipeline.js";
+import { readProgress } from "../progress/progress.js";
+import { readFlow } from "../flow/flow.js";
+import { SCORES_PATH } from "../direct/round.js";
+import { laneView, readLanes, readMaking } from "../lanes/lanes.js";
+import { carried, readKeep } from "../playtest/keep.js";
+import { STORE_PLAN_RECORD } from "../store/plan.js";
+import { patchStatus, readStatusFile, STATUS_FILE, withStatusLock, writeStatusFile } from "./file.js";
+export { patchStatus, STATUS_FILE } from "./file.js";
+export const DEV_FILE = join('.funtools', 'dev.json');
+const PICTURE = /\.(png|jpe?g|webp)$/i;
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+const posix = (p) => p.split('\\').join('/');
+function ledgerByName(root) {
+    const out = new Map();
+    let text = '';
+    try {
+        text = readFileSync(join(root, 'assets', 'costs.jsonl'), 'utf8');
+    }
+    catch {
+        return out;
+    }
+    for (const line of text.split('\n')) {
+        try {
+            const l = JSON.parse(line);
+            if (l?.name)
+                out.set(l.name, l);
+        }
+        catch { }
+    }
+    return out;
+}
+function codeNames(root) {
+    let text = '';
+    const walk = (d, depth) => {
+        let names = [];
+        try {
+            names = readdirSync(d);
+        }
+        catch {
+            return;
+        }
+        for (const n of names) {
+            if (n === 'node_modules' || n.startsWith('.'))
+                continue;
+            const p = join(d, n);
+            let st;
+            try {
+                st = statSync(p);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                if (depth < 5)
+                    walk(p, depth + 1);
+            }
+            else if (/\.(ts|tsx|js|jsx|json|html|css)$/.test(n) && st.size < 2_000_000) {
+                try {
+                    text += readFileSync(p, 'utf8');
+                }
+                catch { }
+            }
+        }
+    };
+    walk(join(root, 'src'), 0);
+    for (const f of ['index.html', 'public/manifest.json']) {
+        try {
+            text += readFileSync(join(root, f), 'utf8');
+        }
+        catch { }
+    }
+    return (file) => { const rel = posix(file).replace(/^public\//, ''); return text.includes(rel) || text.includes(basename(file)); };
+}
+export function assetStages(root, items = readAssetManifest(root)) {
+    const inCode = codeNames(root);
+    const byName = new Map(items.map((it) => [it.name, it]));
+    const ledger = ledgerByName(root);
+    return items.map((it) => {
+        const file = targetOf(it);
+        const made = existsSync(join(root, file));
+        const stages = [];
+        if (it.kind === 'model3d' || it.kind === 'rig') {
+            const from = it.from ? byName.get(it.from) : undefined;
+            const model = it.kind === 'rig' && from?.kind === 'model3d' ? from : it;
+            const modelFile = targetOf(model);
+            const src = model.from ? byName.get(model.from) : undefined;
+            const castSheet = (id) => { if (!id)
+                return undefined; try {
+                const n = readdirSync(join(root, 'design', 'cast', id)).filter((f) => PICTURE.test(f)).sort()[0];
+                return n ? join('design', 'cast', id, n) : undefined;
+            }
+            catch {
+                return undefined;
+            } };
+            const concept = [...(it.references ?? []), ...(model.references ?? [])].find((r) => existsSync(join(root, r)))
+                ?? castSheet(model.cast ?? it.cast)
+                ?? (src && src.kind !== 'model3d' && existsSync(join(root, targetOf(src))) ? targetOf(src) : undefined);
+            stages.push({ stage: 'concept', done: !!concept, ...(concept ? { file: posix(concept) } : {}) });
+            stages.push({ stage: 'model', done: existsSync(join(root, modelFile)), file: modelFile });
+            if (it.kind === 'rig') {
+                const clips = [...(it.clips ?? []), ...(it.motions ?? []).map((m) => String(m.name ?? m.motion ?? 'motion')), ...(it.retarget?.clips ?? [])];
+                stages.push({ stage: 'rig', done: made, file });
+                stages.push({ stage: 'animate', done: made && clips.length > 0, ...(clips.length ? { says: clips.join(', ') } : { says: 'no clips planned' }) });
+            }
+        }
+        else {
+            stages.push({ stage: 'made', done: made, file });
+        }
+        const reference = posix(file).startsWith('design/');
+        if (!reference)
+            stages.push({ stage: 'in the game', done: made && inCode(file) });
+        const l = ledger.get(it.name);
+        const fromLedger = l && l.outcome === 'made'
+            ? { made_by: l.tool, credits: l.credits, candidates: (l.raw ?? []).filter((r) => existsSync(join(root, r))), chosen: l.chosen ?? null }
+            : {};
+        return { name: it.name, kind: it.kind, file, role: reference ? 'reference' : 'game', stages, ...fromLedger };
+    });
+}
+export function previewOf(root) {
+    const d = readJson(join(root, DEV_FILE));
+    if (!d?.url || typeof d.pid !== 'number')
+        return null;
+    try {
+        process.kill(d.pid, 0);
+        return { url: String(d.url) };
+    }
+    catch {
+        return null;
+    }
+}
+export function latestBuild(root) {
+    const all = [];
+    for (const rel of [join('.funtools', 'capture'), join('design', 'shots')]) {
+        let names = [];
+        try {
+            names = readdirSync(join(root, rel));
+        }
+        catch {
+            continue;
+        }
+        for (const n of names) {
+            if (!PICTURE.test(n) || n.startsWith('note-'))
+                continue;
+            let t = 0;
+            try {
+                t = statSync(join(root, rel, n)).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            all.push({ p: posix(join(rel, n)), n: n.toLowerCase(), t });
+        }
+    }
+    if (!all.length)
+        return null;
+    const newest = Math.max(...all.map((x) => x.t));
+    const rank = (n) => (/^playing/.test(n) ? (/desktop/.test(n) ? 0 : 1) : /^title/.test(n) ? 2 : /^(lost|won|over|paused)/.test(n) ? 4 : 3);
+    const best = all.filter((x) => newest - x.t <= 180_000).sort((a, b) => rank(a.n) - rank(b.n) || b.t - a.t)[0];
+    return { capture: best.p, at: new Date(best.t).toISOString() };
+}
+function lanesOf(root, now) {
+    const f = readLanes(root);
+    if (!f?.lanes.length)
+        return [];
+    return f.lanes.map((l) => {
+        const v = laneView(root, f, l, l.gate?.sha ?? null, now.getTime());
+        const last = [...readMaking(root, l.id)].reverse().find((e) => e.kind === 'checkpoint' || e.kind === 'final');
+        const shot = last?.evidence && PICTURE.test(last.evidence) ? posix(last.evidence) : null;
+        const preview = previewOf(join(root, l.worktree))?.url ?? null;
+        return { id: l.id, title: l.title, kind: l.kind, stage: l.stage, status: v.status, says: v.says, next: v.next, minutes: v.minutes, spent_usd: v.spent, last: last?.line ?? null, shot, preview };
+    });
+}
+function targetFrames(root) {
+    const dir = join(root, 'design', 'first-look');
+    let names = [];
+    try {
+        names = readdirSync(dir).filter((n) => PICTURE.test(n));
+    }
+    catch {
+        return [];
+    }
+    const rank = (n) => (/key/i.test(n) ? 0 : /^target-/i.test(n) ? 1 : /^ref-/i.test(n) ? 3 : 2);
+    return names.sort((a, b) => rank(a) - rank(b) || a.localeCompare(b)).map((n) => posix(join('design', 'first-look', n)));
+}
+export function stageLine(stages, now) {
+    return stages.map((s) => ({
+        id: s.id, name: s.title,
+        state: s.id === now ? 'now' : s.status === 'done' ? 'done' : s.status === 'skipped' ? 'skipped' : 'next',
+        done_at: s.done_at ?? null,
+    }));
+}
+export function buildStatus(root, v, now = new Date()) {
+    const fp = readJson(join(root, 'funpixel.json')) ?? {};
+    const doc = designDoc(root);
+    const tier = fp.production?.tier;
+    const flow = readFlow(root);
+    const progress = readProgress(root);
+    const cards = new Map(progress.cards.map((c) => [c.n, c]));
+    const scores = readJson(join(root, SCORES_PATH));
+    const pipe = readPipeline(root);
+    const verdicts = pipe?.verdicts ?? [];
+    const whereWeAre = doc ? (sectionBody(doc.text, 'Where we are') ?? '').trim() : '';
+    return {
+        version: 1,
+        at: now.toISOString(),
+        game: { title: (doc && /^#\s+(.+)$/m.exec(doc.text)?.[1].trim()) || fp.name || basename(root), size: tier ? TIER_NAME[tier] ?? tier : null, framework: fp.framework ?? fp.metadata?.framework ?? null, idea: flow?.idea ?? null },
+        latest: latestBuild(root),
+        where: {
+            phase: v.phase, stage: v.stage, round: v.round?.n ?? null, waiting_on: v.waitingOn, step: v.step, why: v.why, ask: v.ask ?? null,
+            unrun: (v.evidence?.unrun ?? []).map((g) => ({ check: g.gate.kind, says: g.says, run: g.run })),
+            stages: stageLine(pipe?.stages ?? [], v.stage?.id ?? null),
+        },
+        board: readStatusFile(root)?.board ?? null,
+        plan: { file: doc ? posix(doc.rel) : null, page: doc ? posix(GDD_PAGE) : null, agreed: v.agreement.agreed, says: v.agreement.says, where_we_are: whereWeAre || null, targets: targetFrames(root), sections: sectionStates(root) ?? [] },
+        rounds: (flow?.rounds ?? []).map((r) => {
+            const c = r.card ? cards.get(r.card) : undefined;
+            return { n: r.n, stage: r.stage, opened_at: r.opened_at, closed_at: r.closed_at ?? null, met: r.met ?? null, ended: r.ended ?? null, accuracy: r.accuracy ?? null, card: c ? { line: c.line, shot: c.shot?.path ?? null, next: c.next ?? null } : null };
+        }),
+        scores: scores?.moments ? { at: scores.at ?? null, bar: scores.bar ?? 75, moments: scores.moments.filter((m) => typeof m?.score === 'number').map((m) => ({ moment: m.moment, view: m.view ?? null, target: m.target ?? null, capture: m.capture ?? null, score: m.score })) } : null,
+        assets: (() => { try {
+            return assetStages(root);
+        }
+        catch {
+            return [];
+        } })(),
+        chapters: readChapters(root).map((c) => ({ id: c.id, name: c.name, targets: c.targets.map(posix), accepted: [...verdicts].reverse().find((x) => x.stage === chapterStage(c.id))?.says === 'accept' })),
+        keep: carried(readKeep(root)).map((k) => ({ id: k.id, text: k.text, status: k.status, since: k.since, judged: k.judged ?? null, evidence: k.evidence ?? null, ...(k.lost_since ? { lost_since: k.lost_since } : {}) })),
+        look: { every: v.look.every, state: v.look.state, why: v.look.why, next_round: v.look.next, last: v.look.last ? { round: v.look.last.round, filed: v.look.last.filed, ship: v.look.last.ship ?? null, why: v.look.last.why ?? null, brief: posix(v.look.last.brief), defects: v.look.last.defects } : null },
+        notes: pipe ? openNotes(pipe).map((n) => ({ id: n.id, text: n.text, stage: n.stage ?? null, by: n.by, screenshot: n.screenshot ?? null })) : [],
+        lanes: lanesOf(root, now),
+        preview: previewOf(root),
+        preview_start: existsSync(join(root, 'package.json')) ? PREVIEW_START : null,
+        store: storeOf(root),
+    };
+}
+export const ACTIVITY_WORDS = {
+    flow: 'reading where the game is', flow_start: 'making the game', flow_ask: 'putting the plan to you', flow_agree: 'locking the plan',
+    flow_round: 'closing the round', flow_look: 'looking at the whole game', check: 'building and checking the game', verify: 'playing the game through its checks', test: 'running the rules tests',
+    sim: 'the bots are playing the rules', capture: 'capturing the game at its moments', compare: 'setting the game beside its targets',
+    score: 'scoring the game against its targets', assets_script: 'turning the plan into its asset list', assets_gen: 'making the assets',
+    assets_process: 'fitting the assets into the game', gen: 'making an asset', note_add: 'taking your note', note_verdict: 'recording your verdict',
+    progress_card: 'recording the round', reel: 'filming a clip of real play', compose_video: 'rendering the video', ad_variations: 'rendering the ad cuts', run: 'working',
+};
+export function setPreview(root, url) {
+    patchStatus(root, (s) => { s.preview = { url }; });
+}
+export function clearPreview(root, pid) {
+    const devFile = join(root, DEV_FILE);
+    const d = readJson(devFile);
+    if (!d || d.pid !== pid)
+        return;
+    try {
+        rmSync(devFile, { force: true });
+    }
+    catch { }
+    patchStatus(root, (s) => { if (s.preview && s.preview.url === d.url)
+        s.preview = null; });
+}
+export const PREVIEW_START = ['funtools', 'dev'];
+export function setActivity(root, activity) {
+    patchStatus(root, (s) => { if (activity)
+        s.activity = activity;
+    else
+        delete s.activity; });
+}
+export function storeOf(root) {
+    const r = readJson(join(root, STORE_PLAN_RECORD));
+    if (!r?.stores || typeof r.stores !== 'object')
+        return null;
+    return {
+        at: r.at ?? null,
+        stores: Object.fromEntries(Object.entries(r.stores).map(([store, p]) => [store, {
+                hash: p?.hash ?? null, next: p?.next ?? null,
+                steps: (Array.isArray(p?.steps) ? p.steps : []).map((s) => ({ n: s.n, row: s.row, who: s.who, state: s.state, needs: (Array.isArray(s.needs) ? s.needs : []).filter((n) => typeof n === 'string' && !/\(the setup step\)$/.test(n)).slice(0, 3) })),
+            }])),
+    };
+}
+export function patchStatusStore(root) {
+    patchStatus(root, (s) => { s.store = storeOf(root); });
+}
+export function writeStatus(root, v, now = new Date()) {
+    try {
+        if (!existsSync(join(root, 'design')))
+            return null;
+        try {
+            takeAgreements(root, now);
+        }
+        catch { }
+        withStatusLock(root, () => writeStatusFile(root, buildStatus(root, v, now)));
+        try {
+            writeBook(root);
+        }
+        catch { }
+        return STATUS_FILE;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/store/answers.js

@@ -0,0 +1,47 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const ANSWERS_PATH = join('store', 'answers.json');
+export const ANSWERS_VERSION = 1;
+export const isTodo = (v) => typeof v === 'string' && v.startsWith('TODO');
+export const STORES = ['play', 'ios', 'steam'];
+export const STORE_NAME = { play: 'Google Play', ios: 'App Store', steam: 'Steam' };
+export const IOS_DEVICES = ['iphone-6.9', 'iphone-6.5', 'iphone-6.3', 'ipad-13'];
+export const PLAY_KEY_ENV = 'PLAY_SA_JSON';
+export function readAnswers(root) {
+    const p = join(root, ANSWERS_PATH);
+    if (!existsSync(p))
+        return { error: `no ${ANSWERS_PATH}` };
+    try {
+        const a = JSON.parse(readFileSync(p, 'utf8'));
+        if (!a || typeof a !== 'object' || Array.isArray(a))
+            return { error: `${ANSWERS_PATH} is not a JSON object` };
+        return { answers: a };
+    }
+    catch (e) {
+        return { error: `${ANSWERS_PATH} is not JSON: ${e instanceof Error ? e.message : String(e)}` };
+    }
+}
+export const storesOf = (a, only) => STORES.filter((s) => (only ? s === only : a[s] !== undefined));
+export function todos(v, at = '') {
+    if (isTodo(v))
+        return [at || '(root)'];
+    if (Array.isArray(v))
+        return v.flatMap((x, i) => todos(x, `${at}[${i}]`));
+    if (v && typeof v === 'object')
+        return Object.entries(v).filter(([k]) => k !== 'sources').flatMap(([k, x]) => todos(x, at ? `${at}.${k}` : k));
+    return [];
+}
+export function secretsIn(text) {
+    const found = [];
+    if (/-----BEGIN [A-Z ]*PRIVATE KEY-----/.test(text))
+        found.push('a private key block');
+    if (/"private_key"\s*:/.test(text))
+        found.push('a service account\'s private_key');
+    if (/\bfp_live_[A-Za-z0-9]{8,}/.test(text))
+        found.push('a Funpixel API key');
+    if (/\bAIza[0-9A-Za-z_-]{30,}/.test(text))
+        found.push('a Google API key');
+    if (/"(password|secret|token|apiKey|api_key)"\s*:\s*"[^"T]/.test(text))
+        found.push('a password, secret or token field');
+    return found;
+}

package/dist/store/doctor.js

@@ -0,0 +1,120 @@
+import { spawnSync } from 'node:child_process';
+import { accessSync, constants, existsSync, readFileSync, statSync } from 'node:fs';
+import { delimiter, isAbsolute, join, relative, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { PLAY_KEY_ENV } from "./answers.js";
+export const ASC_PINNED = '5.13.0';
+export const ASC_ENV = { ASC_READ_ONLY: '1', DO_NOT_TRACK: '1', ASC_TELEMETRY_DISABLED: '1' };
+const realRun = (program, args, env) => {
+    const r = spawnSync(program, args, { env, encoding: 'utf8', timeout: 10_000, stdio: ['ignore', 'pipe', 'ignore'] });
+    return { status: r.status, stdout: r.stdout ?? '' };
+};
+export function onPath(program, path = process.env.PATH ?? '') {
+    for (const dir of path.split(delimiter).filter(Boolean)) {
+        const p = join(dir, program);
+        try {
+            if (statSync(p).isFile()) {
+                accessSync(p, constants.X_OK);
+                return p;
+            }
+        }
+        catch { }
+    }
+    return null;
+}
+export function envValue(file, name) {
+    if (!existsSync(file))
+        return null;
+    for (const line of readFileSync(file, 'utf8').split(/\r?\n/)) {
+        const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+        if (!m || m[1] !== name)
+            continue;
+        const v = m[2].trim().replace(/^(['"])(.*)\1$/, '$2');
+        return v.startsWith('~/') ? join(homedir(), v.slice(2)) : v;
+    }
+    return null;
+}
+function ios(o, out) {
+    const line = (check, state, says, next) => out.push({ store: 'ios', check, state, says, ...(next ? { next } : {}) });
+    if (o.platform !== 'darwin')
+        line('macOS', 'warn', `this is ${o.platform}`, 'an iOS build needs a Mac with Xcode; asc itself needs macOS 13+ for some commands');
+    const asc = onPath('asc', o.env.PATH);
+    if (!asc)
+        line('asc (App Store Connect CLI)', 'fail', 'not installed', `brew install asc  (then check it is ${ASC_PINNED}: the kit is written against that version)`);
+    else {
+        const r = o.run('asc', ['version'], { ...o.env, ...ASC_ENV });
+        const v = /(\d+\.\d+\.\d+)/.exec(r.stdout)?.[1];
+        if (r.status !== 0 || !v)
+            line('asc (App Store Connect CLI)', 'warn', `${asc}: \`asc version\` did not answer`, 'reinstall: brew reinstall asc');
+        else if (v !== ASC_PINNED)
+            line('asc (App Store Connect CLI)', 'warn', `${v} at ${asc}; the kit is written against ${ASC_PINNED}`, `it moves fast: read its changelog for anything the plan's commands use, or brew install asc@${ASC_PINNED} if a formula for it exists`);
+        else
+            line('asc (App Store Connect CLI)', 'pass', `${v} at ${asc}`);
+    }
+    const quiet = o.env.DO_NOT_TRACK === '1' || o.env.ASC_TELEMETRY_DISABLED === '1';
+    line('asc telemetry off', quiet ? 'pass' : 'warn', quiet ? 'DO_NOT_TRACK or ASC_TELEMETRY_DISABLED is set' : 'asc sends telemetry by default; neither DO_NOT_TRACK nor ASC_TELEMETRY_DISABLED is set in this shell', quiet ? undefined : 'add `export DO_NOT_TRACK=1` to your shell profile (funtools sets it on every asc call it makes)');
+    line('asc sign-in', 'warn', 'not checked: doctor never signs in or reads the Keychain', 'once, yourself: asc auth login --key-id … --issuer-id … --private-key <.p8 outside the repo>; then asc auth status --validate');
+    if (o.platform === 'darwin') {
+        const x = o.run('xcode-select', ['-p'], o.env);
+        line('Xcode', x.status === 0 ? 'pass' : 'fail', x.status === 0 ? x.stdout.trim() : 'no developer folder selected', x.status === 0 ? undefined : 'install Xcode from the App Store, then sudo xcode-select -s /Applications/Xcode.app');
+    }
+}
+function play(o, out) {
+    const line = (check, state, says, next) => out.push({ store: 'play', check, state, says, ...(next ? { next } : {}) });
+    const name = o.answers?.credentials?.playServiceAccountEnv ?? PLAY_KEY_ENV;
+    const dotenv = join(o.root, '.env');
+    const fromFile = envValue(dotenv, name);
+    const raw = fromFile ?? o.env[name] ?? null;
+    const setup = 'one-time, the owner: a Cloud project with the Android Publisher API on, a service account, its JSON key saved OUTSIDE the game folder, invited in Play Console › Users and permissions (production and finance off)';
+    if (!raw) {
+        line('Play service account key', 'fail', `${name} is not set in .env or the environment`, `${setup}; then add ${name}=/path/to/key.json to the game's .env`);
+        return;
+    }
+    const where = fromFile ? '.env' : 'the environment';
+    if (/^\s*\{|private_key|BEGIN [A-Z ]*PRIVATE KEY/.test(raw) || raw.length > 1024) {
+        line('Play service account key', 'fail', `${name} (${where}) holds a key, not a path to one (its value is not shown)`, `save the JSON key as a file outside the game folder and set ${name}=/path/to/key.json`);
+        return;
+    }
+    const keyPath = isAbsolute(raw) ? raw : resolve(o.root, raw);
+    let isFile = false;
+    try {
+        isFile = statSync(keyPath).isFile();
+    }
+    catch { }
+    if (!isFile) {
+        line('Play service account key', 'fail', `${name} (${where}) points at ${keyPath}, which does not exist`, 'fix the path in .env; the key file itself stays where you saved it');
+        return;
+    }
+    const rel = relative(resolve(o.root), keyPath);
+    if (!rel.startsWith('..') && !isAbsolute(rel)) {
+        line('Play service account key', 'fail', `${name} points inside the game folder (${rel})`, 'move the key outside the game folder and repository, and update the path in .env');
+        return;
+    }
+    line('Play service account key', 'pass', `${name} (${where}) → a file exists at ${keyPath} (not opened)`);
+    line('Play API access', 'warn', 'not checked: doctor calls no network API', 'store plan reads only local files; the push (not built yet) will open and delete an edit to prove the key');
+    if (existsSync(dotenv) && !gitIgnored(o.root, '.env', o.run))
+        line('.env ignored by git', 'warn', '.env may not be ignored', 'add .env to .gitignore');
+}
+function gitIgnored(root, file, run) {
+    const r = run('git', ['-C', root, 'check-ignore', '-q', file], process.env);
+    return r.status === 0 || r.status === 128;
+}
+function steam(o, out) {
+    const line = (check, state, says, next) => out.push({ store: 'steam', check, state, says, ...(next ? { next } : {}) });
+    const cmd = onPath('steamcmd', o.env.PATH);
+    line('steamcmd', cmd ? 'pass' : 'fail', cmd ? `on PATH at ${cmd} (not run: it updates itself when started)` : 'not installed', cmd ? undefined : 'brew install --cask steamcmd');
+    line('Steam build account', 'warn', 'not checked: doctor never signs in', 'once, the owner: a dedicated build account (Edit App Metadata + Publish only), signed into steamcmd once with Steam Guard');
+    const id = o.answers?.steam?.appId;
+    line('Steam app id', typeof id === 'string' && /^\d+$/.test(id) ? 'pass' : 'warn', typeof id === 'string' && /^\d+$/.test(id) ? id : 'not in store/answers.json', 'Steamworks gives one when the app is created (the Steam Direct fee is the owner\'s)');
+}
+export function storeDoctor(opts) {
+    const o = { ...opts, env: opts.env ?? process.env, run: opts.run ?? realRun, platform: opts.platform ?? process.platform };
+    const out = [];
+    if (o.stores.includes('play'))
+        play(o, out);
+    if (o.stores.includes('ios'))
+        ios(o, out);
+    if (o.stores.includes('steam'))
+        steam(o, out);
+    return out;
+}

package/dist/store/images.js

@@ -0,0 +1,65 @@
+import { closeSync, openSync, readSync } from 'node:fs';
+function head(path, bytes = 65536) {
+    const fd = openSync(path, 'r');
+    try {
+        const buf = Buffer.alloc(bytes);
+        const n = readSync(fd, buf, 0, bytes, 0);
+        return buf.subarray(0, n);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function pngInfo(b) {
+    if (b.length < 33 || b.readUInt32BE(0) !== 0x89504e47 || b.toString('ascii', 12, 16) !== 'IHDR')
+        return null;
+    const width = b.readUInt32BE(16), height = b.readUInt32BE(20), colourType = b[25];
+    let alpha = colourType === 4 || colourType === 6;
+    for (let at = 33; !alpha && at + 8 <= b.length;) {
+        const len = b.readUInt32BE(at), type = b.toString('ascii', at + 4, at + 8);
+        if (type === 'tRNS')
+            alpha = true;
+        if (type === 'IDAT' || type === 'IEND')
+            break;
+        at += 12 + len;
+    }
+    return { format: 'png', width, height, alpha };
+}
+export function jpegInfo(b) {
+    if (b.length < 4 || b[0] !== 0xff || b[1] !== 0xd8)
+        return null;
+    for (let at = 2; at + 9 < b.length;) {
+        if (b[at] !== 0xff) {
+            at++;
+            continue;
+        }
+        const marker = b[at + 1];
+        if (marker === 0xff) {
+            at++;
+            continue;
+        }
+        if (marker === 0xd8 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+            at += 2;
+            continue;
+        }
+        const len = b.readUInt16BE(at + 2);
+        if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+            return { format: 'jpeg', height: b.readUInt16BE(at + 5), width: b.readUInt16BE(at + 7), alpha: false };
+        }
+        if (marker === 0xda)
+            return null;
+        at += 2 + len;
+    }
+    return null;
+}
+export function imageInfo(path) {
+    let b;
+    try {
+        b = head(path);
+    }
+    catch (e) {
+        return { error: e.code === 'ENOENT' ? 'no such file' : String(e) };
+    }
+    return pngInfo(b) ?? jpegInfo(b) ?? { error: 'not a PNG or JPEG' };
+}
+export const aspect = (i) => Math.max(i.width, i.height) / Math.max(1, Math.min(i.width, i.height));

package/dist/store/init.js

@@ -0,0 +1,101 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ANSWERS_VERSION } from "./answers.js";
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+export function gddPitch(root) {
+    for (const rel of ['design/GDD.md', 'design/README.md']) {
+        const p = join(root, rel);
+        if (!existsSync(p))
+            continue;
+        const m = /^\*\*Pitch:\*\*\s*(.+)$/m.exec(readFileSync(p, 'utf8'));
+        const pitch = m?.[1].trim();
+        if (pitch && !/^<.*>$/.test(pitch))
+            return { pitch, from: `${rel} **Pitch:**` };
+    }
+    return null;
+}
+export function sdkHints(root) {
+    const pkg = readJson(join(root, 'package.json'));
+    const deps = Object.keys({ ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) });
+    const hinted = deps.filter((d) => /firebase|analytics|crashlytics|sentry|bugsnag|amplitude|mixpanel|posthog|admob|applovin|unity-ads|ironsource|gameanalytics|revenuecat|capacitor/i.test(d));
+    const manifest = readJson(join(root, 'Packages', 'manifest.json'));
+    if (manifest?.dependencies)
+        hinted.push(...Object.keys(manifest.dependencies).filter((d) => /firebase|analytics|crashlytics|ads|purchasing/i.test(d)));
+    if (existsSync(join(root, 'Assets', 'Firebase')))
+        hinted.push('Assets/Firebase');
+    return [...new Set(hinted)].sort();
+}
+const todo = (what) => `TODO: ${what}`;
+export function starterAnswers(root, stores = ['play', 'ios']) {
+    const manifest = readJson(join(root, 'funpixel.json')) ?? {};
+    const name = typeof manifest.name === 'string' && manifest.name.trim() ? manifest.name.trim() : null;
+    const pitch = gddPitch(root);
+    const hints = sdkHints(root);
+    const sources = {};
+    const fromName = (key) => { if (!name)
+        return todo('the game\'s name'); sources[key] = 'funpixel.json name'; return name; };
+    const fromPitch = (key, what) => { if (!pitch)
+        return todo(what); sources[key] = pitch.from; return pitch.pitch; };
+    const shots = readdirSafe(join(root, 'store', 'art'));
+    const a = {
+        version: ANSWERS_VERSION,
+        game: name ?? todo('the game\'s name'),
+        contact: { email: todo('a support email people can write to'), website: todo('the game\'s https website'), privacyUrl: todo('the privacy policy\'s public https address') },
+        sdks: todo(`every SDK that ships, from: ${'firebase-analytics, crashlytics, firebase-performance'}; [] when none${hints.length ? ` (the game's packages include: ${hints.join(', ')})` : ''}`),
+        rating: {
+            violence: todo('none, cartoon, fantasy or realistic'), blood: todo('true or false'), fear: todo('true or false'), sexualContent: todo('true or false'),
+            profanity: todo('true or false'), drugsAlcoholTobacco: todo('true or false'), gambling: todo('none, simulated or real'),
+            userInteraction: todo('can players talk or share with each other? true or false'), sharesLocation: todo('true or false'), unrestrictedWeb: todo('true or false'),
+        },
+        audience: { minAge: todo('the youngest age it is for (13 keeps it out of the children\'s programmes)'), ads: todo('does it show ads? true or false'), aiGeneratedContent: todo('does AI-generated content ship in the game? true or false') },
+        products: todo('each purchase as { id, type, price: "4.99 USD", name }, the ids the code uses; [] when none'),
+        countries: todo('"all", or ISO country codes'),
+        credentials: { playServiceAccountEnv: 'PLAY_SA_JSON' },
+        play: {
+            packageName: todo('the owner decides it, e.g. com.studio.game: permanent once the app exists'),
+            listing: { title: fromName('play.listing.title'), short: fromPitch('play.listing.short', 'up to 80 characters'), full: todo('up to 4,000 characters') },
+            category: todo('a GAME_ category, e.g. GAME_PUZZLE'),
+            testersGroup: todo('the testers Google Group\'s address'),
+            build: todo('the AAB\'s path in this folder'),
+            art: { icon: todo('512×512 PNG'), featureGraphic: todo('1024×500'), screenshots: { phone: todo('4–8 real-play captures, at most 2:1') } },
+        },
+        ios: {
+            bundleId: todo('the owner decides it, e.g. com.studio.game: permanent once the app exists'),
+            listing: { name: fromName('ios.listing.name'), subtitle: todo('up to 30 characters'), keywords: todo('up to 100 characters, comma-separated, no spaces'), description: todo('up to 4,000 characters') },
+            category: todo('GAMES and a subcategory, e.g. GAMES_PUZZLE'),
+            ipad: todo('does it run on iPad? true or false'),
+            build: todo('the IPA\'s path in this folder'),
+            reviewNotes: todo('how a reviewer reaches everything, paid content included'),
+            art: { icon: todo('1024×1024, no alpha'), screenshots: todo('{ "iphone-6.9": [paths], "ipad-13": [paths] } from real play') },
+        },
+        steam: {
+            appId: todo('Steamworks gives it when the app is created'),
+            listing: { name: fromName('steam.listing.name'), short: fromPitch('steam.listing.short', 'the short description'), about: todo('the About This Game text') },
+            tags: todo('Steam tags'),
+            art: { screenshots: todo('5 or more real-play 16:9 captures, 1920×1080 or larger') },
+        },
+        sources,
+    };
+    for (const s of ['play', 'ios', 'steam'])
+        if (!stores.includes(s))
+            delete a[s];
+    for (const k of Object.keys(sources))
+        if (/^(play|ios|steam)\./.test(k) && !stores.includes(k.split('.')[0]))
+            delete sources[k];
+    if (shots.length)
+        sources['store/art'] = `found ${shots.length} file${shots.length === 1 ? '' : 's'} in store/art/ — name them under each store's art`;
+    return a;
+}
+function readdirSafe(d) {
+    try {
+        return readdirSync(d).filter((f) => /\.(png|jpe?g)$/i.test(f));
+    }
+    catch {
+        return [];
+    }
+}