@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/unity/queue.js

@@ -0,0 +1,353 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { realpathSync } from 'node:fs';
+import { mkdir, readdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { basename, join, resolve } from 'node:path';
+import { alive, isBatch, subtreeCpu, unityOn, unityRuns } from "../machine/procs.js";
+export const STALE_MINUTES = 20;
+export const MAX_UNITY = 2;
+export const POLL_MS = 5000;
+const UNWRITTEN_MS = 60_000;
+export function projectNames(project) {
+    const abs = resolve(project).replace(/\/+$/, '');
+    let real = abs;
+    try {
+        real = realpathSync(abs);
+    }
+    catch { }
+    return [...new Set([abs, real])];
+}
+export function projectKey(project) {
+    const real = projectNames(project).at(-1);
+    const slug = basename(real).replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 40) || 'project';
+    return `${slug}-${createHash('sha1').update(real).digest('hex').slice(0, 12)}`;
+}
+export const lockDir = (root, project) => join(root, 'projects', `${projectKey(project)}.lock`);
+export const queueDir = (root, project) => join(root, 'projects', `${projectKey(project)}.queue`);
+export const slotDir = (root, n) => join(root, 'slots', `${n}.lock`);
+export const newJobId = () => randomBytes(4).toString('hex');
+async function writeJson(file, value) {
+    const tmp = `${file}.${process.pid}.${randomBytes(3).toString('hex')}.tmp`;
+    await writeFile(tmp, JSON.stringify(value, null, 2) + '\n');
+    await rename(tmp, file);
+}
+export async function readLock(dir, now) {
+    let s;
+    try {
+        s = await stat(dir);
+    }
+    catch {
+        return { kind: 'free' };
+    }
+    try {
+        return { kind: 'held', rec: JSON.parse(await readFile(join(dir, 'owner.json'), 'utf8')) };
+    }
+    catch {
+        return { kind: 'unwritten', age: now - s.mtimeMs };
+    }
+}
+async function logStat(file) {
+    if (!file || file === '-')
+        return null;
+    try {
+        const s = await stat(file);
+        return { size: s.size, mtime: s.mtimeMs };
+    }
+    catch {
+        return null;
+    }
+}
+export async function judge(rec, procs, now, staleMs, watch) {
+    const pids = [rec.pid, rec.unity_pid].filter((p) => typeof p === 'number');
+    if (!pids.some((p) => alive(procs, p)))
+        return { live: false, why: `its processes are gone (pid ${pids.join(', ')})`, lastProgress: 0 };
+    const log = await logStat(rec.log);
+    const cpu = subtreeCpu(procs, pids);
+    let seenAt = 0;
+    if (watch) {
+        const prev = watch.get(rec.id);
+        if (!prev || prev.log !== (log?.size ?? 0) || cpu >= prev.cpu + 1)
+            watch.set(rec.id, { log: log?.size ?? 0, cpu, at: now });
+        else if (cpu < prev.cpu)
+            prev.cpu = cpu;
+        seenAt = watch.get(rec.id).at;
+    }
+    const lastProgress = Math.max(seenAt, log?.mtime ?? 0, Date.parse(rec.progress_at ?? '') || 0, Date.parse(rec.since) || 0);
+    const idle = now - lastProgress;
+    if (idle >= staleMs)
+        return { live: false, why: `no progress for ${Math.round(idle / 60000)} min (log ${log ? `${log.size} bytes, unchanged` : 'not written'}, no CPU used)`, lastProgress };
+    return { live: true, why: 'making progress', lastProgress };
+}
+async function reclaim(dir, judgedId, now) {
+    const st = await readLock(dir, now);
+    if (st.kind === 'free')
+        return false;
+    if (st.kind === 'held' && st.rec.id !== judgedId)
+        return false;
+    const aside = `${dir}.stale-${now}-${randomBytes(3).toString('hex')}`;
+    try {
+        await rename(dir, aside);
+    }
+    catch {
+        return false;
+    }
+    await rm(aside, { recursive: true, force: true });
+    return true;
+}
+const ago = (now, iso) => {
+    const s = Math.max(0, Math.round((now - Date.parse(iso)) / 1000));
+    return s < 120 ? `${s} s` : s < 7200 ? `${Math.round(s / 60)} min` : `${(s / 3600).toFixed(1)} h`;
+};
+export const holderLine = (rec, now) => `session ${rec.session}, pid ${rec.unity_pid ?? rec.pid}, \`${rec.command}\`, since ${rec.since} (${ago(now, rec.since)})`;
+async function tickets(qdir, procs) {
+    let names = [];
+    try {
+        names = await readdir(qdir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const n of names.filter((x) => x.endsWith('.json'))) {
+        try {
+            const t = JSON.parse(await readFile(join(qdir, n), 'utf8'));
+            if (alive(procs, t.pid))
+                out.push(t);
+            else
+                await rm(join(qdir, n), { force: true });
+        }
+        catch { }
+    }
+    return out.sort((a, b) => a.at - b.at || a.id.localeCompare(b.id));
+}
+export async function waiting(root, project, procs) {
+    return tickets(queueDir(root, project), procs);
+}
+async function slots(root, procs, now, staleMs, watch, max, say) {
+    const held = [];
+    const free = [];
+    let names = [];
+    try {
+        names = await readdir(join(root, 'slots'));
+    }
+    catch { }
+    const nums = new Set([...Array(max).keys()]);
+    for (const n of names) {
+        const m = /^(\d+)\.lock$/.exec(n);
+        if (m)
+            nums.add(Number(m[1]));
+    }
+    for (const n of [...nums].sort((a, b) => a - b)) {
+        const dir = slotDir(root, n);
+        const st = await readLock(dir, now);
+        if (st.kind === 'free') {
+            if (n < max)
+                free.push(n);
+            continue;
+        }
+        if (st.kind === 'unwritten') {
+            if (st.age > UNWRITTEN_MS && await reclaim(dir, null, now)) {
+                say(`reclaimed Unity slot ${n}: taken and never written (a crash)`);
+                if (n < max)
+                    free.push(n);
+            }
+            else
+                held.push({ id: `unwritten-${n}`, project: '?', pid: 0, session: '?', cwd: '?', command: '(starting)', since: new Date(now).toISOString(), log: null });
+            continue;
+        }
+        const v = await judge(st.rec, procs, now, staleMs, watch);
+        if (v.live)
+            held.push(st.rec);
+        else if (await reclaim(dir, st.rec.id, now)) {
+            say(`reclaimed Unity slot ${n} from ${holderLine(st.rec, now)}: ${v.why}`);
+            if (n < max)
+                free.push(n);
+        }
+    }
+    return { held, free };
+}
+export function foreignBatch(procs, ours) {
+    const known = new Set(ours.flatMap((r) => [r.pid, r.unity_pid ?? -1]));
+    return unityRuns(procs).filter((p) => isBatch(p.args) && !known.has(p.pid) && !known.has(p.ppid));
+}
+export async function acquire(rec, o, d) {
+    const names = projectNames(rec.project);
+    const pdir = lockDir(d.root, rec.project);
+    const qdir = queueDir(d.root, rec.project);
+    await mkdir(qdir, { recursive: true });
+    await mkdir(join(d.root, 'slots'), { recursive: true });
+    const ticketFile = join(qdir, `${rec.id}.json`);
+    const start = d.now();
+    await writeJson(ticketFile, { id: rec.id, pid: rec.pid, at: start, session: rec.session, command: rec.command });
+    const watch = new Map();
+    let lastSaid = '';
+    let lastSaidAt = 0;
+    const say = (key, line) => {
+        const t = d.now();
+        if (key !== lastSaid || t - lastSaidAt >= 60_000) {
+            d.log(line);
+            lastSaid = key;
+            lastSaidAt = t;
+        }
+    };
+    const dropTicket = () => rm(ticketFile, { force: true });
+    const timedOut = () => o.maxWaitMs !== null && d.now() - start >= o.maxWaitMs;
+    try {
+        for (;;) {
+            const procs = await d.procs();
+            const now = d.now();
+            const st = await readLock(pdir, now);
+            if (st.kind === 'held') {
+                const v = await judge(st.rec, procs, now, o.staleMs, watch);
+                if (!v.live) {
+                    if (await reclaim(pdir, st.rec.id, now))
+                        d.log(`reclaimed the lock on ${rec.project} from ${holderLine(st.rec, now)}: ${v.why}`);
+                    continue;
+                }
+                say(`held:${st.rec.id}`, `waiting for ${rec.project}: held by ${holderLine(st.rec, now)}`);
+            }
+            else if (st.kind === 'unwritten') {
+                if (st.age > UNWRITTEN_MS && await reclaim(pdir, null, now)) {
+                    d.log(`reclaimed the lock on ${rec.project}: taken and never written (a crash)`);
+                    continue;
+                }
+            }
+            else {
+                const line = await tickets(qdir, procs);
+                const first = line[0];
+                const editors = unityOn(procs, names);
+                const interactive = editors.filter((p) => !isBatch(p.args));
+                if (interactive.length) {
+                    return { ok: false, code: 'editor_open', message: `the Unity Editor (pid ${interactive.map((p) => p.pid).join(', ')}) has ${rec.project} open, and batch mode cannot open a project an Editor holds — save and quit that Editor (funtools never quits it for you), or run in your own worktree` };
+                }
+                if (editors.length)
+                    say(`foreign:${editors[0].pid}`, `waiting for ${rec.project}: a Unity batch run no funtools job owns has it open (pid ${editors.map((p) => p.pid).join(', ')}); it is waited for, never stopped`);
+                else if (first && first.id !== rec.id)
+                    say(`line:${first.id}`, `waiting for ${rec.project}: ${line.findIndex((t) => t.id === rec.id)} ahead in line (next: session ${first.session}, \`${first.command}\`)`);
+                else {
+                    if (!(await takeDir(pdir)))
+                        continue;
+                    await writeJson(join(pdir, 'owner.json'), rec);
+                    break;
+                }
+            }
+            if (timedOut())
+                return { ok: false, code: 'timed_out', message: `gave up after ${Math.round((d.now() - start) / 60000)} min waiting for ${rec.project}` };
+            await d.sleep(o.pollMs);
+        }
+        await dropTicket();
+        for (;;) {
+            const procs = await d.procs();
+            const now = d.now();
+            const s = await slots(d.root, procs, now, o.staleMs, watch, o.max, d.log);
+            const foreign = foreignBatch(procs, s.held);
+            const used = s.held.length + foreign.length;
+            if (used < o.max && s.free.length) {
+                const n = s.free[0];
+                if (!(await takeDir(slotDir(d.root, n))))
+                    continue;
+                await writeJson(join(slotDir(d.root, n), 'owner.json'), rec);
+                return { ok: true, held: heldOf(rec, n, pdir, d.root) };
+            }
+            const who = [...s.held.map((r) => `${r.project} (session ${r.session}, pid ${r.unity_pid ?? r.pid})`), ...foreign.map((p) => `pid ${p.pid} (not a funtools job)`)];
+            say(`cap:${who.join('|')}`, `waiting for a Unity slot: ${used} of ${o.max} running on this Mac — ${who.join('; ')}`);
+            {
+                const mine = await readLock(pdir, now);
+                if (mine.kind === 'held' && mine.rec.id === rec.id)
+                    await writeJson(join(pdir, 'owner.json'), { ...rec, progress_at: new Date(now).toISOString() });
+            }
+            if (timedOut()) {
+                await releaseDir(pdir, rec.id, d.now());
+                return { ok: false, code: 'timed_out', message: `gave up after ${Math.round((d.now() - start) / 60000)} min waiting for a Unity slot` };
+            }
+            await d.sleep(o.pollMs);
+        }
+    }
+    finally {
+        await dropTicket();
+    }
+}
+async function takeDir(dir) {
+    try {
+        await mkdir(dir);
+        return true;
+    }
+    catch (e) {
+        if (e.code === 'EEXIST')
+            return false;
+        throw e;
+    }
+}
+async function releaseDir(dir, id, now) {
+    const st = await readLock(dir, now);
+    if (st.kind === 'held' && st.rec.id === id)
+        await reclaim(dir, id, now);
+}
+function heldOf(rec, slot, pdir, root) {
+    let current = { ...rec };
+    const sdir = slotDir(root, slot);
+    return {
+        project: rec.project,
+        slot,
+        get rec() { return current; },
+        update: async (patch) => {
+            current = { ...current, ...patch };
+            for (const dir of [pdir, sdir]) {
+                const st = await readLock(dir, Date.now());
+                if (st.kind === 'held' && st.rec.id === rec.id)
+                    await writeJson(join(dir, 'owner.json'), current);
+            }
+        },
+        release: async () => {
+            await releaseDir(sdir, rec.id, Date.now());
+            await releaseDir(pdir, rec.id, Date.now());
+        },
+    };
+}
+export async function view(root, procs, now, staleMs) {
+    let names = [];
+    try {
+        names = await readdir(join(root, 'projects'));
+    }
+    catch { }
+    const keys = [...new Set(names.map((n) => n.replace(/\.(lock|queue)$/, '')).filter((n) => !/\.stale-/.test(n)))].sort();
+    const projects = [];
+    for (const key of keys) {
+        const st = await readLock(join(root, 'projects', `${key}.lock`), now);
+        const holder = st.kind === 'held' ? st.rec : null;
+        const line = await tickets(join(root, 'projects', `${key}.queue`), procs);
+        const project = holder?.project ?? '';
+        if (!holder && !line.length)
+            continue;
+        projects.push({ project, key, holder, verdict: holder ? await judge(holder, procs, now, staleMs) : null, waiting: line, editors: project ? unityOn(procs, projectNames(project)) : [] });
+    }
+    const slotsHeld = [];
+    let snames = [];
+    try {
+        snames = await readdir(join(root, 'slots'));
+    }
+    catch { }
+    for (const n of snames) {
+        const m = /^(\d+)\.lock$/.exec(n);
+        if (!m)
+            continue;
+        const st = await readLock(join(root, 'slots', n), now);
+        if (st.kind === 'held')
+            slotsHeld.push({ slot: Number(m[1]), rec: st.rec });
+    }
+    slotsHeld.sort((a, b) => a.slot - b.slot);
+    return { projects, slots: slotsHeld, foreign: foreignBatch(procs, slotsHeld.map((s) => s.rec)) };
+}
+export async function queueHolds(root, project, procs, now, staleMs) {
+    const st = await readLock(lockDir(root, project), now);
+    if (st.kind === 'unwritten')
+        return 'its funtools lock is being taken';
+    if (st.kind === 'held') {
+        const v = await judge(st.rec, procs, now, staleMs);
+        if (v.live)
+            return `its funtools lock is held (${holderLine(st.rec, now)})`;
+    }
+    const line = await tickets(queueDir(root, project), procs);
+    if (line.length)
+        return `${line.length} job(s) wait for it in the funtools queue`;
+    return null;
+}

package/dist/unity/run.js

@@ -0,0 +1,172 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { mkdir, readFile, stat } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { subtreeCpu } from "../machine/procs.js";
+import { acquire, newJobId } from "./queue.js";
+export const NOT_RUN = 125;
+export const HUB_EDITORS = '/Applications/Unity/Hub/Editor';
+export const isUnityProject = (dir) => existsSync(join(dir, 'ProjectSettings', 'ProjectVersion.txt'));
+export function editorVersion(project) {
+    try {
+        return /m_EditorVersion:\s*(\S+)/.exec(readFileSync(join(project, 'ProjectSettings', 'ProjectVersion.txt'), 'utf8'))?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function findUnity(project, flag, env = process.env, hub = HUB_EDITORS) {
+    const given = flag ?? env.FUNTOOLS_UNITY ?? env.UNITY_PATH;
+    if (given)
+        return existsSync(given) ? { bin: given } : { error: `no Unity at ${given}` };
+    const v = editorVersion(project);
+    if (!v)
+        return { error: `${project} has no ProjectSettings/ProjectVersion.txt (not a Unity project)` };
+    const bin = join(hub, v, 'Unity.app', 'Contents', 'MacOS', 'Unity');
+    if (existsSync(bin))
+        return { bin };
+    let have = [];
+    try {
+        have = readdirSync(hub).filter((n) => !n.startsWith('.'));
+    }
+    catch { }
+    return { error: `the project wants Unity ${v}, which is not installed in ${hub}${have.length ? ` (installed: ${have.join(', ')})` : ''} — install it with Unity Hub, or pass --unity <path to the Unity binary>` };
+}
+const argIndex = (args, name) => args.findIndex((a) => a.toLowerCase() === name.toLowerCase());
+export function prepareArgs(unityArgs, o) {
+    const args = [...unityArgs];
+    const pi = argIndex(args, '-projectPath');
+    let project = o.project ? resolve(o.cwd, o.project) : null;
+    if (pi >= 0) {
+        const named = args[pi + 1];
+        if (!named || named.startsWith('-'))
+            return { error: '-projectPath needs a folder' };
+        const abs = resolve(o.cwd, named);
+        if (project && abs !== project)
+            return { error: `-projectPath ${named} and --project ${o.project} name different projects` };
+        project = abs;
+        args.splice(pi, 2);
+    }
+    project ??= resolve(o.cwd);
+    const out = ['-projectPath', project];
+    if (argIndex(args, '-batchmode') < 0)
+        out.push('-batchmode');
+    if (argIndex(args, '-quit') < 0 && argIndex(args, '-runTests') < 0 && !o.noQuit)
+        out.push('-quit');
+    if (argIndex(args, '-runTests') >= 0 && argIndex(args, '-quit') >= 0)
+        return { error: '-runTests with -quit: the test runner exits by itself, and -quit stops it before the results are written — drop -quit' };
+    let log;
+    const li = argIndex(args, '-logFile');
+    if (li >= 0) {
+        const v = args[li + 1];
+        log = v === undefined || v.startsWith('-') ? null : v === '-' ? null : resolve(o.cwd, v);
+        if (log)
+            args[li + 1] = log;
+    }
+    else {
+        log = o.log ? resolve(o.cwd, o.log) : join(project, 'Logs', `funtools-unity-${o.stamp}-${o.id}.log`);
+        out.push('-logFile', log);
+    }
+    return { project, args: [...out, ...args], log };
+}
+export function logErrors(text, limit = 40) {
+    const hit = /error CS\d+|Exception|Error building Player|BuildFailedException|Scripts have compiler errors|Aborting batchmode|executeMethod method .* threw|Couldn't set project path|another Unity instance is running/i;
+    const out = [];
+    for (const l of text.split('\n')) {
+        const t = l.trim();
+        if (t && hit.test(t) && !/^UnityEngine\.|^\s*at /.test(t) && !out.includes(t))
+            out.push(t);
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}
+export const spawnUnity = (bin, args) => {
+    const c = spawn(bin, args, { stdio: ['ignore', 'inherit', 'inherit'] });
+    return {
+        pid: c.pid ?? -1,
+        exit: new Promise((ok) => {
+            c.on('error', () => ok(NOT_RUN));
+            c.on('exit', (code, signal) => ok(code ?? (signal ? 128 + ({ SIGINT: 2, SIGTERM: 15, SIGKILL: 9 }[signal] ?? 1) : 1)));
+        }),
+    };
+};
+const stampOf = (ms) => new Date(ms).toISOString().replace(/[-:]/g, '').replace(/\..*$/, '').replace('T', '-');
+export async function unityRun(o, d) {
+    const id = newJobId();
+    const prep = prepareArgs(o.unityArgs, { project: o.project, cwd: o.cwd, log: o.log, noQuit: o.noQuit, id, stamp: stampOf(d.now()) });
+    if ('error' in prep)
+        return { code: NOT_RUN, message: prep.error };
+    if (!isUnityProject(prep.project))
+        return { code: NOT_RUN, message: `${prep.project} is not a Unity project (no ProjectSettings/ProjectVersion.txt) — run from the project, or pass --project <dir>` };
+    const found = findUnity(prep.project, o.unity, d.env);
+    if ('error' in found)
+        return { code: NOT_RUN, message: found.error };
+    const rec = {
+        id, project: prep.project, pid: d.self, session: d.session, cwd: o.cwd,
+        command: ['unity', ...prep.args.filter((a, i, all) => !['-projectPath', '-logFile'].includes(a) && !['-projectPath', '-logFile'].includes(all[i - 1]))].join(' ').slice(0, 300),
+        since: new Date(d.now()).toISOString(), log: prep.log,
+    };
+    const got = await acquire(rec, o.queue, d);
+    if (!got.ok)
+        return { code: NOT_RUN, project: prep.project, message: got.message };
+    const held = got.held;
+    let child = null;
+    const onSignal = (sig) => {
+        if (!child)
+            void held.release().finally(() => process.exit(128 + (sig === 'SIGINT' ? 2 : 15)));
+        else {
+            d.log(`funtools stopped; Unity (pid ${child.pid}) keeps the lock on ${prep.project} until it exits`);
+            process.exit(128 + (sig === 'SIGINT' ? 2 : 15));
+        }
+    };
+    const real = d.self === process.pid;
+    if (real) {
+        process.once('SIGINT', onSignal);
+        process.once('SIGTERM', onSignal);
+    }
+    try {
+        if (prep.log)
+            await mkdir(dirname(prep.log), { recursive: true });
+        const since = new Date(d.now()).toISOString();
+        await held.update({ since });
+        d.log(`unity: ${prep.project} (slot ${held.slot + 1})${prep.log ? `, log ${prep.log}` : ''}`);
+        child = d.spawn(found.bin, prep.args);
+        await held.update({ unity_pid: child.pid, progress_at: since });
+        let done = false;
+        const exit = child.exit.then((c) => { done = true; return c; });
+        let mark = { log: -1, cpu: -1 };
+        while (!done) {
+            await Promise.race([exit, d.beat(d.heartbeatMs)]);
+            if (done)
+                break;
+            const procs = await d.procs();
+            const cpu = subtreeCpu(procs, [child.pid]);
+            let size = 0;
+            try {
+                size = prep.log ? (await stat(prep.log)).size : 0;
+            }
+            catch { }
+            if (size !== mark.log || cpu >= mark.cpu + 1) {
+                mark = { log: size, cpu };
+                await held.update({ progress_at: new Date(d.now()).toISOString() });
+            }
+        }
+        const code = await exit;
+        let errors = [];
+        if (prep.log) {
+            try {
+                errors = logErrors(await readFile(prep.log, 'utf8'));
+            }
+            catch { }
+        }
+        return { code, project: prep.project, log: prep.log, errors };
+    }
+    finally {
+        if (real) {
+            process.off('SIGINT', onSignal);
+            process.off('SIGTERM', onSignal);
+        }
+        await held.release();
+    }
+}

package/dist/update.js

@@ -0,0 +1,111 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const PACKAGE = '@funpixel/tools';
+const DAY_MS = 24 * 60 * 60 * 1000;
+export function cachePath(env = process.env, platform = process.platform) {
+    const base = env.XDG_CONFIG_HOME || (platform === 'win32' && env.APPDATA) || join(homedir(), '.config');
+    return join(base, 'funpixel', 'funtools-update.json');
+}
+export function currentVersion() {
+    const pkg = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+    try {
+        return String(JSON.parse(readFileSync(pkg, 'utf8')).version);
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+export const packageDir = () => join(dirname(fileURLToPath(import.meta.url)), '..');
+export function checkoutCommit(dir = packageDir(), git = (args) => {
+    const r = spawnSync('git', ['-C', dir, ...args], { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'] });
+    return r.status === 0 ? r.stdout : null;
+}) {
+    if (git(['ls-files', '--error-unmatch', 'package.json']) === null)
+        return null;
+    return git(['rev-parse', '--short=9', 'HEAD'])?.trim() || null;
+}
+export function versionLine(commit = checkoutCommit()) {
+    return commit ? `${currentVersion()} (${commit})` : currentVersion();
+}
+const registry = (env) => (env.FUNTOOLS_REGISTRY || env.npm_config_registry || 'https://registry.npmjs.org').replace(/\/$/, '');
+export function newer(a, b) {
+    if (!a || !/^\d+\.\d+\.\d+$/.test(a))
+        return false;
+    const pa = a.split('.').map(Number), pb = b.split(/[.-]/).slice(0, 3).map(Number);
+    for (let i = 0; i < 3; i++)
+        if (pa[i] !== pb[i])
+            return pa[i] > (pb[i] || 0);
+    return false;
+}
+export function wanted(argv, env = process.env, tty = process.stderr.isTTY === true) {
+    if (env.FUNTOOLS_NO_UPDATE_CHECK || env.NO_UPDATE_NOTIFIER || env.CI)
+        return false;
+    if (argv.includes('--json') || argv.length === 0 || argv[0] === '--help' || argv[0] === '-h')
+        return false;
+    return tty;
+}
+function read(path) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export const refreshScript = (url, path, previous) => `
+const fs = require('node:fs');
+fetch(${JSON.stringify(url)}, { signal: AbortSignal.timeout(3000), headers: { accept: 'application/json' } })
+  .then((r) => (r.ok ? r.json() : null))
+  .then((j) => {
+    const latest = j && typeof j.version === 'string' ? j.version : ${JSON.stringify(previous)};
+    fs.writeFileSync(${JSON.stringify(path)}, JSON.stringify({ checked_at: Date.now(), latest }));
+  })
+  .catch(() => {});
+`;
+export function startUpdateCheck(argv, env = process.env, now = Date.now(), tty) {
+    try {
+        if (!wanted(argv, env, tty))
+            return null;
+        const path = cachePath(env);
+        const cache = read(path);
+        if (!cache || now - cache.checked_at > DAY_MS) {
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, JSON.stringify({ checked_at: now, latest: cache?.latest ?? null }));
+            const url = `${registry(env)}/${PACKAGE}/latest`;
+            spawn(process.execPath, ['-e', refreshScript(url, path, cache?.latest ?? null)], { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+        }
+        const current = currentVersion();
+        return cache && newer(cache.latest, current)
+            ? `funtools ${cache.latest} is out (you have ${current}) — ${selfUpdateCommand()}; FUNTOOLS_NO_UPDATE_CHECK=1 turns this notice off`
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function selfUpdateCommand(here = fileURLToPath(import.meta.url), cwd = process.cwd()) {
+    const parts = here.split(sep);
+    if (parts.includes('_npx'))
+        return `run \`npx ${PACKAGE}@latest\``;
+    const nm = parts.lastIndexOf('node_modules');
+    if (nm < 0)
+        return 'this is a source checkout: `git pull`, then `npm ci` in libs/funpixel-tools';
+    const project = parts.slice(0, nm).join(sep);
+    const local = project === cwd || existsSync(join(project, 'package.json')) && cwd.startsWith(project + sep);
+    return local ? `\`npm install --save-dev ${PACKAGE}@latest\`` : `\`npm install --global ${PACKAGE}@latest\``;
+}
+export async function latestNow(env = process.env) {
+    try {
+        const r = await fetch(`${registry(env)}/${PACKAGE}/latest`, { signal: AbortSignal.timeout(3000), headers: { accept: 'application/json' } });
+        if (!r.ok)
+            return null;
+        const j = (await r.json());
+        return typeof j.version === 'string' ? j.version : null;
+    }
+    catch {
+        return null;
+    }
+}