@funpixel/tools 0.0.0-stage → 0.1.0

package/dist/doctor/unity-meta.js

@@ -0,0 +1,225 @@
+import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, statSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import { localPackages } from "./unity.js";
+export const TEXTURE_EXT = /\.(png|jpe?g|tga|psd|tiff?|gif|bmp|exr|hdr)$/i;
+export const AUDIO_EXT = /\.(wav|mp3|ogg|aiff?|flac|m4a)$/i;
+const REFERRER = /\.(unity|prefab|mat|asset|controller|overrideController|anim|playable|spriteatlas|spriteatlasv2|shadervariants|guiskin|fontsettings)$/;
+const skipDir = (name) => name.startsWith('.') || name.endsWith('~');
+function walk(root, out = []) {
+    let entries;
+    try {
+        entries = readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        const p = join(root, e.name);
+        if (e.isDirectory()) {
+            if (!skipDir(e.name))
+                walk(p, out);
+        }
+        else if (e.isFile())
+            out.push(p);
+    }
+    return out;
+}
+const read = (p, max = 16 * 1024 * 1024) => {
+    try {
+        return statSync(p).size > max ? '' : readFileSync(p, 'utf8');
+    }
+    catch {
+        return '';
+    }
+};
+export const guidOf = (meta) => /^guid:\s*([0-9a-f]{32})/m.exec(meta)?.[1] ?? null;
+export function assetRoots(dir) {
+    const roots = [];
+    if (existsSync(join(dir, 'Assets')))
+        roots.push({ root: join(dir, 'Assets'), prefix: 'Assets' });
+    const pkgs = join(dir, 'Packages');
+    const named = (root) => {
+        try {
+            return String(JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).name || '') || root.split(sep).pop();
+        }
+        catch {
+            return root.split(sep).pop();
+        }
+    };
+    const seen = new Set();
+    const add = (root) => {
+        if (seen.has(root))
+            return;
+        seen.add(root);
+        roots.push({ root, prefix: `Packages/${named(root)}` });
+    };
+    try {
+        for (const e of readdirSync(pkgs, { withFileTypes: true }))
+            if (e.isDirectory() && !skipDir(e.name))
+                add(join(pkgs, e.name));
+    }
+    catch {
+    }
+    for (const p of localPackages(dir)) {
+        try {
+            if (statSync(p).isDirectory())
+                add(p);
+        }
+        catch {
+        }
+    }
+    return roots;
+}
+export function assetIndex(dir) {
+    const textures = [];
+    const audio = [];
+    const referenced = new Set();
+    const atlased = new Set();
+    const folders = new Map();
+    for (const { root, prefix } of assetRoots(dir)) {
+        for (const abs of walk(root)) {
+            const rel = relative(root, abs).split(sep).join('/');
+            const path = `${prefix}/${rel}`;
+            if (abs.endsWith('.meta')) {
+                const target = abs.slice(0, -5);
+                if (!TEXTURE_EXT.test(target) && !AUDIO_EXT.test(target)) {
+                    try {
+                        if (statSync(target).isDirectory()) {
+                            const g = guidOf(read(abs, 64 * 1024));
+                            if (g)
+                                folders.set(path.slice(0, -5), g);
+                        }
+                    }
+                    catch {
+                    }
+                }
+                continue;
+            }
+            const isTex = TEXTURE_EXT.test(abs);
+            const isAudio = !isTex && AUDIO_EXT.test(abs);
+            if (isTex || isAudio) {
+                const meta = read(`${abs}.meta`, 1024 * 1024);
+                if (!meta)
+                    continue;
+                const a = { path, abs, guid: guidOf(meta), meta, resources: path.split('/').slice(0, -1).includes('Resources') };
+                (isTex ? textures : audio).push(a);
+                continue;
+            }
+            if (REFERRER.test(abs)) {
+                const text = read(abs);
+                const atlas = /\.spriteatlas(v2)?$/.test(abs);
+                for (const m of text.matchAll(/guid:\s*([0-9a-f]{32})/g))
+                    (atlas ? atlased : referenced).add(m[1]);
+            }
+        }
+    }
+    const folderGuids = (a) => {
+        const out = [];
+        const parts = a.path.split('/');
+        for (let i = parts.length - 1; i > 0; i--) {
+            const g = folders.get(parts.slice(0, i).join('/'));
+            if (g)
+                out.push(g);
+        }
+        return out;
+    };
+    return { textures, audio, referenced, atlased, folderGuids };
+}
+export const isAtlased = (ix, a) => (!!a.guid && ix.atlased.has(a.guid)) || ix.folderGuids(a).some((g) => ix.atlased.has(g));
+export const ships = (ix, a) => a.resources || (!!a.guid && ix.referenced.has(a.guid));
+const keyValues = (text) => {
+    const out = {};
+    for (const m of text.matchAll(/^[ \t]*-?[ \t]*([A-Za-z_]\w*):[ \t]*(.*)$/gm))
+        if (!(m[1] in out))
+            out[m[1]] = m[2].trim();
+    return out;
+};
+export const platformName = (t) => (t === 'iOS' ? 'iPhone' : t);
+export function textureMeta(meta) {
+    const at = meta.search(/^ {2}platformSettings:/m);
+    const top = keyValues(at < 0 ? meta : meta.slice(0, at));
+    const platforms = {};
+    if (at >= 0) {
+        const block = /^ {2}platformSettings:[^\n]*\n((?: {2}[- ] .*\n?| {4,}.*\n?)*)/m.exec(meta.slice(at))?.[1] ?? '';
+        for (const entry of block.split(/^ {2}- /m).slice(1)) {
+            const kv = keyValues(entry);
+            if (kv.buildTarget)
+                platforms[platformName(kv.buildTarget)] = kv;
+        }
+    }
+    return { top, platforms };
+}
+export function audioMeta(meta) {
+    const block = /^ {2}defaultSettings:[^\n]*\n((?: {4,}.*\n?)*)/m.exec(meta)?.[1] ?? '';
+    const rest = meta.replace(/^ {2}defaultSettings:[^\n]*\n((?: {4,}.*\n?)*)/m, '').replace(/^ {2}platformSettingOverrides:[\s\S]*?(?=^ {2}\S)/m, '');
+    return { defaults: keyValues(block), top: keyValues(rest) };
+}
+export const COMPRESSED_FORMATS = new Set([10, 12, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 64, 65, 66, 67, 68, 69, 70, 71]);
+export const META_PLATFORM = { ios: 'iPhone', android: 'Android', mac: 'Standalone', windows: 'Standalone', webgl: 'WebGL' };
+export function shipsAs(t, platform) {
+    const own = t.platforms[platform];
+    const def = t.platforms.DefaultTexturePlatform;
+    const max = Number((own?.overridden === '1' ? own.maxTextureSize : undefined) ?? def?.maxTextureSize ?? t.top.maxTextureSize ?? 2048) || 2048;
+    if (own?.overridden === '1') {
+        const f = Number(own.textureFormat ?? -1);
+        if (f !== -1)
+            return { compressed: COMPRESSED_FORMATS.has(f), maxSize: max, format: `format ${f} on ${platform}` };
+        return { compressed: (own.textureCompression ?? '1') !== '0', maxSize: max, format: `${platform} override` };
+    }
+    const c = def?.textureCompression ?? t.top.textureCompression ?? '1';
+    return { compressed: c !== '0', maxSize: max, format: 'the default compression' };
+}
+export function imageSize(file) {
+    let fd;
+    try {
+        fd = openSync(file, 'r');
+        const head = Buffer.alloc(32);
+        const n = readSync(fd, head, 0, 32, 0);
+        if (n < 24)
+            return null;
+        if (head.readUInt32BE(0) === 0x89504e47)
+            return { w: head.readUInt32BE(16), h: head.readUInt32BE(20) };
+        if (head.toString('latin1', 0, 4) === '8BPS')
+            return { w: head.readUInt32BE(18), h: head.readUInt32BE(14) };
+        if (head.toString('latin1', 0, 3) === 'GIF')
+            return { w: head.readUInt16LE(6), h: head.readUInt16LE(8) };
+        if (head.toString('latin1', 0, 2) === 'BM')
+            return { w: Math.abs(head.readInt32LE(18)), h: Math.abs(head.readInt32LE(22)) };
+        if (head[0] === 0xff && head[1] === 0xd8) {
+            const size = statSync(file).size;
+            let pos = 2;
+            const m = Buffer.alloc(9);
+            while (pos + 9 < size && pos < 4 * 1024 * 1024) {
+                readSync(fd, m, 0, 9, pos);
+                if (m[0] !== 0xff)
+                    return null;
+                const marker = m[1];
+                const len = m.readUInt16BE(2);
+                if (marker >= 0xc0 && marker <= 0xcf && ![0xc4, 0xc8, 0xcc].includes(marker))
+                    return { w: m.readUInt16BE(7), h: m.readUInt16BE(5) };
+                pos += 2 + len;
+            }
+            return null;
+        }
+        if (/\.tga$/i.test(file))
+            return { w: head.readUInt16LE(12), h: head.readUInt16LE(14) };
+        return null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+export const isPow2 = (n) => n > 0 && (n & (n - 1)) === 0;
+export function shippedSize(px, maxSize) {
+    const big = Math.max(px.w, px.h);
+    if (big <= maxSize)
+        return px;
+    const k = maxSize / big;
+    return { w: Math.max(1, Math.round(px.w * k)), h: Math.max(1, Math.round(px.h * k)) };
+}
+export const mb = (bytes) => bytes / (1024 * 1024);
+export const fmtMb = (bytes) => `${mb(bytes) >= 10 ? mb(bytes).toFixed(0) : mb(bytes).toFixed(1)} MB`;

package/dist/doctor/unity-project.js

@@ -0,0 +1,297 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import { localPackages, unityVersion } from "./unity.js";
+export const TARGET_NAME = { ios: 'iOS', android: 'Android', mac: 'Mac', windows: 'Windows', webgl: 'WebGL' };
+const skipDir = (name) => name.startsWith('.') || name.endsWith('~');
+function files(root, out = []) {
+    let entries;
+    try {
+        entries = readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        const p = join(root, e.name);
+        if (e.isDirectory()) {
+            if (!skipDir(e.name))
+                files(p, out);
+        }
+        else if (e.isFile())
+            out.push(p);
+    }
+    return out;
+}
+export function stripCs(src, blankStrings = true) {
+    let out = '';
+    let i = 0;
+    const n = src.length;
+    while (i < n) {
+        const c = src[i];
+        const d = src[i + 1];
+        if (c === '/' && d === '/') {
+            while (i < n && src[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (c === '/' && d === '*') {
+            const end = src.indexOf('*/', i + 2);
+            const stop = end < 0 ? n : end + 2;
+            out += src.slice(i, stop).replace(/[^\n]/g, ' ');
+            i = stop;
+            continue;
+        }
+        if (c === '"' || c === "'" || ((c === '@' || c === '$') && (d === '"' || ((d === '@' || d === '$') && src[i + 2] === '"')))) {
+            let j = i;
+            let verbatim = false;
+            while (src[j] === '@' || src[j] === '$') {
+                if (src[j] === '@')
+                    verbatim = true;
+                j++;
+            }
+            const quote = src[j];
+            const raw = quote === '"' && src.startsWith('"""', j);
+            let k = j + (raw ? 3 : 1);
+            for (; k < n; k++) {
+                if (raw) {
+                    if (src.startsWith('"""', k)) {
+                        k += 3;
+                        break;
+                    }
+                }
+                else if (verbatim) {
+                    if (src[k] === '"' && src[k + 1] === '"') {
+                        k++;
+                        continue;
+                    }
+                    if (src[k] === '"') {
+                        k++;
+                        break;
+                    }
+                }
+                else {
+                    if (src[k] === '\\') {
+                        k++;
+                        continue;
+                    }
+                    if (src[k] === quote) {
+                        k++;
+                        break;
+                    }
+                    if (src[k] === '\n')
+                        break;
+                }
+            }
+            const lit = src.slice(i, k);
+            if (!blankStrings)
+                out += lit;
+            else {
+                const open = src.slice(i, j + (raw ? 3 : 1));
+                const close = lit.length > open.length ? src.slice(k - (raw ? 3 : 1), k) : '';
+                out += open + lit.slice(open.length, lit.length - close.length).replace(/[^\n]/g, ' ') + close;
+            }
+            i = k;
+            continue;
+        }
+        out += c;
+        i++;
+    }
+    return out;
+}
+const segments = (rel) => rel.split(/[\\/]/);
+const csFile = (rel, text) => {
+    const seg = segments(rel).slice(0, -1);
+    return {
+        rel,
+        code: stripCs(text),
+        withStrings: stripCs(text, false),
+        editor: seg.includes('Editor'),
+        test: seg.some((s) => /tests?$/i.test(s)),
+    };
+};
+const read = (p) => {
+    try {
+        return readFileSync(p, 'utf8');
+    }
+    catch {
+        return '';
+    }
+};
+export function scalar(yaml, key) {
+    return new RegExp(`^\\s*${key}:[ \\t]*(.*)$`, 'm').exec(yaml)?.[1].trim() ?? null;
+}
+export function yamlMap(yaml, key) {
+    const m = new RegExp(`^( *)${key}:[ \\t]*\\n((?:\\1 +\\S.*\\n?)*)`, 'm').exec(yaml);
+    const out = {};
+    if (!m)
+        return out;
+    for (const line of m[2].split('\n')) {
+        const kv = /^\s*([^:]+):\s*(.*)$/.exec(line);
+        if (kv)
+            out[kv[1].trim()] = kv[2].trim();
+    }
+    return out;
+}
+export function graphicsApis(settings) {
+    const block = /^ *m_BuildTargetGraphicsAPIs:[^\n]*\n((?: +[- ] *\S.*\n?)*)/m.exec(settings)?.[1] ?? '';
+    const out = {};
+    for (const entry of block.split(/\n\s*- /)) {
+        const target = /m_BuildTarget:\s*(\S+)/.exec(entry)?.[1];
+        const auto = /m_Automatic:\s*(\d)/.exec(entry)?.[1];
+        if (target)
+            out[target] = { automatic: auto !== '0' };
+    }
+    return out;
+}
+export const templateBundleId = (id) => !id || /^com\.(DefaultCompany|Unity-?Technologies|UnityTechnologies|Company)\./i.test(id);
+const SCRIPT_EXT = /\.(sh|bash|zsh|py|mjs|cjs|js|ts|ps1|bat|cmd)$/i;
+const NOT_PROJECT = new Set(['Library', 'Temp', 'Logs', 'Builds', 'Build', 'UserSettings', 'obj', 'node_modules', 'Assets', 'Packages', 'ProjectSettings']);
+function scriptsOf(dir) {
+    const out = [];
+    const look = (folder, depth) => {
+        let entries;
+        try {
+            entries = readdirSync(folder, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const p = join(folder, e.name);
+            if (e.isFile() && (SCRIPT_EXT.test(e.name) || e.name === 'Makefile')) {
+                if (statSync(p).size < 512 * 1024)
+                    out.push({ rel: relative(dir, p), text: read(p) });
+            }
+            else if (e.isDirectory() && depth > 0 && /^(tools|scripts|Tools|Scripts|ci)$/.test(e.name) && !NOT_PROJECT.has(e.name))
+                look(p, depth - 1);
+        }
+    };
+    look(dir, 1);
+    return out;
+}
+const TARGET_CODE = [
+    ['ios', /\b(?:BuildTarget|NamedBuildTarget|BuildTargetGroup)\.iOS\b/],
+    ['android', /\b(?:BuildTarget|NamedBuildTarget|BuildTargetGroup)\.Android\b/],
+    ['mac', /\bBuildTarget\.StandaloneOSX\b/],
+    ['windows', /\bBuildTarget\.StandaloneWindows(?:64)?\b/],
+    ['webgl', /\b(?:BuildTarget|NamedBuildTarget|BuildTargetGroup)\.WebGL\b/],
+];
+const TARGET_FLAG = [
+    ['ios', /-buildTarget\s+["']?iOS\b/i],
+    ['android', /-buildTarget\s+["']?Android\b/i],
+    ['mac', /-buildTarget\s+["']?(?:OSXUniversal|StandaloneOSX|osx)\b/i],
+    ['windows', /-buildTarget\s+["']?(?:Win64|Win|StandaloneWindows64|StandaloneWindows)\b/i],
+    ['webgl', /-buildTarget\s+["']?WebGL\b/i],
+];
+function targetsOf(p) {
+    const t = new Map();
+    const add = (target, why) => {
+        const list = t.get(target) ?? [];
+        if (!list.includes(why))
+            list.push(why);
+        t.set(target, list);
+    };
+    const ids = yamlMap(p.settings, 'applicationIdentifier');
+    if (ids.iPhone && !templateBundleId(ids.iPhone))
+        add('ios', 'its iPhone bundle id');
+    if (ids.Android && !templateBundleId(ids.Android))
+        add('android', 'its Android bundle id');
+    for (const f of p.code)
+        for (const [target, re] of TARGET_CODE)
+            if (re.test(f.code))
+                add(target, 'its own code');
+    for (const s of p.scripts)
+        for (const [target, re] of TARGET_FLAG)
+            if (re.test(s.text))
+                add(target, s.rel);
+    return t;
+}
+const REFERRER = /\.(mat|shadervariants|prefab|unity|asset)$/;
+export function readUnityProject(dir) {
+    const assets = join(dir, 'Assets');
+    const all = existsSync(assets) ? files(assets).sort() : [];
+    const rel = (p) => relative(dir, p);
+    const code = [];
+    const scenes = [];
+    const models = [];
+    const shaders = [];
+    const referrers = [];
+    const tmpSettings = [];
+    for (const f of all) {
+        const r = rel(f);
+        if (f.endsWith('.cs'))
+            code.push(csFile(r, read(f)));
+        else if (f.endsWith('.unity'))
+            scenes.push(r);
+        else if (/\.(glb|gltf)$/i.test(f))
+            models.push(r);
+        else if (f.endsWith('.shader'))
+            shaders.push(r);
+        if (f.endsWith(`${sep}TMP Settings.asset`))
+            tmpSettings.push(r);
+        if (REFERRER.test(f))
+            referrers.push(r);
+    }
+    const packageCode = [];
+    const packageRoots = [
+        ...(existsSync(join(dir, 'Packages')) ? readdirSync(join(dir, 'Packages'), { withFileTypes: true }).filter((e) => e.isDirectory() && !skipDir(e.name)).map((e) => join(dir, 'Packages', e.name)) : []),
+        ...localPackages(dir).filter((p) => existsSync(p) && statSync(p).isDirectory()),
+    ];
+    for (const root of [...new Set(packageRoots)]) {
+        for (const f of files(root)) {
+            const shownPath = f.startsWith(dir + sep) ? rel(f) : `${root.split(sep).pop()}/${relative(root, f)}`;
+            if (f.endsWith('.cs'))
+                packageCode.push(csFile(shownPath, read(f)));
+            if (f.endsWith(`${sep}TMP Settings.asset`))
+                tmpSettings.push(shownPath);
+        }
+    }
+    let manifest = {};
+    try {
+        manifest = JSON.parse(read(join(dir, 'Packages', 'manifest.json'))).dependencies ?? {};
+    }
+    catch {
+    }
+    const base = {
+        dir,
+        version: unityVersion(dir),
+        settings: read(join(dir, 'ProjectSettings', 'ProjectSettings.asset')),
+        graphics: read(join(dir, 'ProjectSettings', 'GraphicsSettings.asset')),
+        manifest,
+        code,
+        packageCode,
+        scenes,
+        models,
+        shaders,
+        referrers,
+        tmpSettings,
+        scripts: scriptsOf(dir),
+    };
+    return { ...base, targets: targetsOf(base) };
+}
+const NOT_METHOD = new Set(['if', 'for', 'foreach', 'while', 'switch', 'catch', 'using', 'lock', 'return', 'new', 'else', 'fixed', 'when', 'nameof', 'typeof', 'sizeof', 'default', 'checked', 'unchecked']);
+export function methodsOf(code) {
+    const out = [];
+    const header = /\b([\w<>[\],.?]+)\s+(\w+)\s*(?:<[^<>()]*>)?\s*\((?:[^()]|\([^()]*\))*\)\s*(?:where\s[^{;]+)?\{/g;
+    const classes = [...code.matchAll(/\b(?:class|struct)\s+(\w+)/g)].map((m) => ({ at: m.index, name: m[1] }));
+    for (const m of code.matchAll(header)) {
+        const name = m[2];
+        if (NOT_METHOD.has(name) || NOT_METHOD.has(m[1]))
+            continue;
+        const open = m.index + m[0].length - 1;
+        let depth = 0;
+        let end = open;
+        for (let i = open; i < code.length; i++) {
+            if (code[i] === '{')
+                depth++;
+            else if (code[i] === '}' && --depth === 0) {
+                end = i;
+                break;
+            }
+        }
+        const cls = classes.filter((c) => c.at < m.index).pop()?.name ?? '';
+        out.push({ cls, name, start: open, end });
+    }
+    return out.filter((m) => !out.some((o) => o !== m && o.start < m.start && o.end >= m.end));
+}
+export const methodAt = (methods, at) => methods.find((m) => m.start <= at && at <= m.end) ?? null;

package/dist/doctor/unity.js

@@ -0,0 +1,171 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, openSync, readFileSync, readSync, closeSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+export const LFS_POINTER_HEAD = 'version https://git-lfs.github.com/spec/v1';
+const POINTER_MAX_BYTES = 1024;
+export const isUnityProject = (dir) => existsSync(join(dir, 'ProjectSettings', 'ProjectVersion.txt'));
+export function unityVersion(dir) {
+    try {
+        return /m_EditorVersion:\s*(\S+)/.exec(readFileSync(join(dir, 'ProjectSettings', 'ProjectVersion.txt'), 'utf8'))?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function isLfsPointer(file) {
+    let size;
+    try {
+        size = statSync(file).size;
+    }
+    catch {
+        return false;
+    }
+    if (size < LFS_POINTER_HEAD.length || size > POINTER_MAX_BYTES)
+        return false;
+    const buf = Buffer.alloc(LFS_POINTER_HEAD.length);
+    let fd;
+    try {
+        fd = openSync(file, 'r');
+        readSync(fd, buf, 0, buf.length, 0);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+    return buf.toString('latin1') === LFS_POINTER_HEAD;
+}
+const skipDir = (name) => name.startsWith('.') || name.endsWith('~');
+function walk(root, out, seen) {
+    let real;
+    try {
+        real = realpathSync(root);
+    }
+    catch {
+        return;
+    }
+    if (seen.has(real))
+        return;
+    seen.add(real);
+    let entries;
+    try {
+        entries = readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const p = join(root, e.name);
+        let isDir = e.isDirectory();
+        let isFile = e.isFile();
+        if (e.isSymbolicLink()) {
+            try {
+                const s = statSync(p);
+                isDir = s.isDirectory();
+                isFile = s.isFile();
+            }
+            catch {
+                continue;
+            }
+        }
+        if (isDir) {
+            if (!skipDir(e.name))
+                walk(p, out, seen);
+        }
+        else if (isFile && !e.name.endsWith('.meta') && isLfsPointer(p))
+            out.push(p);
+    }
+}
+export function localPackages(dir) {
+    let manifest;
+    try {
+        manifest = JSON.parse(readFileSync(join(dir, 'Packages', 'manifest.json'), 'utf8'));
+    }
+    catch {
+        return [];
+    }
+    const deps = manifest?.dependencies ?? {};
+    const out = [];
+    for (const v of Object.values(deps)) {
+        if (typeof v !== 'string' || !v.startsWith('file:'))
+            continue;
+        const p = v.slice('file:'.length);
+        out.push(isAbsolute(p) ? p : resolve(dir, 'Packages', p));
+    }
+    return out;
+}
+export function gitRoot(from) {
+    let d = from;
+    for (;;) {
+        if (existsSync(join(d, '.git')))
+            return d;
+        const up = dirname(d);
+        if (up === d)
+            return null;
+        d = up;
+    }
+}
+const inside = (child, parent) => child === parent || child.startsWith(parent.endsWith(sep) ? parent : parent + sep);
+export function findLfsPointers(dir) {
+    const root = resolve(dir);
+    const seen = new Set();
+    const pointers = [];
+    const scanned = [];
+    const missingPackages = [];
+    for (const rel of ['Assets', 'Packages']) {
+        const p = join(root, rel);
+        if (existsSync(p)) {
+            scanned.push(p);
+            walk(p, pointers, seen);
+        }
+    }
+    for (const pkg of localPackages(root)) {
+        if (!existsSync(pkg)) {
+            missingPackages.push(pkg);
+            continue;
+        }
+        scanned.push(pkg);
+        if (statSync(pkg).isFile()) {
+            if (isLfsPointer(pkg))
+                pointers.push(pkg);
+        }
+        else
+            walk(pkg, pointers, seen);
+    }
+    const cache = join(root, 'Library', 'PackageCache');
+    if (existsSync(cache)) {
+        scanned.push(cache);
+        walk(cache, pointers, seen);
+    }
+    const groups = new Map();
+    for (const f of [...new Set(pointers)].sort()) {
+        let key;
+        let kind;
+        if (inside(f, cache)) {
+            key = join(cache, relative(cache, f).split(sep)[0]);
+            kind = 'package-cache';
+        }
+        else {
+            const g = gitRoot(dirname(f));
+            key = g ?? dirname(f);
+            kind = g ? 'repo' : 'none';
+        }
+        const group = groups.get(key) ?? { root: key, kind, files: [] };
+        group.files.push(f);
+        groups.set(key, group);
+    }
+    return { scanned, groups: [...groups.values()], missingPackages };
+}
+export const gitLfsInstalled = () => spawnSync('git', ['lfs', 'version'], { stdio: 'ignore' }).status === 0;
+export const shown = (dir, p) => (inside(p, resolve(dir)) ? relative(resolve(dir), p) || '.' : p);
+export function pullHint(dir, g, lfsInstalled) {
+    const install = lfsInstalled ? '' : 'install Git LFS first (`brew install git-lfs`, then `git lfs install`), then ';
+    if (g.kind === 'package-cache') {
+        return `${install}delete ${shown(dir, g.root)} with Unity closed and reopen the project, so the Package Manager fetches the package again with its LFS files`;
+    }
+    if (g.kind === 'none')
+        return 'not in a git checkout: copy the real files from wherever they came from';
+    return `${install}run \`git lfs pull\` in ${g.root}`;
+}