@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/store/lint.js

@@ -0,0 +1,392 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { aspect, imageInfo } from "./images.js";
+import { agreement, derivePrivacy, sdkId, SDKS } from "./sdks.js";
+import { IOS_DEVICES, isTodo, storesOf, STORE_NAME, todos } from "./answers.js";
+export const RULES = {
+    play: {
+        read: 'google-play.md (Google Play Console Help, read 8 Oct 2026)',
+        title: 30, short: 80, full: 4000,
+        icon: { width: 512, height: 512 },
+        featureGraphic: { width: 1024, height: 500 },
+        screenshots: { min: 2, want: 4, max: 8, maxAspect: 2 },
+    },
+    ios: {
+        read: 'app-store.md (App Store Connect Help, screenshot specifications, read 8 Oct 2026)',
+        name: 30, subtitle: 30, keywords: 100, promo: 170, description: 4000,
+        icon: { width: 1024, height: 1024 },
+        screenshots: { min: 1, max: 10 },
+        sizes: {
+            'iphone-6.9': [[1320, 2868], [1290, 2796], [1260, 2736]],
+            'iphone-6.5': [[1284, 2778], [1242, 2688]],
+            'iphone-6.3': [[1206, 2622], [1179, 2556]],
+            'ipad-13': [[2064, 2752], [2048, 2732]],
+        },
+    },
+    steam: {
+        read: 'steam.md (Steamworks documentation, read 8 Oct 2026)',
+        screenshots: { min: 5, width: 1920, height: 1080 },
+    },
+};
+const OTHER_STORES = {
+    play: /\b(app store|apple|iphone|ipad|ios|testflight|steam)\b/i,
+    ios: /\b(google play|play store|android|steam)\b/i,
+    steam: /\b(app store|google play|play store|iphone|android|apple id)\b/i,
+};
+const NO_DATA = /\b(no (analytics|tracking|data collect(ed|ion))|(we )?(do not|don't|never) (collect|track)|collects? no (personal )?data|data not collected)\b/i;
+const PRICE_WORDS = /\bfree\b|[$€£¥]\s?\d|\d+([.,]\d\d)?\s?(usd|eur|gbp)\b|\bon sale\b|\bdiscount\b/i;
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const PRODUCT_ID = /^[a-z0-9][a-z0-9._]*$/;
+const PRICE = /^\d+(\.\d{1,2})? [A-Z]{3}$/;
+const chars = (s) => [...s].length;
+function add(c, store, check, state, says, next) {
+    c.out.push({ store, check, state, says, ...(next ? { next } : {}) });
+}
+function inGame(root, p) {
+    const full = resolve(root, p);
+    const rel = relative(root, full);
+    if (isAbsolute(p) || rel.startsWith('..'))
+        return { error: `${p} is outside the game folder` };
+    return full;
+}
+function picture(c, store, check, path) {
+    if (isTodo(path) || path === undefined) {
+        add(c, store, check, 'fail', 'unanswered', `make it and name its path in store/answers.json`);
+        return null;
+    }
+    if (typeof path !== 'string') {
+        add(c, store, check, 'fail', 'not a path');
+        return null;
+    }
+    const full = inGame(c.root, path);
+    if (typeof full !== 'string') {
+        add(c, store, check, 'fail', full.error, 'keep store art in the game folder, e.g. store/art/');
+        return null;
+    }
+    const info = imageInfo(full);
+    if ('error' in info) {
+        add(c, store, check, 'fail', `${path}: ${info.error}`);
+        return null;
+    }
+    return info;
+}
+function text(c, store, check, v, max, opts = {}) {
+    if (isTodo(v) || v === undefined) {
+        add(c, store, check, 'fail', 'unanswered', 'write it in store/answers.json');
+        return null;
+    }
+    if (typeof v !== 'string' || !v.trim()) {
+        add(c, store, check, 'fail', 'empty');
+        return null;
+    }
+    const n = chars(v);
+    if (max !== null && n > max) {
+        add(c, store, check, 'fail', `${n} characters, the limit is ${max}`, `cut ${n - max}`);
+        return v;
+    }
+    const other = OTHER_STORES[store].exec(v);
+    if (other) {
+        add(c, store, check, 'fail', `names another store or platform: "${other[0]}"`, `${STORE_NAME[store]} rejects other platforms' names in its listing`);
+        return v;
+    }
+    if (opts.free) {
+        const p = PRICE_WORDS.exec(v);
+        if (p) {
+            add(c, store, check, 'fail', `a price or "free": "${p[0]}"`, 'the price is set in the console, never written into the listing');
+            return v;
+        }
+    }
+    add(c, store, check, 'pass', max !== null ? `${n}/${max}` : 'set');
+    return v;
+}
+function shared(c, stores) {
+    const { a } = c;
+    const email = a.contact?.email;
+    if (isTodo(email) || !email)
+        add(c, 'all', 'contact email', 'fail', 'unanswered', 'a support address people can write to');
+    else if (!EMAIL.test(email))
+        add(c, 'all', 'contact email', 'fail', `not an email address: ${email}`);
+    else
+        add(c, 'all', 'contact email', 'pass', email);
+    const web = a.contact?.website;
+    if (isTodo(web) || !web)
+        add(c, 'all', 'contact website', 'warn', 'unanswered', 'Play shows it on the listing; the App Store asks for a support URL');
+    else if (!/^https:\/\//.test(web))
+        add(c, 'all', 'contact website', 'fail', `not an https address: ${web}`);
+    else
+        add(c, 'all', 'contact website', 'pass', web);
+    const priv = a.contact?.privacyUrl;
+    if (isTodo(priv) || !priv)
+        add(c, 'all', 'privacy URL', 'fail', 'unanswered', 'both stores require a privacy policy at a public https address (and a Settings row in the game that opens it)');
+    else if (!/^https:\/\/[^\s/]+\.[^\s]+/.test(priv))
+        add(c, 'all', 'privacy URL', 'fail', `not a public https address: ${priv}`);
+    else
+        add(c, 'all', 'privacy URL', 'pass', priv);
+    const sdks = a.sdks;
+    if (isTodo(sdks) || !Array.isArray(sdks)) {
+        add(c, 'all', 'SDK list', 'fail', 'unanswered: the privacy answers cannot be derived', 'list every SDK that ships (store/answers.json "sdks"; [] when none)');
+    }
+    else {
+        const d = derivePrivacy(sdks);
+        if (d.unknown.length)
+            add(c, 'all', 'SDK list', 'fail', `not on funtools' list: ${d.unknown.join(', ')} — its answers cannot be derived`, `known: ${Object.keys(SDKS).join(', ')}; declare an unknown SDK from its maker's disclosure page by hand`);
+        else
+            add(c, 'all', 'SDK list', 'pass', sdks.length ? sdks.map(sdkId).join(', ') : 'none');
+        const { onlyPlay, onlyIos } = agreement(d);
+        if (onlyPlay.length || onlyIos.length)
+            add(c, 'all', 'privacy answers agree', 'fail', `Play only: ${onlyPlay.join(', ') || '—'}; App Store only: ${onlyIos.join(', ') || '—'}`);
+        else
+            add(c, 'all', 'privacy answers agree', 'pass', d.play.collectsData ? `both declare ${d.play.types.length} Play / ${d.ios.types.length} App Store data types, from the same SDKs` : 'both: no data collected');
+        const decl = a.declared ?? {};
+        if (decl.iosDataNotCollected === true && !d.ios.dataNotCollected) {
+            add(c, 'ios', 'App Privacy: Data Not Collected', 'fail', `wrong: ${d.ios.types.map((t) => t.from).flat().filter((x, i, l) => l.indexOf(x) === i).join(', ')} collect ${d.ios.types.map((t) => t.type).join(', ')}`, 'declare the data types the SDK list derives (store plan prints them)');
+        }
+        if (decl.playCollectsData === false && d.play.collectsData) {
+            add(c, 'play', 'Data safety: collects data', 'fail', `wrong: the SDKs collect ${d.play.types.map((t) => t.type).join(', ')}`, 'declare the data types the SDK list derives');
+        }
+        if (decl.iosDataNotCollected !== undefined && decl.playCollectsData !== undefined && decl.iosDataNotCollected === decl.playCollectsData) {
+            add(c, 'all', 'declared forms agree', 'fail', `the App Store says ${decl.iosDataNotCollected ? 'no data collected' : 'data collected'}, Play says ${decl.playCollectsData ? 'data collected' : 'none'}`);
+        }
+        if (d.play.collectsData) {
+            for (const s of stores) {
+                const words = listingWords(a, s).join(' \n ');
+                const m = NO_DATA.exec(words);
+                if (m)
+                    add(c, s, 'listing vs SDKs', 'fail', `the listing says "${m[0]}" while ${sdks.join(', ')} ship`, 'fix the listing text before anyone fills a privacy form');
+            }
+        }
+        if (d.play.adId && a.audience?.ads === false)
+            add(c, 'play', 'advertising ID', 'warn', 'firebase-analytics reads the advertising ID: a game without ads declares No and removes the AD_ID permission (or turns ad-id collection off)');
+    }
+    const left = todos({ rating: a.rating, audience: a.audience });
+    if (!a.rating || !a.audience)
+        add(c, 'all', 'rating answers', 'fail', 'no rating or audience section');
+    else if (left.length)
+        add(c, 'all', 'rating answers', 'fail', `unanswered: ${left.join(', ')}`, 'the IARC questionnaire (Play) and Apple\'s age rating are filled from these');
+    else
+        add(c, 'all', 'rating answers', 'pass', `min age ${a.audience.minAge}, ads ${a.audience.ads ? 'yes' : 'no'}`);
+    if (typeof a.audience?.minAge === 'number' && a.audience.minAge < 13)
+        add(c, 'all', 'audience', 'warn', `min age ${a.audience.minAge}: a game for children enters each store's children's programme and its rules`, '13+ unless it is built for children');
+    const products = a.products;
+    if (isTodo(products) || !Array.isArray(products))
+        add(c, 'all', 'products', 'fail', 'unanswered', 'list each purchase (id, type, price), or [] for none');
+    else if (!products.length)
+        add(c, 'all', 'products', 'pass', 'none');
+    else {
+        const code = sourceText(c.root);
+        const seen = new Set();
+        for (const p of products) {
+            if (!p || typeof p.id !== 'string' || !PRODUCT_ID.test(p.id)) {
+                add(c, 'all', 'products', 'fail', `bad id: ${JSON.stringify(p?.id)}`, 'lowercase letters, digits, _ and . (Play\'s rule), the same id on iOS');
+                continue;
+            }
+            if (seen.has(p.id))
+                add(c, 'all', 'products', 'fail', `${p.id} twice`);
+            seen.add(p.id);
+            const missing = todos(p);
+            if (missing.length)
+                add(c, 'all', `product ${p.id}`, 'fail', `unanswered: ${missing.join(', ')}`);
+            else if (!PRICE.test(String(p.price)))
+                add(c, 'all', `product ${p.id}`, 'fail', `price "${p.price}"`, 'like "4.99 USD"');
+            else if (code !== null && !code.includes(p.id))
+                add(c, 'all', `product ${p.id}`, 'warn', 'the id is not in src/', 'a product the code never sells is a review rejection');
+            else
+                add(c, 'all', `product ${p.id}`, 'pass', `${p.type}, ${p.price}`);
+        }
+    }
+    const countries = a.countries;
+    if (isTodo(countries) || countries === undefined)
+        add(c, 'all', 'countries', 'fail', 'unanswered', '"all", or a list of ISO country codes');
+    else if (countries !== 'all' && !(Array.isArray(countries) && countries.length && countries.every((x) => /^[A-Z]{2}$/.test(x))))
+        add(c, 'all', 'countries', 'fail', `not "all" or ISO codes: ${JSON.stringify(countries)}`);
+    else
+        add(c, 'all', 'countries', 'pass', countries === 'all' ? 'all' : `${countries.length}`);
+}
+function listingWords(a, s) {
+    const l = a[s]?.listing;
+    return l ? Object.values(l).filter((v) => typeof v === 'string' && !isTodo(v)) : [];
+}
+function sourceText(root) {
+    const src = join(root, 'src');
+    if (!existsSync(src))
+        return null;
+    const out = [];
+    const walk = (d) => {
+        for (const e of readdirSync(d, { withFileTypes: true })) {
+            const p = join(d, e.name);
+            if (e.isDirectory())
+                walk(p);
+            else if (/\.(ts|tsx|js|jsx|mjs|cs|json)$/.test(e.name) && statSync(p).size < 2_000_000)
+                out.push(readFileSync(p, 'utf8'));
+        }
+    };
+    walk(src);
+    return out.join('\n');
+}
+function play(c) {
+    const p = c.a.play;
+    const R = RULES.play;
+    const pkg = p.packageName;
+    if (isTodo(pkg))
+        add(c, 'play', 'package name', 'fail', 'unanswered', 'the owner decides it: it is permanent once the app exists');
+    else if (!/^[a-zA-Z][\w]*(\.[a-zA-Z][\w]*)+$/.test(String(pkg)))
+        add(c, 'play', 'package name', 'fail', `not a package name: ${pkg}`);
+    else
+        add(c, 'play', 'package name', 'pass', String(pkg));
+    text(c, 'play', 'title', p.listing?.title, R.title, { free: true });
+    text(c, 'play', 'short description', p.listing?.short, R.short);
+    text(c, 'play', 'full description', p.listing?.full, R.full);
+    if (isTodo(p.category) || !p.category)
+        add(c, 'play', 'category', 'fail', 'unanswered', 'a game category (GAME_PUZZLE, GAME_ARCADE…); Game exempts it from Android 16\'s forced resizing');
+    else
+        add(c, 'play', 'category', /^GAME_/.test(p.category) ? 'pass' : 'warn', p.category, /^GAME_/.test(p.category) ? undefined : 'a game belongs in a GAME_ category');
+    const icon = picture(c, 'play', 'icon', p.art?.icon);
+    if (icon) {
+        const ok = icon.width === R.icon.width && icon.height === R.icon.height && icon.format === 'png';
+        add(c, 'play', 'icon', ok ? 'pass' : 'fail', `${icon.width}×${icon.height} ${icon.format}`, ok ? undefined : `${R.icon.width}×${R.icon.height} PNG, derived from the 1024 master`);
+    }
+    const fg = picture(c, 'play', 'feature graphic', p.art?.featureGraphic);
+    if (fg) {
+        const ok = fg.width === R.featureGraphic.width && fg.height === R.featureGraphic.height && !fg.alpha;
+        add(c, 'play', 'feature graphic', ok ? 'pass' : 'fail', `${fg.width}×${fg.height}${fg.alpha ? ' with alpha' : ''}`, ok ? undefined : `${R.featureGraphic.width}×${R.featureGraphic.height}, no transparency: new art per game`);
+    }
+    const shots = p.art?.screenshots?.phone;
+    if (isTodo(shots) || !Array.isArray(shots))
+        add(c, 'play', 'phone screenshots', 'fail', 'unanswered', `${R.screenshots.want}–${R.screenshots.max} real-play captures, at most 2:1`);
+    else {
+        const n = shots.length;
+        if (n < R.screenshots.min || n > R.screenshots.max)
+            add(c, 'play', 'phone screenshots', 'fail', `${n} screenshots: Play takes ${R.screenshots.min}–${R.screenshots.max}`);
+        else if (n < R.screenshots.want)
+            add(c, 'play', 'phone screenshots', 'warn', `${n} screenshots`, `${R.screenshots.want}–${R.screenshots.max} for a game listing`);
+        playShots(c, 'phone screenshot', shots);
+    }
+    if (p.art?.screenshots?.tablet?.length)
+        playShots(c, 'tablet screenshot', p.art.screenshots.tablet);
+}
+function playShots(c, check, shots) {
+    shots.forEach((s, i) => {
+        const info = picture(c, 'play', `${check} ${i + 1}`, s);
+        if (!info)
+            return;
+        const r = aspect(info);
+        if (r > RULES.play.screenshots.maxAspect + 1e-9)
+            add(c, 'play', `${check} ${i + 1}`, 'fail', `${s}: ${info.width}×${info.height} is ${r.toFixed(2)}:1, Play allows 2:1 at most`, 're-compose from real captures; never crop another store\'s set');
+        else
+            add(c, 'play', `${check} ${i + 1}`, 'pass', `${info.width}×${info.height}`);
+    });
+}
+function ios(c) {
+    const p = c.a.ios;
+    const R = RULES.ios;
+    const id = p.bundleId;
+    if (isTodo(id))
+        add(c, 'ios', 'bundle id', 'fail', 'unanswered', 'the owner decides it: it is permanent once the app exists');
+    else if (!/^[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)+$/.test(String(id)))
+        add(c, 'ios', 'bundle id', 'fail', `not a bundle id: ${id}`);
+    else
+        add(c, 'ios', 'bundle id', 'pass', String(id));
+    text(c, 'ios', 'name', p.listing?.name, R.name, { free: true });
+    text(c, 'ios', 'subtitle', p.listing?.subtitle, R.subtitle, { free: true });
+    const kw = text(c, 'ios', 'keywords', p.listing?.keywords, R.keywords, { free: true });
+    if (kw && /,\s/.test(kw))
+        add(c, 'ios', 'keywords', 'warn', 'spaces after commas count against the 100', 'write "puzzle,cozy,fishing"');
+    if (p.listing?.promo !== undefined)
+        text(c, 'ios', 'promotional text', p.listing.promo, R.promo);
+    text(c, 'ios', 'description', p.listing?.description, R.description);
+    if (isTodo(p.category) || !p.category)
+        add(c, 'ios', 'category', 'fail', 'unanswered', 'GAMES and a game subcategory');
+    else
+        add(c, 'ios', 'category', 'pass', p.category);
+    if (isTodo(p.ipad))
+        add(c, 'ios', 'iPad', 'fail', 'unanswered: does the game run on iPad?', 'yes needs a 13" screenshot set');
+    const icon = picture(c, 'ios', 'icon', p.art?.icon);
+    if (icon) {
+        const ok = icon.width === R.icon.width && icon.height === R.icon.height && !icon.alpha;
+        add(c, 'ios', 'icon', ok ? 'pass' : 'fail', `${icon.width}×${icon.height}${icon.alpha ? ' with an alpha channel' : ''}`, ok ? undefined : `${R.icon.width}×${R.icon.height}, no transparency (no alpha channel)`);
+    }
+    const sets = p.art?.screenshots;
+    if (isTodo(sets) || !sets || typeof sets !== 'object') {
+        add(c, 'ios', 'screenshots', 'fail', 'unanswered', 'one iPhone set (6.9" preferred) from real play with the real HUD');
+        return;
+    }
+    const unknown = Object.keys(sets).filter((k) => !IOS_DEVICES.includes(k));
+    if (unknown.length)
+        add(c, 'ios', 'screenshots', 'fail', `unknown device sets: ${unknown.join(', ')}`, `use ${IOS_DEVICES.join(', ')}`);
+    if (!IOS_DEVICES.some((d) => d.startsWith('iphone') && sets[d]?.length))
+        add(c, 'ios', 'screenshots', 'fail', 'no iPhone set', 'at least one iPhone set (6.9", 6.5" or 6.3")');
+    if (p.ipad === true && !sets['ipad-13']?.length)
+        add(c, 'ios', 'screenshots', 'fail', 'the game runs on iPad and has no 13" set');
+    for (const d of IOS_DEVICES) {
+        const list = sets[d];
+        if (!list)
+            continue;
+        if (list.length < R.screenshots.min || list.length > R.screenshots.max)
+            add(c, 'ios', `${d} screenshots`, 'fail', `${list.length}: ${R.screenshots.min}–${R.screenshots.max} per device size`);
+        const sizes = R.sizes[d].flatMap(([w, h]) => [`${w}×${h}`, `${h}×${w}`]);
+        list.forEach((s, i) => {
+            const info = picture(c, 'ios', `${d} screenshot ${i + 1}`, s);
+            if (!info)
+                return;
+            const size = `${info.width}×${info.height}`;
+            if (!sizes.includes(size))
+                add(c, 'ios', `${d} screenshot ${i + 1}`, 'fail', `${s}: ${size} is not a ${d} size`, `one of ${sizes.join(', ')}`);
+            else if (info.alpha)
+                add(c, 'ios', `${d} screenshot ${i + 1}`, 'fail', `${s}: has an alpha channel`, 'App Store screenshots cannot carry alpha: save without it');
+            else
+                add(c, 'ios', `${d} screenshot ${i + 1}`, 'pass', size);
+        });
+    }
+}
+function steam(c) {
+    const p = c.a.steam;
+    if (isTodo(p.appId))
+        add(c, 'steam', 'app id', 'warn', 'unanswered', 'Steam gives one when the app is created (Steam Direct fee, the owner\'s)');
+    text(c, 'steam', 'name', p.listing?.name, null);
+    text(c, 'steam', 'short description', p.listing?.short, null);
+    text(c, 'steam', 'about', p.listing?.about, null);
+    const shots = p.art?.screenshots;
+    const R = RULES.steam.screenshots;
+    if (isTodo(shots) || !Array.isArray(shots))
+        add(c, 'steam', 'screenshots', 'fail', 'unanswered', `at least ${R.min} real gameplay screenshots, 16:9, ${R.width}×${R.height} or larger`);
+    else {
+        if (shots.length < R.min)
+            add(c, 'steam', 'screenshots', 'fail', `${shots.length}: at least ${R.min}`);
+        shots.forEach((s, i) => {
+            const info = picture(c, 'steam', `screenshot ${i + 1}`, s);
+            if (!info)
+                return;
+            const ok = Math.abs(info.width / info.height - 16 / 9) < 0.01 && info.width >= R.width;
+            add(c, 'steam', `screenshot ${i + 1}`, ok ? 'pass' : 'fail', `${info.width}×${info.height}`, ok ? undefined : `16:9, ${R.width}×${R.height} or larger`);
+        });
+    }
+    for (const [k, v] of Object.entries(p.art ?? {})) {
+        if (k === 'screenshots' || v === undefined)
+            continue;
+        const info = picture(c, 'steam', k, v);
+        if (!info)
+            continue;
+        if (k === 'libraryLogo' && !info.alpha)
+            add(c, 'steam', k, 'fail', `${info.width}×${info.height} with no alpha`, 'the library logo is a transparent PNG');
+        else
+            add(c, 'steam', k, 'pass', `${info.width}×${info.height}`, 'check its size against Steamworks\' graphical assets page');
+    }
+}
+export function lintAnswers(root, a, only) {
+    const c = { root, a, out: [] };
+    const stores = storesOf(a, only);
+    if (a.version !== 1)
+        add(c, 'all', 'version', 'fail', `answers version ${a.version}`, 'this funtools reads version 1');
+    shared(c, stores);
+    if (stores.includes('play'))
+        play(c);
+    if (stores.includes('ios'))
+        ios(c);
+    if (stores.includes('steam'))
+        steam(c);
+    const findings = c.out.filter((f) => f.store === 'all' || stores.includes(f.store));
+    const counts = { pass: 0, warn: 0, fail: 0 };
+    for (const f of findings)
+        counts[f.state]++;
+    return { stores, findings, counts, todos: todos(a) };
+}

package/dist/store/plan.js

@@ -0,0 +1,133 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { derivePrivacy } from "./sdks.js";
+import { isTodo } from "./answers.js";
+export const STORE_PLAN_RECORD = join('.funtools', 'store-plan.json');
+export const PLAN_STORES = ['play', 'ios'];
+const noProducts = (a) => (Array.isArray(a.products) && a.products.length === 0 ? 'no products' : null);
+export const STEPS = {
+    play: [
+        { row: 'One-time setup', who: 'You', how: 'Cloud project with the Android Publisher and Reporting APIs on; a service account whose JSON key lives outside the repo (path in .env); invite it in Play Console › Users and permissions; a testers Google Group', setup: ['Play service account key'] },
+        { row: 'Create the app', who: 'You', how: 'Play Console › Create app: name, default language, Game, free or paid, and the declarations (a legal tick)', checks: ['package name', 'title'], shows: (a) => ({ packageName: a.play?.packageName, title: a.play?.listing?.title }) },
+        { row: 'Upload the AAB', who: 'Script', how: 'edits.bundles.upload (resumable)', checks: ['package name'], setup: ['Play service account key'], build: true },
+        { row: 'Internal release, testers', who: 'Script', how: 'edits.tracks.update on internal, then edits.commit', setup: ['Play service account key'], shows: (a) => ({ testersGroup: a.play?.testersGroup }) },
+        { row: 'Listing text', who: 'Script', how: 'edits.listings.update', checks: ['title', 'short description', 'full description'], setup: ['Play service account key'] },
+        { row: 'Icon, feature graphic, screenshots', who: 'Script', how: 'edits.images.upload per type (upload order is display order)', checks: ['icon', 'feature graphic', 'phone screenshot', 'tablet screenshot'], setup: ['Play service account key'] },
+        { row: 'Contact email, website', who: 'Script', how: 'edits.details.update', checks: ['contact email', 'contact website'], setup: ['Play service account key'], shows: (a) => ({ email: a.contact?.email, website: a.contact?.website }) },
+        { row: 'Data safety', who: 'Script', how: 'applications.dataSafety with Play\'s CSV (exported once from the console, kept as store/play-data-safety.csv)', checks: ['SDK list', 'privacy answers agree', 'Data safety', 'listing vs SDKs', 'declared forms agree'], setup: ['Play service account key'], shows: (a) => (Array.isArray(a.sdks) ? derivePrivacy(a.sdks).play : undefined) },
+        { row: 'App content: privacy URL, ads, ad ID, target audience, government, finance, health, AI declaration', who: 'Console', how: 'Play Console › App content, from the answers', checks: ['privacy URL', 'rating answers', 'audience', 'advertising ID'], shows: (a) => ({ privacyUrl: a.contact?.privacyUrl, ...a.audience, adId: Array.isArray(a.sdks) ? derivePrivacy(a.sdks).play.adId : undefined }) },
+        { row: 'Content rating (IARC)', who: 'Console', how: 'the IARC questionnaire from the rating answers; its terms tick is yours', checks: ['rating answers'], shows: (a) => a.rating },
+        { row: 'Category, countries', who: 'Console', how: 'Store settings (category) and Countries / regions', checks: ['category', 'countries'], shows: (a) => ({ category: a.play?.category, countries: a.countries }) },
+        { row: 'Sign in details, promo codes', who: 'Console', how: 'App access: how a reviewer reaches paid content (a promo code); the promo terms tick is yours', skip: noProducts },
+        { row: 'License testers, managed publishing', who: 'Console', how: 'License testing; Publishing overview › Managed publishing on, so an approved release waits for your click' },
+        { row: 'One-time product, prices', who: 'Script', how: 'monetization.onetimeproducts (after an AAB with the billing permission is on a track)', checks: ['products', 'product '], setup: ['Play service account key'], skip: noProducts, shows: (a) => a.products },
+        { row: 'Native crash symbols', who: 'Script', how: 'edits.deobfuscationfiles.upload (nativeCode), per version code', setup: ['Play service account key'], skip: (a) => (a.sdks !== undefined && Array.isArray(a.sdks) && !a.sdks.includes('crashlytics') ? 'no native crash reporting in the SDK list' : null) },
+        { row: 'Production release', who: 'Script', how: 'edits.tracks.update on production as a draft (completed or staged only with your go-ahead)', setup: ['Play service account key'], build: true },
+        { row: 'Send for review', who: 'You', how: 'Publishing overview › Send for review (edits.commit sends the API\'s changes; console-only changes need this button)' },
+        { row: 'Status, reviews, vitals', who: 'Script', how: 'Reviews API and Play Developer Reporting API (read-only)', setup: ['Play service account key'] },
+    ],
+    ios: [
+        { row: 'Agreements, tax, banking', who: 'You', how: 'App Store Connect › Business: the Paid Apps agreement, tax and banking' },
+        { row: 'API key and sign-in', who: 'You', how: 'a Team API key (App Manager), its .p8 outside the repo; asc auth login once', setup: ['asc (App Store Connect CLI)'] },
+        { row: 'Register the bundle id', who: 'Script', how: 'asc bundle-ids', checks: ['bundle id'], setup: ['asc (App Store Connect CLI)'], shows: (a) => ({ bundleId: a.ios?.bundleId }) },
+        { row: 'Create the app record', who: 'Console', how: 'App Store Connect › Apps › New App (asc web apps create only on your own Apple ID session, if you choose it)', checks: ['bundle id', 'name'], shows: (a) => ({ bundleId: a.ios?.bundleId, name: a.ios?.listing?.name }) },
+        { row: 'Certificates and profiles', who: 'Script', how: 'asc signing', setup: ['asc (App Store Connect CLI)', 'Xcode'] },
+        { row: 'Upload the build', who: 'Script', how: 'asc builds upload --ipa', setup: ['asc (App Store Connect CLI)'], build: true },
+        { row: 'TestFlight groups and testers', who: 'Script', how: 'asc testflight', setup: ['asc (App Store Connect CLI)'] },
+        { row: 'Listing text', who: 'Script', how: 'asc metadata apply --dry-run, then without it', checks: ['name', 'subtitle', 'keywords', 'promotional text', 'description', 'contact website'], setup: ['asc (App Store Connect CLI)'] },
+        { row: 'Screenshots and previews', who: 'Script', how: 'asc screenshots plan, then upload', checks: ['icon', 'screenshots', 'iphone-', 'ipad-', 'iPad'], setup: ['asc (App Store Connect CLI)'] },
+        { row: 'Category, age rating, encryption', who: 'Script', how: 'asc categories, asc age-rating, asc encryption', checks: ['category', 'rating answers'], setup: ['asc (App Store Connect CLI)'], shows: (a) => ({ category: a.ios?.category, rating: a.rating }) },
+        { row: 'App Privacy', who: 'Console', how: 'App Store Connect › App Privacy, from the SDK list (asc web privacy only on your own session, if you choose it)', checks: ['SDK list', 'privacy answers agree', 'App Privacy', 'listing vs SDKs', 'privacy URL', 'declared forms agree'], shows: (a) => (Array.isArray(a.sdks) ? derivePrivacy(a.sdks).ios : undefined) },
+        { row: 'Price and availability', who: 'Script', how: 'asc pricing', checks: ['countries'], setup: ['asc (App Store Connect CLI)'], shows: (a) => ({ countries: a.countries }) },
+        { row: 'In-app purchases, prices', who: 'Script', how: 'asc iap', checks: ['products', 'product '], setup: ['asc (App Store Connect CLI)'], skip: noProducts, shows: (a) => a.products },
+        { row: 'The first in-app purchase on the version', who: 'Console', how: 'tick it onto the version in App Store Connect (whether asc can is not verified)', skip: noProducts },
+        { row: 'Review details', who: 'Script', how: 'asc review: notes, contact, a way to the paid content', checks: ['contact email'], setup: ['asc (App Store Connect CLI)'], shows: (a) => ({ notes: a.ios?.reviewNotes, email: a.contact?.email }) },
+        { row: 'Validate', who: 'Script', how: 'asc validate --strict, asc release stage --dry-run', setup: ['asc (App Store Connect CLI)'] },
+        { row: 'Submit for review', who: 'You', how: 'App Store Connect › Add for Review › Submit' },
+        { row: 'Status, reviews', who: 'Script', how: 'asc status, asc reviews (read-only)', setup: ['asc (App Store Connect CLI)'] },
+    ],
+};
+export function canonical(v) {
+    if (Array.isArray(v))
+        return `[${v.map(canonical).join(',')}]`;
+    if (v && typeof v === 'object')
+        return `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${canonical(v[k])}`).join(',')}}`;
+    return JSON.stringify(v ?? null);
+}
+export function artPaths(a, store) {
+    const out = [];
+    const walk = (v) => {
+        if (typeof v === 'string' && !isTodo(v))
+            out.push(v);
+        else if (Array.isArray(v))
+            v.forEach(walk);
+        else if (v && typeof v === 'object')
+            Object.values(v).forEach(walk);
+    };
+    walk(a[store]?.art);
+    return [...new Set(out)].sort();
+}
+export function planHash(root, a, store) {
+    const h = createHash('sha256');
+    h.update(canonical(a)).update('\n');
+    for (const p of artPaths(a, store)) {
+        const full = resolve(root, p);
+        h.update(`${p}=${existsSync(full) ? createHash('sha256').update(readFileSync(full)).digest('hex') : 'missing'}\n`);
+    }
+    h.update(store);
+    return h.digest('hex');
+}
+const matches = (check, prefixes) => prefixes.some((p) => check === p || check.startsWith(p));
+export function storePlan(root, a, store, lint, doctor) {
+    const fails = lint.findings.filter((f) => f.state === 'fail' && (f.store === store || f.store === 'all'));
+    const steps = STEPS[store].map((d, i) => {
+        const needs = [];
+        const isTrue = [];
+        let state = 'ready';
+        const skipped = d.skip?.(a);
+        if (skipped)
+            return { n: i + 1, row: d.row, who: d.who, how: d.how, state: 'not-needed', needs: [], true: [skipped] };
+        for (const name of d.setup ?? []) {
+            const l = doctor.find((x) => x.store === store && x.check === name);
+            if (!l)
+                continue;
+            if (l.state === 'fail') {
+                needs.push(d.who === 'You' ? `${name}: ${l.says}${l.next ? ` — ${l.next}` : ''}` : `${name}: ${l.says} (the setup step)`);
+                state = 'needs-setup';
+            }
+            else
+                isTrue.push(`${name}: ${l.says}`);
+        }
+        if (d.checks) {
+            const blocking = fails.filter((f) => matches(f.check, d.checks));
+            for (const f of blocking)
+                needs.push(`${f.check}: ${f.says}${f.next ? ` — ${f.next}` : ''}`);
+            if (blocking.length && state === 'ready')
+                state = 'needs-answer';
+            const passed = lint.findings.filter((f) => f.state === 'pass' && (f.store === store || f.store === 'all') && matches(f.check, d.checks));
+            if (passed.length)
+                isTrue.push(`${passed.length} check${passed.length === 1 ? '' : 's'} pass (${[...new Set(passed.map((f) => f.check.replace(/ \d+$/, '')))].join(', ')})`);
+        }
+        if (d.build) {
+            const b = a[store]?.build;
+            if (typeof b !== 'string' || isTodo(b)) {
+                needs.push(`the ${store === 'play' ? 'AAB' : 'IPA'}: no build named in store/answers.json (${store}.build)`);
+                if (state === 'ready')
+                    state = 'needs-build';
+            }
+            else if (!existsSync(resolve(root, b))) {
+                needs.push(`${b}: no such file`);
+                if (state === 'ready')
+                    state = 'needs-build';
+            }
+            else
+                isTrue.push(`build ${b} exists`);
+        }
+        if (d.who === 'You' && d.setup?.length && state === 'ready' && isTrue.length)
+            state = 'done';
+        const shown = d.shows?.(a);
+        return { n: i + 1, row: d.row, who: d.who, how: d.how, state, needs, true: isTrue, ...(shown !== undefined ? { answers: shown } : {}) };
+    });
+    return { store, hash: planHash(root, a, store), steps, next: steps.find((s) => s.state !== 'done' && s.state !== 'not-needed') ?? null };
+}

package/dist/store/sdks.js

@@ -0,0 +1,107 @@
+const A = 'Analytics', F = 'App functionality';
+export const SDKS = {
+    'firebase-analytics': {
+        name: 'Google Analytics for Firebase',
+        source: 'support.google.com/analytics/answer/11582702 (read 8 Oct 2026)',
+        adId: true,
+        play: [
+            { category: 'Location', type: 'Approximate location', purpose: A },
+            { category: 'Financial info', type: 'Purchase history', purpose: A },
+            { category: 'App activity', type: 'App interactions', purpose: A },
+            { category: 'Device or other IDs', type: 'Device or other IDs', purpose: A },
+        ],
+        ios: [
+            { category: 'Location', type: 'Coarse Location', purpose: A, linked: false, tracking: false },
+            { category: 'Purchases', type: 'Purchase History', purpose: A, linked: false, tracking: false },
+            { category: 'Usage Data', type: 'Product Interaction', purpose: A, linked: false, tracking: false },
+            { category: 'Identifiers', type: 'Device ID', purpose: A, linked: false, tracking: false },
+        ],
+    },
+    crashlytics: {
+        name: 'Firebase Crashlytics',
+        source: 'firebase.google.com/docs/android/play-data-disclosure, /docs/ios/app-store-data-collection (read 8 Oct 2026)',
+        play: [
+            { category: 'App info and performance', type: 'Crash logs', purpose: F },
+            { category: 'App info and performance', type: 'Diagnostics', purpose: F },
+            { category: 'Device or other IDs', type: 'Device or other IDs', purpose: F },
+        ],
+        ios: [
+            { category: 'Diagnostics', type: 'Crash Data', purpose: F, linked: false, tracking: false },
+            { category: 'Identifiers', type: 'Device ID', purpose: F, linked: false, tracking: false },
+        ],
+    },
+    'firebase-performance': {
+        name: 'Firebase Performance Monitoring',
+        source: 'firebase.google.com/docs/android/play-data-disclosure, /docs/ios/app-store-data-collection (read 8 Oct 2026)',
+        play: [
+            { category: 'App info and performance', type: 'Diagnostics', purpose: A },
+            { category: 'Location', type: 'Approximate location', purpose: A },
+        ],
+        ios: [
+            { category: 'Diagnostics', type: 'Performance Data', purpose: A, linked: false, tracking: false },
+            { category: 'Location', type: 'Coarse Location', purpose: A, linked: false, tracking: false },
+        ],
+    },
+};
+const ALIASES = {
+    'firebase-crashlytics': 'crashlytics',
+    'google-analytics-firebase': 'firebase-analytics',
+    'google-analytics-for-firebase': 'firebase-analytics',
+    'firebase-perf': 'firebase-performance',
+};
+export const sdkId = (name) => {
+    const k = name.trim().toLowerCase().replace(/[\s_]+/g, '-');
+    return ALIASES[k] ?? k;
+};
+export function derivePrivacy(sdks) {
+    const known = [...new Set(sdks.map(sdkId))];
+    const unknown = known.filter((s) => !SDKS[s]);
+    const play = new Map();
+    const ios = new Map();
+    let adId = false;
+    for (const id of known.filter((s) => SDKS[s])) {
+        const e = SDKS[id];
+        adId ||= !!e.adId;
+        for (const i of e.play) {
+            const k = `${i.category}/${i.type}`;
+            const row = play.get(k) ?? { category: i.category, type: i.type, purposes: [], from: [] };
+            if (!row.purposes.includes(i.purpose))
+                row.purposes.push(i.purpose);
+            if (!row.from.includes(id))
+                row.from.push(id);
+            play.set(k, row);
+        }
+        for (const i of e.ios) {
+            const k = `${i.category}/${i.type}`;
+            const row = ios.get(k) ?? { category: i.category, type: i.type, purposes: [], linked: false, tracking: false, from: [] };
+            if (!row.purposes.includes(i.purpose))
+                row.purposes.push(i.purpose);
+            row.linked ||= i.linked;
+            row.tracking ||= i.tracking;
+            if (!row.from.includes(id))
+                row.from.push(id);
+            ios.set(k, row);
+        }
+    }
+    return {
+        play: { collectsData: play.size > 0, sharesData: false, types: [...play.values()], adId },
+        ios: { dataNotCollected: ios.size === 0, types: [...ios.values()] },
+        unknown,
+    };
+}
+export function agreement(d) {
+    const same = {
+        'Location/Approximate location': 'Location/Coarse Location',
+        'Financial info/Purchase history': 'Purchases/Purchase History',
+        'App activity/App interactions': 'Usage Data/Product Interaction',
+        'Device or other IDs/Device or other IDs': 'Identifiers/Device ID',
+        'App info and performance/Crash logs': 'Diagnostics/Crash Data',
+        'App info and performance/Diagnostics': 'Diagnostics/Performance Data',
+    };
+    const playKeys = d.play.types.map((t) => `${t.category}/${t.type}`);
+    const iosKeys = new Set(d.ios.types.map((t) => `${t.category}/${t.type}`));
+    const mapped = new Set(playKeys.map((k) => same[k] ?? k));
+    const onlyPlay = playKeys.filter((k) => !iosKeys.has(same[k] ?? k) && !(k === 'App info and performance/Diagnostics' && iosKeys.has('Diagnostics/Crash Data')));
+    const onlyIos = [...iosKeys].filter((k) => !mapped.has(k));
+    return { onlyPlay, onlyIos };
+}