@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/doctor/unity-history.js

@@ -0,0 +1,589 @@
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { gitRoot } from "./unity.js";
+import { methodAt, methodsOf, scalar, templateBundleId, yamlMap } from "./unity-project.js";
+import { importRules, enumName, KEY_ENUM } from "./unity-import-rules.js";
+import { assetIndex, audioMeta, COMPRESSED_FORMATS, fmtMb, imageSize, isAtlased, isPow2, META_PLATFORM, shippedSize, ships, shipsAs, textureMeta } from "./unity-meta.js";
+const list = (xs, n = 3) => `${xs.slice(0, n).join(', ')}${xs.length > n ? `, … (${xs.length} in all)` : ''}`;
+const runtime = (f) => !f.editor && !f.test;
+const read = (p, max = 4 * 1024 * 1024) => {
+    try {
+        return statSync(p).size > max ? '' : readFileSync(p, 'utf8');
+    }
+    catch {
+        return '';
+    }
+};
+const lineOf = (text, at) => text.slice(0, at).split('\n').length;
+const home = (p, h = process.env.HOME ?? '') => (h && (p === h || p.startsWith(h + sep)) ? `~${p.slice(h.length)}` : p);
+const readdirSafe = (d) => { try {
+    return readdirSync(d);
+}
+catch {
+    return [];
+} };
+const statSafe = (p) => { try {
+    return statSync(p);
+}
+catch {
+    return null;
+} };
+export const audioSettings = (p) => read(join(p.dir, 'ProjectSettings', 'AudioManager.asset'));
+export function metaPlatform(p) {
+    const order = ['ios', 'android', 'webgl', 'mac', 'windows'];
+    const t = order.find((x) => p.targets.has(x));
+    return t ? META_PLATFORM[t] : 'DefaultTexturePlatform';
+}
+export const SAMPLE_RATE_FIX = 'set m_SampleRate: 48000 in ProjectSettings/AudioManager.asset (Project Settings > Audio > System Sample Rate)';
+export function checkSampleRate(p, audio = audioSettings(p)) {
+    const rate = scalar(audio, 'm_SampleRate');
+    if (!audio || rate === null)
+        return [];
+    if (rate === '48000')
+        return [['pass', 'audio: 48 kHz (m_SampleRate: 48000 in ProjectSettings/AudioManager.asset)']];
+    const reset = p.code.find((f) => runtime(f) && /\bAudioSettings\s*\.\s*Reset\s*\(/.test(f.code) && /\bsampleRate\s*=\s*48000\b/.test(f.code));
+    if (reset)
+        return [['pass', `audio: m_SampleRate is ${rate}, and ${reset.rel} sets 48000 through AudioSettings.Reset`]];
+    const what = rate === '0' ? "0, the device's rate (24 kHz on the iOS Simulator)" : `${rate} Hz`;
+    return [['warn', `audio: m_SampleRate is ${what}, not 48000: one game's cues came out dull at 24 kHz until it pinned 48000, and 8 of 13 studio games still follow the device — ${SAMPLE_RATE_FIX}`]];
+}
+export function checkAudioDisabled(p, ix, audio = audioSettings(p)) {
+    if (scalar(audio, 'm_DisableAudio') !== '1')
+        return [];
+    const plays = ix.audio.length > 0 || p.code.some((f) => runtime(f) && /\bAudio(?:Source|Clip)\b/.test(f.code));
+    return [[plays ? 'fail' : 'warn', `audio: m_DisableAudio is 1, so the build plays no sound at all${plays ? `, and the game has ${ix.audio.length ? `${ix.audio.length} sound file(s)` : 'code that plays sound'}` : ''}: one game inherited it from a template and only the upload script caught it — set m_DisableAudio: 0 in ProjectSettings/AudioManager.asset (Project Settings > Audio > Disable Unity Audio, off)`]];
+}
+const biggest = (xs) => [...xs].sort((x, y) => y.bytes - x.bytes);
+const named = (xs, n = 3) => list(biggest(xs).map((x) => `${x.a.path} (${x.px.w}×${x.px.h}, ${fmtMb(x.bytes)})`), n);
+const total = (xs) => xs.reduce((s, x) => s + x.bytes, 0);
+function rulesWriting(rules, kind, path, match) {
+    return rules.filter((r) => r.kind === kind && r.read(path).wants.some(match)).map((r) => r.name);
+}
+export function checkNpotMips(p, ix, rules = []) {
+    const platform = metaPlatform(p);
+    const hits = [];
+    let read = 0;
+    for (const a of ix.textures) {
+        if (!ships(ix, a) || isAtlased(ix, a))
+            continue;
+        const t = textureMeta(a.meta);
+        read++;
+        if (t.top.enableMipMap !== '1' || t.top.nPOTScale !== '0' || (t.top.textureShape ?? '1') !== '1')
+            continue;
+        const px = imageSize(a.abs);
+        if (!px || (isPow2(px.w) && isPow2(px.h)))
+            continue;
+        const s = shippedSize(px, shipsAs(t, platform).maxSize);
+        hits.push({ a, px, bytes: Math.round(s.w * s.h * 4 * (4 / 3)) });
+    }
+    if (!hits.length)
+        return read ? [['pass', `textures: no mipmapped texture with a side that is not a power of two (${read} that ship read)`]] : [];
+    const writers = hits.map((h) => rulesWriting(rules, 'texture', h.a.path, (w) => (w.key === 'nPOTScale' && w.value === '0') || (w.key === 'enableMipMap' && w.value === '1')));
+    const byRule = [...new Set(writers.flat())];
+    const where = !byRule.length ? 'in each .meta' : `in the import rule that sets them (${list(byRule, 2)}), or the next import puts them back${writers.some((w) => !w.length) ? ', and in the other .meta files' : ''}`;
+    return [['warn', `textures: ${hits.length} mipmapped texture(s) with a side that is not a power of two and Non-Power of 2 set to None: Unity leaves them uncompressed, RGBA32, without a word and even under an ASTC override (measured twice: a splash screen and one game's character screens), about ${fmtMb(total(hits))}: ${named(hits)} — set Non-Power of 2 to ToNearest (nPOTScale: 1) or turn mipmaps off (enableMipMap: 0) ${where}; the splash alone cost 10.3 MB in every game that shipped it`]];
+}
+const ICON = /(^|\/)(icons?|appicons?)(\/|$)/i;
+export function checkUncompressed(p, ix, rules = []) {
+    const platform = metaPlatform(p);
+    const hits = [];
+    const kept = [];
+    const keepers = new Set();
+    let read = 0;
+    for (const a of ix.textures) {
+        if (!ships(ix, a) || isAtlased(ix, a) || ICON.test(a.path))
+            continue;
+        read++;
+        const t = textureMeta(a.meta);
+        const how = shipsAs(t, platform);
+        if (how.compressed)
+            continue;
+        const px = imageSize(a.abs);
+        if (!px)
+            continue;
+        const s = shippedSize(px, how.maxSize);
+        if (Math.max(s.w, s.h) <= 512)
+            continue;
+        const x = { a, px, bytes: Math.round(s.w * s.h * 4 * (t.top.enableMipMap === '1' ? 4 / 3 : 1)) };
+        const by = rulesWriting(rules, 'texture', a.path, (w) => (w.key === 'textureCompression' && w.value === '0' && (w.where === 'DefaultTexturePlatform' || w.where === platform)) || (w.key === 'textureFormat' && w.where === platform && w.value !== '-1' && !COMPRESSED_FORMATS.has(Number(w.value))));
+        if (by.length) {
+            kept.push(x);
+            for (const r of by)
+                keepers.add(r);
+        }
+        else
+            hits.push(x);
+    }
+    const out = [];
+    if (hits.length) {
+        out.push(['warn', `textures: ${hits.length} texture(s) over 512 px ship uncompressed on ${platform === 'DefaultTexturePlatform' ? 'every platform' : platform} (about ${fmtMb(total(hits))}): ${named(hits)} — compress them (Compression: Normal Quality, the DefaultTexturePlatform textureCompression in each .meta, or an ${platform === 'DefaultTexturePlatform' ? 'iPhone' : platform} override to ASTC); 17 of the studio's size commits were passes like this`]);
+    }
+    if (!hits.length && !kept.length && read)
+        out.push(['pass', `textures: none over 512 px ships uncompressed on ${platform === 'DefaultTexturePlatform' ? 'any platform' : platform} (${read} that ship read)`]);
+    if (kept.length)
+        out.push(['note', `textures: ${kept.length} texture(s) over 512 px stay uncompressed because ${list([...keepers], 2)} says so (about ${fmtMb(total(kept))}) — fine for data read as pixels; anything drawn as a picture is cheaper compressed`]);
+    return out;
+}
+const near = (a, b) => a === b || (!Number.isNaN(Number(a)) && !Number.isNaN(Number(b)) && Math.abs(Number(a) - Number(b)) < 1e-4);
+export function settledWants(rules, path) {
+    const reads = rules.map((r) => ({ r, x: r.read(path) }));
+    const out = [];
+    for (const { r, x } of reads) {
+        for (const w of x.wants) {
+            const id = `${w.where}\u0000${w.key}`;
+            const others = reads.filter((o) => o.r !== r);
+            if (others.some((o) => o.x.any || o.x.maybe.has(id) || o.x.maybe.has(`*\u0000${w.key}`) || o.x.wants.some((v) => v.where === w.where && v.key === w.key && !near(v.value, w.value))))
+                continue;
+            if (out.some((o) => o.want.where === w.where && o.want.key === w.key))
+                continue;
+            out.push({ rule: r.name, want: w });
+        }
+    }
+    return out;
+}
+export function importDrift(ix, rules) {
+    const drifts = [];
+    let covered = 0;
+    for (const kind of ['texture', 'audio']) {
+        const mine = rules.filter((r) => r.kind === kind);
+        if (!mine.length)
+            continue;
+        for (const a of kind === 'texture' ? ix.textures : ix.audio) {
+            const wants = settledWants(mine, a.path);
+            if (!wants.length)
+                continue;
+            covered++;
+            const t = kind === 'texture' ? textureMeta(a.meta) : null;
+            const m = kind === 'audio' ? audioMeta(a.meta) : null;
+            for (const { rule, want } of wants) {
+                let has = t ? (want.where === 'top' ? t.top[want.key] : t.platforms[want.where]?.[want.key]) : want.where === 'defaults' ? m.defaults[want.key] : m.top[want.key];
+                if (has === undefined && t && want.where !== 'top' && want.key === 'overridden')
+                    has = '0';
+                if (has === undefined || near(has, want.value))
+                    continue;
+                drifts.push({ asset: a, rule, key: want.key, has, want });
+            }
+        }
+    }
+    return { drifts, covered };
+}
+const shownValue = (key, v) => enumName(KEY_ENUM[key], v);
+export function checkImportDrift(ix, rules) {
+    if (!rules.length)
+        return [];
+    const { drifts, covered } = importDrift(ix, rules);
+    if (!drifts.length)
+        return covered ? [['pass', `import rules: the ${covered} .meta file(s) ${rules.length} rule(s) write agree with them`]] : [];
+    const out = [];
+    const retyped = [...new Map(drifts.filter((d) => d.key === 'textureType' && d.has === '8' && d.want.value !== '8').map((d) => [d.asset.path, d])).values()];
+    if (retyped.length) {
+        const rulesNamed = [...new Set(retyped.map((d) => d.rule))];
+        out.push(['warn', `import rules: the next import turns ${retyped.length} sprite(s) into ${retyped[0].want.shown} textures (${list(rulesNamed, 2)} re-types them): ${list(retyped.map((d) => d.asset.path))} — anything that loads them as a Sprite then gets null; rename or move them out of the rule's reach (TextureBudget takes every name__role texture under Art/ or Models/), or make the rule leave sprites alone`]);
+    }
+    const byRule = new Map();
+    for (const d of drifts)
+        byRule.set(d.rule, [...(byRule.get(d.rule) ?? []), d]);
+    for (const [rule, ds] of byRule) {
+        const files = [...new Set(ds.map((d) => d.asset.path))];
+        const keys = [...new Set(ds.map((d) => d.key))];
+        const eg = ds[0];
+        const file = rules.find((r) => r.name === rule)?.file;
+        out.push(['warn', `import rules: ${files.length} .meta file(s) disagree with ${rule}${file ? ` (${file})` : ''}, which rewrites them on the next import (${list(keys, 4)}): e.g. ${eg.asset.path}.meta has ${eg.key} ${shownValue(eg.key, eg.has)}, the rule writes ${eg.want.shown}${files.length > 1 ? `; also ${list(files.slice(1), 2)}` : ''} — reimport them (select the folder, Reimport; or AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate)) and commit the .meta files: until then a build ships whatever that Mac's Library last imported, and a fresh clone's import dirties the tree`]);
+    }
+    return out;
+}
+export function checkTextureRoles(ix, rules) {
+    const coarse = [];
+    for (const a of ix.textures) {
+        if (!/__normal\d*\.[a-z]+$/i.test(a.path))
+            continue;
+        const wants = settledWants(rules.filter((r) => r.kind === 'texture'), a.path);
+        const type = wants.find((w) => w.want.key === 'textureType');
+        const fmt = wants.find((w) => w.want.key === 'textureFormat' && Number(w.want.value) >= 50 && Number(w.want.value) <= 53);
+        if (type && type.want.value === '0' && fmt)
+            coarse.push({ a, rule: fmt.rule, fmt: fmt.want.shown });
+    }
+    if (!coarse.length)
+        return [];
+    return [['warn', `textures: ${coarse.length} normal map(s) import as Default textures at ${coarse[0].fmt} (${list([...new Set(coarse.map((c) => c.rule))], 2)}): ${list(coarse.map((c) => c.a.path))} — a 6×6 block or coarser smears a normal map's detail; give __normal textures ASTC 4x4 or 5x5 in that rule`]];
+}
+export function gitCommonDir(dir) {
+    const root = gitRoot(dir);
+    if (!root)
+        return null;
+    const dotGit = join(root, '.git');
+    try {
+        if (statSync(dotGit).isDirectory())
+            return realpathSync(dotGit);
+        const to = /^gitdir:\s*(.+)$/m.exec(readFileSync(dotGit, 'utf8'))?.[1]?.trim();
+        if (!to)
+            return null;
+        const gd = resolve(root, to);
+        const common = read(join(gd, 'commondir')).trim();
+        return realpathSync(common ? resolve(gd, common) : gd);
+    }
+    catch {
+        return null;
+    }
+}
+export function identityOf(dir, settings = read(join(dir, 'ProjectSettings', 'ProjectSettings.asset'))) {
+    const ids = yamlMap(settings, 'applicationIdentifier');
+    const bundle = [ids.iPhone, ids.Android, ids.Standalone].find((b) => b && !templateBundleId(b)) ?? null;
+    return { dir, guid: scalar(settings, 'productGUID'), product: scalar(settings, 'productName'), bundle, metro: scalar(settings, 'metroPackageName'), repo: gitCommonDir(dir) };
+}
+const SKIP_SCAN = new Set(['node_modules', 'Library', 'Temp', 'Logs', 'Builds', 'Build', 'obj', 'bin', 'target', 'dist', 'Assets', 'Packages', 'UserSettings', 'ProjectSettings', 'build', 'out', 'vendor', 'Pods', 'DerivedData']);
+export function unityProjectsUnder(roots, depth = 4) {
+    const out = [];
+    const look = (d, left) => {
+        if (existsSync(join(d, 'ProjectSettings', 'ProjectVersion.txt'))) {
+            out.push(d);
+            return;
+        }
+        if (left <= 0)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries)
+            if (e.isDirectory() && !e.name.startsWith('.') && !e.name.endsWith('~') && !SKIP_SCAN.has(e.name))
+                look(join(d, e.name), left - 1);
+    };
+    for (const r of roots)
+        look(r, depth);
+    return [...new Set(out)];
+}
+const slug = (s) => (s ?? '').toLowerCase().replace(/[^a-z0-9]/g, '');
+const GENERIC = new Set(['unity', 'game', 'games', 'project', 'app', 'src', 'client', 'main']);
+export function namesOf(id) {
+    const folder = basename(id.dir);
+    const names = [GENERIC.has(folder.toLowerCase()) ? basename(dirname(id.dir)) : folder, id.product ?? '', (id.bundle ?? '').split('.').pop() ?? ''];
+    return [...new Set(names.filter((n) => n && !GENERIC.has(n.toLowerCase())))];
+}
+const inRepo = (dir) => { const r = gitRoot(dir); return r ? relative(r, dir) : null; };
+const sameGame = (a, b) => (!!a.repo && a.repo === b.repo && inRepo(a.dir) === inRepo(b.dir)) || (!!a.bundle && a.bundle === b.bundle);
+export const GUID_FIX = 'give the one made later its own: with Unity closed, set productGUID in its ProjectSettings/ProjectSettings.asset to the output of `uuidgen | tr -d - | tr A-F a-f`';
+export function checkClonedIdentity(p, others) {
+    const me = identityOf(p.dir, p.settings);
+    const real = (d) => { try {
+        return realpathSync(d);
+    }
+    catch {
+        return d;
+    } };
+    const mine = real(p.dir);
+    const rest = others.filter((o) => real(o.dir) !== mine);
+    const out = [];
+    const label = (o) => `${o.product ?? basename(o.dir)} (${home(o.dir)})`;
+    if (me.guid && /^[0-9a-f]{32}$/i.test(me.guid)) {
+        const dupes = rest.filter((o) => o.guid === me.guid && !sameGame(me, o));
+        if (dupes.length)
+            out.push(['warn', `identity: productGUID ${me.guid} is also ${list(dupes.map(label), 2)}'s: one project was cloned from the other (one game carried its sibling's), so Unity's services and caches take the two for one project — ${GUID_FIX}`]);
+        else if (rest.length)
+            out.push(['pass', `identity: productGUID is this project's own (${rest.length} other Unity project(s) on this Mac read)`]);
+    }
+    const own = new Set(namesOf(me).map(slug));
+    if (me.metro && !own.has(slug(me.metro))) {
+        const from = rest.find((o) => !sameGame(me, o) && namesOf(o).some((n) => slug(n) === slug(me.metro)));
+        if (from)
+            out.push(['warn', `identity: metroPackageName is "${me.metro}", ${label(from)}'s name: a leftover of the project this one was cloned from — set metroPackageName: ${namesOf(me)[0]?.toLowerCase().replace(/[^a-z0-9-]+/g, '-') ?? 'its own name'} in ProjectSettings/ProjectSettings.asset (Player > Publishing Settings > Package name)`]);
+    }
+    const repo = gitRoot(p.dir);
+    for (const at of [...new Set([join(p.dir, '.gitattributes'), ...(repo ? [join(repo, '.gitattributes')] : [])])]) {
+        const text = read(at, 256 * 1024);
+        if (!text)
+            continue;
+        const base = dirname(at);
+        const foreign = [];
+        for (const [i, line] of text.split('\n').entries()) {
+            const pattern = line.trim().split(/\s+/)[0];
+            if (!pattern || pattern.startsWith('#') || !pattern.includes('/'))
+                continue;
+            const literal = pattern.replace(/^\//, '').split('/').filter((seg, k, all) => k < all.length - 1).filter((seg, k, all) => all.slice(0, k + 1).every((x) => !/[*?[\]]/.test(x)));
+            if (!literal.length || existsSync(join(base, ...literal)))
+                continue;
+            const of = rest.find((o) => namesOf(o).some((n) => literal.some((seg) => slug(seg) === slug(n))));
+            if (of)
+                foreign.push({ line: i + 1, path: literal.join('/'), of });
+        }
+        if (foreign.length) {
+            const shown = relative(p.dir, at) || '.gitattributes';
+            const owners = [...new Set(foreign.map((f) => label(f.of)))];
+            out.push(['warn', `identity: ${shown} line${foreign.length > 1 ? 's' : ''} ${foreign.map((f) => f.line).join(', ')} name${foreign.length > 1 ? '' : 's'} ${list([...new Set(foreign.map((f) => `${f.path}/`))], 2)}, ${list(owners, 2)}'s path${foreign.length > 1 ? 's' : ''}, not in this repository: copied from it, so ${foreign.length > 1 ? 'those rules match' : 'the rule matches'} nothing here — remove ${foreign.length > 1 ? 'them' : 'it'}, or point ${foreign.length > 1 ? 'them' : 'it'} at this project's own files`]);
+        }
+    }
+    return out;
+}
+export function checkStudioPackages(p, run) {
+    const out = [];
+    const ownRepo = gitRoot(p.dir);
+    const real = (d) => { try {
+        return realpathSync(d);
+    }
+    catch {
+        return d;
+    } };
+    for (const [name, spec] of Object.entries(p.manifest)) {
+        if (typeof spec !== 'string' || !spec.startsWith('file:'))
+            continue;
+        const rel = spec.slice(5);
+        const abs = isAbsolute(rel) ? rel : resolve(p.dir, 'Packages', rel);
+        if (!existsSync(abs) || !statSync(abs).isDirectory())
+            continue;
+        let version = '';
+        try {
+            version = String(JSON.parse(readFileSync(join(abs, 'package.json'), 'utf8')).version ?? '');
+        }
+        catch {
+        }
+        const label = `${name}${version ? ` ${version}` : ''}`;
+        const root = gitRoot(abs);
+        if (!root) {
+            out.push(['note', `studio package ${label}: ${home(abs)}, not in a git checkout: the game compiles whatever is on disk there`]);
+            continue;
+        }
+        const same = !!ownRepo && real(root) === real(ownRepo);
+        const inRepo = relative(root, abs) || '.';
+        const commit = run('git', ['-C', root, 'rev-parse', '--short=9', 'HEAD'])?.trim() || null;
+        const branch = run('git', ['-C', root, 'symbolic-ref', '--short', '-q', 'HEAD'])?.trim() || null;
+        const status = run('git', ['-C', root, '--no-optional-locks', 'status', '--porcelain', '--', inRepo]);
+        const dirty = !!status && status.trim().length > 0;
+        const at = `${branch ?? 'a detached HEAD'}${commit ? ` @ ${commit}` : ''}${dirty ? ', with uncommitted changes in it' : ''}`;
+        const where = same ? `this repository's ${inRepo}` : home(abs);
+        const says = `studio package ${label} compiles from ${where}: ${at}`;
+        if (!same && commit && (!branch || !/^(main|master)$/.test(branch))) {
+            const main = ['main', 'master'].find((b) => run('git', ['-C', root, 'rev-parse', '--verify', '-q', `${b}^{commit}`]) !== null);
+            const onMain = !!main && run('git', ['-C', root, 'cat-file', '-e', `${main}:${inRepo === '.' ? '' : `${inRepo}/`}package.json`]) !== null;
+            const pin = `pin a tag in Packages/manifest.json ("${name}": "git+<its url>?path=${inRepo}#<tag>")`;
+            out.push(['warn', onMain
+                    ? `${says}, not ${main} — a session that switches branches there changes what this game builds: check out ${main} in ${home(root)}, or ${pin}`
+                    : `${says}, and ${main ? `${main} does not have it yet` : 'that checkout has no main'} — a session that switches branches there takes the package from this game: merge it to ${main ?? 'main'}, or ${pin}`]);
+        }
+        else if (!same && dirty) {
+            out.push(['warn', `${says} — uncommitted work there (perhaps another session's) builds into this game: commit or stash it in ${home(root)} before a build`]);
+        }
+        else
+            out.push(['note', says]);
+    }
+    return out;
+}
+export function checkFirebaseSimulator(p) {
+    const firebase = Object.keys(p.manifest).filter((k) => k.startsWith('com.google.firebase.'));
+    if (!firebase.length && existsSync(join(p.dir, 'Assets', 'Firebase')))
+        firebase.push('Assets/Firebase');
+    if (!firebase.length || !p.targets.has('ios'))
+        return [];
+    const all = [...p.code, ...p.packageCode];
+    const stub = all.find((f) => f.editor && /libFirebaseCpp/.test(f.withStrings));
+    const guard = all.find((f) => !f.editor && /\bSIMULATOR_UDID\b/.test(f.withStrings));
+    if (stub && guard)
+        return [['pass', `Firebase on the Simulator: stubbed at link (${stub.rel}) and muted at run (${guard.rel})`]];
+    const out = [];
+    const names = list(firebase, 2);
+    if (!stub)
+        out.push(['warn', `Firebase on the Simulator: ${names} in an iOS game, and nothing stubs it for a Simulator build: Firebase's C++ libraries (libFirebaseCpp*.a) carry no arm64 Simulator slice and the iOS 26 Simulator runs arm64 only, so the link fails — add an IPostprocessBuildWithReport that, for SimulatorSDK builds only, drops them from UnityFramework and links stubs in their place (an Editor script such as Assets/_Game/Editor/SimFirebase.cs)`]);
+    if (!guard)
+        out.push(['warn', `Firebase on the Simulator: nothing reads SIMULATOR_UDID, so a Simulator run calls the stubbed SDK and throws TypeInitializationException (the Simulator reports a real model, iPhone18,1, so a model check never matches) — skip Firebase and mute telemetry when SIMULATOR_UDID is set`]);
+    return out;
+}
+const GATE = /\bisDebugBuild\b|\bDEVELOPMENT_BUILD\b|\b[A-Z][A-Z0-9]*_TEST_ARGS\b/;
+const READS_ARGS = /\bLaunchArgs\s*\.\s*Get\s*\(|\bGetCommandLineArgs\s*\(/g;
+const BUILD_SWITCH = /^\s*#\s*(?:el)?if\b(?![^\n]*\bUNITY_(?:IOS|ANDROID|STANDALONE\w*|WEBGL|TVOS|VISIONOS|WSA\w*|SWITCH|PS\d|GAMECORE\w*)\b[^\n]*$)[^\n]*\b[A-Z][A-Z0-9_]{2,}\b/m;
+export function gateNames(files) {
+    const out = new Set();
+    for (const f of files) {
+        if (!GATE.test(f.code) && !BUILD_SWITCH.test(f.code))
+            continue;
+        for (const m of f.code.matchAll(/\bbool\s+(\w+)\s*(=>|=|\{)/g)) {
+            const from = m.index + m[0].length - (m[2] === '{' ? 1 : 0);
+            let end = from;
+            if (m[2] === '{') {
+                let depth = 0;
+                for (let i = from; i < f.code.length; i++) {
+                    if (f.code[i] === '{')
+                        depth++;
+                    else if (f.code[i] === '}' && --depth === 0) {
+                        end = i;
+                        break;
+                    }
+                }
+            }
+            else
+                end = f.code.indexOf(';', from);
+            const body = f.code.slice(from, end < 0 ? undefined : end);
+            if (GATE.test(body) || BUILD_SWITCH.test(body))
+                out.add(m[1]);
+        }
+    }
+    return [...out];
+}
+export function checkLaunchArgs(p) {
+    const files = p.code.filter(runtime);
+    const gates = gateNames(files);
+    const gated = (code) => GATE.test(code) || gates.some((g) => new RegExp(`\\b${g}\\b`).test(code));
+    const readers = files.filter((f) => new RegExp(READS_ARGS.source).test(f.code));
+    if (!readers.length)
+        return [];
+    const reads = (f) => [...f.code.matchAll(READS_ARGS)].filter((m) => {
+        const from = f.code.lastIndexOf(';', m.index) + 1;
+        const to = f.code.indexOf(';', m.index);
+        return !/\bMuted\s*=\s*true\b/.test(f.code.slice(from, to < 0 ? undefined : to));
+    });
+    const open = readers.filter((f) => !gated(f.code)).flatMap((f) => { const r = reads(f); return r.length ? [`${f.rel}:${lineOf(f.code, r[0].index)}`] : []; });
+    if (!open.length)
+        return [['pass', `launch flags: every reader is behind a development-build gate (${readers.length} file(s))`]];
+    const fix = "read every flag through one gated reader, `if (!Debug.isDebugBuild && !Application.isEditor) return none;`";
+    const what = `launch flags: ${open.length} player file(s) read the launch arguments with no development-build gate (isDebugBuild, DEVELOPMENT_BUILD, a *_TEST_ARGS define, or a flag built on one): ${list(open)}`;
+    const desktop = ['mac', 'windows'].filter((t) => p.targets.has(t));
+    if (desktop.length)
+        return [['warn', `${what} — the ${desktop.map((t) => (t === 'mac' ? 'Mac' : 'Windows')).join(' and ')} build honours them for anyone who starts it with a flag (three release builds honoured unlock flags: -setcoins, -unlocked, -unlockall); ${fix}`]];
+    return [['note', `${what} — harmless while the game ships only for phones (a store build there starts with no arguments, and Android's intent flags should be read only in development builds), live the day it ships for Mac or Windows; ${fix}`]];
+}
+const EXIT = /\bEditorApplication\s*\.\s*Exit\s*\(/g;
+const BATCH = /\bisBatchMode\b|\binBatchMode\b/;
+export function checkEditorExit(p) {
+    const files = [...p.code, ...p.packageCode].filter((f) => f.editor && !f.test);
+    const open = [];
+    let all = 0;
+    for (const f of files) {
+        if (!new RegExp(EXIT.source).test(f.code))
+            continue;
+        const methods = methodsOf(f.code);
+        const lines = [];
+        for (const m of f.code.matchAll(EXIT)) {
+            all++;
+            const at = methodAt(methods, m.index);
+            if (BATCH.test(f.code.slice(at ? at.start : 0, m.index)))
+                continue;
+            lines.push(lineOf(f.code, m.index));
+        }
+        if (lines.length)
+            open.push(`${f.rel}:${lines.join(',')}`);
+    }
+    if (!all)
+        return [];
+    if (!open.length)
+        return [['pass', `EditorApplication.Exit: every call checks batch mode first (${all})`]];
+    return [['warn', `EditorApplication.Exit with no batch-mode check: ${list(open)} — run in an open Editor (a menu item, or \`funtools unity editor call\`), it quits that Editor and loses its unsaved work; exit only in batch mode: \`if (Application.isBatchMode) EditorApplication.Exit(1); else throw new BuildFailedException(why);\``]];
+}
+function sideProjects(dir) {
+    const out = [];
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        if (!e.isDirectory() || !e.name.endsWith('~'))
+            continue;
+        const look = (rel, depth) => {
+            for (const n of readdirSafe(join(dir, rel))) {
+                const child = `${rel}/${n}`;
+                if (n.endsWith('.csproj'))
+                    out.push({ folder: e.name, csproj: child, text: read(join(dir, child), 256 * 1024) });
+                else if (depth > 0 && !/^(bin|obj|\..*)$/.test(n) && statSafe(join(dir, child))?.isDirectory())
+                    look(child, depth - 1);
+            }
+        };
+        look(e.name, 1);
+    }
+    return out;
+}
+export function checkNetstandard(p) {
+    const side = sideProjects(p.dir);
+    const tests = side.filter((s) => /nunit|xunit|Microsoft\.NET\.Test\.Sdk|MSTest/i.test(s.text) || /tests?~$/i.test(s.folder));
+    if (!tests.length)
+        return [];
+    const ns = side.find((s) => /<TargetFrameworks?>[^<]*netstandard/i.test(s.text));
+    if (ns)
+        return [['pass', `engine-free code: ${tests[0].folder} runs it on .NET and ${ns.csproj} compiles it against netstandard, Unity's API`]];
+    const tfm = /<TargetFrameworks?>([^<]+)</i.exec(tests[0].text)?.[1] ?? '.NET';
+    return [['note', `engine-free code: ${tests[0].folder} runs it on ${tfm} only, where an API Unity lacks still compiles — add a CoreNetStandard~ project that compiles the same files for netstandard2.1 (CoreNetStandard~/CoreNetStandard.csproj; 6 of 13 studio games have one)`]];
+}
+const PARSES = /\b(?:double|float|decimal|Double|Single)\s*\.\s*(?:Try)?Parse\s*\(|\bConvert\s*\.\s*To(?:Double|Single)\s*\(/;
+const PRINTS = /\.ToString\s*\(\s*"(?:R|G17)"/;
+export function hasGoldens(p) {
+    if (p.code.some((f) => /golden/i.test(f.rel)))
+        return true;
+    const names = (d) => { try {
+        return readdirSync(d);
+    }
+    catch {
+        return [];
+    } };
+    return [...names(p.dir), ...sideProjects(p.dir).flatMap((s) => names(join(p.dir, s.folder)))].some((n) => /golden/i.test(n));
+}
+export function checkIl2cppNumbers(p) {
+    if (!hasGoldens(p))
+        return [];
+    const hits = p.code.filter((f) => runtime(f) && (PARSES.test(f.code) || PRINTS.test(f.withStrings))).map((f) => {
+        const at = f.code.search(PARSES);
+        return `${f.rel}:${lineOf(f.code, at >= 0 ? at : f.withStrings.search(PRINTS))}`;
+    });
+    if (!hits.length)
+        return [];
+    return [['note', `numbers: the project replays goldens, and ${hits.length} player file(s) parse or print doubles with the runtime's own routines (${list(hits)}): under IL2CPP double.Parse misread 446 of 100,000 doubles and "R" printed 17 digits where 16 read back (one game, twice), so a golden that passes in the Editor can differ in the player — replay one golden in a development player, or parse and print exactly (a decimal parser and printer of the game's own)`]];
+}
+const UDID = /\b[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\b/;
+const SIM_CONTEXT = /sim|udid|device|\bDEV\b|xcrun|booted/i;
+const SCRIPT_EXT = /\.(sh|bash|zsh|py|mjs|cjs|js|ts|ps1)$/i;
+export function scriptsInReach(p) {
+    const own = [...p.scripts];
+    const repo = gitRoot(p.dir);
+    if (repo && resolve(repo) !== resolve(p.dir)) {
+        const named = new Set();
+        for (const text of [...own.map((s) => s.text), ...p.code.map((f) => f.withStrings), ...readdirSafe(p.dir).filter((n) => /\.md$/i.test(n)).map((n) => read(join(p.dir, n), 512 * 1024))]) {
+            for (const m of text.matchAll(/(?<![\w.-])[\w.-]+\.(?:sh|bash|zsh|py|mjs|cjs|js|ts|ps1)\b/g))
+                named.add(m[0].split('/').pop());
+        }
+        for (const folder of ['tools', 'scripts']) {
+            for (const n of readdirSafe(join(repo, folder))) {
+                if (!SCRIPT_EXT.test(n) || !named.has(n))
+                    continue;
+                const abs = join(repo, folder, n);
+                own.push({ rel: relative(p.dir, abs), text: read(abs, 512 * 1024) });
+            }
+        }
+    }
+    return own;
+}
+export function checkHardcodedSimulator(p) {
+    const hits = [];
+    for (const s of scriptsInReach(p)) {
+        for (const [i, line] of s.text.split('\n').entries())
+            if (UDID.test(line) && SIM_CONTEXT.test(line) && !/^\s*(#|\/\/)/.test(line))
+                hits.push(`${s.rel}:${i + 1}`);
+    }
+    if (!hits.length)
+        return [];
+    return [['warn', `Simulator UDID typed into ${list(hits)}: every agent on this Mac then drives that one Simulator, and a run shut down under another killed it three times — lease one per run: \`funtools sim lease\` prints a fresh udid, \`funtools sim release <udid>\` gives it back (skill funpixel-unity-game, references/agent-ops.md)`]];
+}
+export const HISTORY_HEADING = "the studio's history · fixes its games' logs repeated";
+export function historyChecks(p, host) {
+    const audio = audioSettings(p);
+    const ix = assetIndex(p.dir);
+    const rules = importRules([...p.code, ...p.packageCode].filter((f) => f.editor));
+    const needsOthers = !!scalar(p.settings, 'productGUID') || !!scalar(p.settings, 'metroPackageName');
+    const others = needsOthers ? unityProjectsUnder(host.unityRoots ?? []).map((d) => identityOf(d)) : [];
+    return [
+        ...checkSampleRate(p, audio),
+        ...checkAudioDisabled(p, ix, audio),
+        ...checkNpotMips(p, ix, rules),
+        ...checkUncompressed(p, ix, rules),
+        ...checkImportDrift(ix, rules),
+        ...checkTextureRoles(ix, rules),
+        ...checkClonedIdentity(p, others),
+        ...checkStudioPackages(p, host.run),
+        ...checkFirebaseSimulator(p),
+        ...checkLaunchArgs(p),
+        ...checkEditorExit(p),
+        ...checkNetstandard(p),
+        ...checkIl2cppNumbers(p),
+        ...checkHardcodedSimulator(p),
+    ];
+}