@funpixel/tools 0.0.0-stage → 0.1.1

package/bench/handlers/views.py

@@ -0,0 +1,232 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""The fixed view sets and their cameras, shared by `render_views`,
+`apply_skin` and `apply_texture`.
+
+A camera here is orthographic and derived ONLY from the model: its bounds, and
+its head and hands (found from named bones, else from its shape). So the same
+model always gives the same cameras, and a verb that paints from marks made on
+`render_views`' pictures recomputes exactly the cameras those pictures came
+from — nothing about a camera is ever taken from a caller.
+
+Directions are the glTF convention after import (Blender -Y is the model's
+front). They are views, not anatomy: a model authored facing the other way
+gets "front" of its back, and the pictures show it.
+"""
+import numpy as np
+from mathutils import Vector
+
+from . import raster
+
+VIEW_SETS = {
+    "skin": ["front", "back", "left", "right", "face", "hand_l", "hand_r"],
+    "retexture": ["front", "back", "left", "right"],
+}
+# `fidelity`: the model squared to its principal axes, from every side and three heights, in
+# both orientations about its long axis (glTF axis signs are ambiguous) — the renders a set of
+# reference views is scored against (funtools fidelity). Ported from the owner's fidelity tools
+# (tools/fidelity/render_views.py with FID_ALIGN and FID_FLIP, as called by score_round.py): orthographic, 8 yaws x 3 heights x 2 orientations = 48 views.
+FIDELITY_YAWS = (0, 45, 90, 135, 180, 225, 270, 315)
+# 89, not 90: straight down leaves "up" undefined; the owner's renders used 89 too.
+FIDELITY_ELEVATIONS = (0, 25, 89)
+FIDELITY_ORIENTATIONS = ("n", "f")  # as squared; rolled 180 degrees about the long axis
+FIDELITY_SIZE = 512
+# Look direction and screen-up per whole-body view (Blender space).
+_DIRS = {
+    "front": ((0, 1, 0), (0, 0, 1)),
+    "back": ((0, -1, 0), (0, 0, 1)),
+    "left": ((-1, 0, 0), (0, 0, 1)),
+    "right": ((1, 0, 0), (0, 0, 1)),
+}
+KEY = np.array([1.0, 0.0, 1.0], dtype=np.float32)  # magenta backdrop
+GRID = 16
+
+
+class Model:
+    """Every mesh of a scene as flat arrays, in world space, at REST pose."""
+
+    def __init__(self, meshes):
+        pos, tris, uvs, owner, slot, normals = [], [], [], [], [], []
+        base = 0
+        self.objects = meshes
+        for oi, obj in enumerate(meshes):
+            me = obj.data
+            me.calc_loop_triangles()
+            n = len(me.vertices)
+            co = np.empty(n * 3, dtype=np.float64)
+            me.vertices.foreach_get("co", co)
+            co = co.reshape(-1, 3)
+            mw = np.array(obj.matrix_world, dtype=np.float64)
+            co = co @ mw[:3, :3].T + mw[:3, 3]
+            t = len(me.loop_triangles)
+            vi = np.empty(t * 3, dtype=np.int64)
+            me.loop_triangles.foreach_get("vertices", vi)
+            li = np.empty(t * 3, dtype=np.int64)
+            me.loop_triangles.foreach_get("loops", li)
+            mi = np.empty(t, dtype=np.int64)
+            me.loop_triangles.foreach_get("material_index", mi)
+            layer = me.uv_layers.active
+            if layer is not None:
+                uv = np.empty(len(me.loops) * 2, dtype=np.float64)
+                layer.data.foreach_get("uv", uv)
+                uvs.append(uv.reshape(-1, 2)[li].reshape(t, 3, 2))
+            else:
+                uvs.append(np.full((t, 3, 2), np.nan))
+            pos.append(co)
+            tris.append(vi.reshape(t, 3) + base)
+            owner.append(np.full(t, oi))
+            slot.append(mi)
+            base += n
+        self.pos = np.concatenate(pos) if pos else np.zeros((0, 3))
+        self.tris = np.concatenate(tris) if tris else np.zeros((0, 3), dtype=np.int64)
+        self.uv = np.concatenate(uvs) if uvs else np.zeros((0, 3, 2))
+        self.owner = np.concatenate(owner) if owner else np.zeros(0, dtype=np.int64)
+        self.slot = np.concatenate(slot) if slot else np.zeros(0, dtype=np.int64)
+        corners = self.pos[self.tris]
+        n = np.cross(corners[:, 1] - corners[:, 0], corners[:, 2] - corners[:, 0])
+        length = np.linalg.norm(n, axis=1, keepdims=True)
+        self.normal = n / np.maximum(length, 1e-12)
+        self.lo = self.pos.min(axis=0)
+        self.hi = self.pos.max(axis=0)
+        self.height = float(self.hi[2] - self.lo[2])
+
+
+def _bone_points(armature):
+    """Head and hand positions from bone NAMES, or None when the rig has none."""
+    if armature is None:
+        return None
+    mw = armature.matrix_world
+    head, hands = None, []
+    for b in armature.data.bones:
+        name = b.name.lower()
+        p = mw @ b.head_local
+        if "head" in name and "end" not in name and (head is None or p.z > head.z):
+            head = p
+        elif "hand" in name and not any(f in name for f in ("thumb", "index", "middle", "ring", "pinky", "finger")):
+            hands.append(p)
+    if head is None or len(hands) < 2:
+        return None
+    hands.sort(key=lambda p: p.x)
+    return head, hands[-1], hands[0]
+
+
+def _shape_points(model):
+    """Head: the top slab's centre. Hands: the outermost points at arm height."""
+    p, lo, hi, h = model.pos, model.lo, model.hi, model.height
+    top = p[p[:, 2] > hi[2] - 0.1 * h]
+    head = top.mean(axis=0)
+    band = p[(p[:, 2] > lo[2] + 0.3 * h) & (p[:, 2] < lo[2] + 0.85 * h)]
+    if len(band) == 0:
+        band = p
+    width = hi[0] - lo[0]
+    left = band[band[:, 0] > band[:, 0].max() - 0.07 * width].mean(axis=0)
+    right = band[band[:, 0] < band[:, 0].min() + 0.07 * width].mean(axis=0)
+    return Vector(head), Vector(left), Vector(right)
+
+
+def principal_axes(model, flip=False, roll=False):
+    """Rows: the model's longest axis (new X, length), smallest (new Y, depth), middle (new Z,
+    height), a right-handed frame; `flip` rolls it 180 degrees about the long axis, `roll` a
+    further 90 (FID_ROLL: a model deeper than it is tall squares onto its side, because
+    its middle axis is then not "up"). And the vertex centroid it turns about."""
+    c = model.pos.mean(axis=0)
+    _, v = np.linalg.eigh(np.cov((model.pos - c).T))  # ascending
+    r = np.stack([v[:, 2], v[:, 0], v[:, 1]])
+    if np.linalg.det(r) < 0:
+        r[1] *= -1
+    if flip:
+        r[1] *= -1
+        r[2] *= -1
+    if roll:
+        r = np.stack([r[0], r[2], -r[1]])
+    return r, c
+
+
+def fidelity_cameras(model, align=True, roll=False):
+    """The `fidelity` set: each camera is placed round the SQUARED model exactly as the owner's
+    renders were (yaw 0 looks along +Y of the squared frame, up is its +Z), then turned back into
+    the model's own space, so the model itself is never moved.
+
+    `align=False` (FID_ALIGN=0) keeps the model's own axes: for a model BUILT square to
+    them, which principal axes would tilt where its mass skews them (measured on the hand-built
+    Corer, 10 Oct 2026). Its two orientations are the same picture, so it is 24 views, not 48."""
+    out = []
+    for orient in FIDELITY_ORIENTATIONS if align else FIDELITY_ORIENTATIONS[:1]:
+        if align:
+            r, c = principal_axes(model, flip=orient == "f", roll=roll)
+        else:
+            r, c = np.eye(3), np.zeros(3)
+        sq = (model.pos - c) @ r.T
+        lo, hi = sq.min(axis=0), sq.max(axis=0)
+        centre_sq = (lo + hi) / 2
+        half = float(np.linalg.norm(hi - lo) / 2 * 1.1)  # as the owner's: ortho_scale = 2.2 x radius
+        for elev in FIDELITY_ELEVATIONS:
+            for yaw in FIDELITY_YAWS:
+                ay, ae = np.radians(yaw), np.radians(elev)
+                towards = np.array([np.sin(ay) * np.cos(ae), -np.cos(ay) * np.cos(ae), np.sin(ae)])
+                forward = -towards
+                # Blender's to_track_quat("-Z", "Y"): screen-up is +Z made square to the view.
+                up = np.array([0.0, 0.0, 1.0]) - forward[2] * forward
+                up /= np.linalg.norm(up)
+                out.append(dict(
+                    name="%s-e%02d-yaw%03d" % (orient, elev, yaw),
+                    forward=Vector(r.T @ forward), up=Vector(r.T @ up),
+                    centre=Vector(r.T @ centre_sq + c), half=max(half, 1e-3),
+                    yaw=yaw, elevation=elev, flipped=orient == "f"))
+    return out
+
+
+def cameras(model, view_set, armature):
+    """The view set's cameras: dicts of name, forward, up, centre, half-size."""
+    if view_set == "fidelity":
+        return fidelity_cameras(model), "axes"
+    if view_set not in VIEW_SETS:
+        raise ValueError("view_set must be one of fidelity, %s" % ", ".join(sorted(VIEW_SETS)))
+    lo, hi = Vector(model.lo), Vector(model.hi)
+    centre, ext = (lo + hi) / 2, hi - lo
+    whole = max(ext.x, ext.y, ext.z) * 0.54
+    located_by = ""
+    out = []
+    for name in VIEW_SETS[view_set]:
+        if name in _DIRS:
+            f, u = _DIRS[name]
+            out.append(dict(name=name, forward=Vector(f), up=Vector(u), centre=centre.copy(), half=whole))
+            continue
+        if not located_by:
+            points = _bone_points(armature)
+            located_by = "rig" if points else "shape"
+            head, hand_l, hand_r = points or _shape_points(model)
+        at = {"face": head, "hand_l": hand_l, "hand_r": hand_r}[name]
+        half = model.height * (0.12 if name == "face" else 0.07)
+        out.append(dict(name=name, forward=Vector((0, 1, 0)), up=Vector((0, 0, 1)),
+                        centre=Vector(at), half=max(half, 1e-3)))
+    return out, located_by or "none"
+
+
+def project(cam, points, size):
+    """World points (N, 3) to pixel x, pixel y (rows top-down) and depth."""
+    f = np.array(cam["forward"])
+    u = np.array(cam["up"])
+    r = np.cross(f, u)
+    d = points - np.array(cam["centre"])
+    px = ((d @ r) / cam["half"] + 1.0) * 0.5 * size
+    py = (1.0 - (d @ u) / cam["half"]) * 0.5 * size
+    return px, py, d @ f
+
+
+def depth_view(model, cam, size):
+    """The z-buffer, winning triangle and barycentrics of one view."""
+    px, py, dz = project(cam, model.pos, size)
+    xy = np.stack([px, py], axis=1)[model.tris]
+    return raster.rasterize(xy, dz[model.tris], size, size, want_bary=True)
+
+
+def visible(model, cam, size, zbuf, points, normals, tolerance):
+    """Which surface points this view SEES, their pixel index, and how square-on."""
+    px, py, dz = project(cam, points, size)
+    ix = np.clip(px.astype(np.int64), 0, size - 1)
+    iy = np.clip(py.astype(np.int64), 0, size - 1)
+    flat = iy * size + ix
+    facing = -(normals @ np.array(cam["forward"]))
+    inside = (px >= 0) & (px < size) & (py >= 0) & (py < size)
+    seen = inside & (facing > 0.1) & (dz <= zbuf[flat] + tolerance)
+    return seen, flat, facing

package/dist/api/generated/openapi.js

@@ -0,0 +1 @@
+export {};

package/dist/api/http.js

@@ -0,0 +1,71 @@
+import { apiKey, apiUrl } from "../keys/store.js";
+export const apiBase = () => apiUrl().replace(/\/$/, '');
+export class ApiError extends Error {
+    status;
+    code;
+    body;
+    constructor(status, code, message, body = {}) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.body = body;
+    }
+}
+export const realSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const MAX_WAIT_MS = 60_000;
+export function apiOptions(over = {}) {
+    const key = over.key ?? apiKey();
+    if (!key)
+        return null;
+    return { base: apiBase(), key, sleep: realSleep, retries: 4, ...over };
+}
+export function backoffMs(attempt, retryAfter) {
+    const floor = retryAfter && /^\d+$/.test(retryAfter.trim()) ? Number(retryAfter) * 1000 : 0;
+    return Math.min(MAX_WAIT_MS, Math.max(floor, 500 * 2 ** attempt));
+}
+const RETRIED_CODES = new Set(['rate_limited', 'too_many_streams']);
+async function refusal(res) {
+    const text = await res.text().catch(() => '');
+    let body = {};
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        body = { error: text.slice(0, 200) };
+    }
+    const code = typeof body.code === 'string' ? body.code : `http_${res.status}`;
+    const message = typeof body.error === 'string' && body.error ? body.error : `HTTP ${res.status}`;
+    return new ApiError(res.status, code, message, body);
+}
+export async function send(api, method, path, init = {}) {
+    const headers = { Authorization: `Bearer ${api.key}`, ...init.headers };
+    if (init.body !== undefined)
+        headers['Content-Type'] = 'application/json';
+    for (let attempt = 0;; attempt++) {
+        let res;
+        try {
+            res = await fetch(`${api.base}${path}`, { method, headers, body: init.body === undefined ? undefined : JSON.stringify(init.body) });
+        }
+        catch (e) {
+            if (attempt >= api.retries)
+                throw new ApiError(0, 'network', `could not reach ${api.base}: ${e instanceof Error ? e.message : String(e)}`);
+            const ms = backoffMs(attempt, null);
+            api.onWait?.('the connection failed', ms);
+            await api.sleep(ms);
+            continue;
+        }
+        if (res.ok)
+            return res;
+        const err = await refusal(res);
+        const retryable = (res.status === 429 && RETRIED_CODES.has(err.code)) || res.status >= 500;
+        if (!retryable || attempt >= api.retries)
+            throw err;
+        const ms = backoffMs(attempt, res.headers.get('retry-after'));
+        api.onWait?.(res.status === 429 ? `rate limited (${err.code})` : `the server answered ${res.status}`, ms);
+        await api.sleep(ms);
+    }
+}
+export async function sendJson(api, method, path, init) {
+    const res = await send(api, method, path, init);
+    return { status: res.status, json: (await res.json()) };
+}

package/dist/api/jobs.js

@@ -0,0 +1,94 @@
+import { ApiError, backoffMs, send, sendJson } from "./http.js";
+export const TERMINAL = ['succeeded', 'failed', 'cancelled'];
+export const estimate = (api, tool, input) => sendJson(api, 'POST', `/v1/tools/${tool}/estimate`, { body: input }).then((r) => r.json);
+export async function submit(api, tool, input, opts) {
+    const body = opts.confirm ? { ...input, confirm_cost: true } : input;
+    const r = await sendJson(api, 'POST', `/v1/tools/${tool}`, { body, headers: { 'Idempotency-Key': opts.idempotencyKey } });
+    return { job: r.json, replay: r.status === 200 };
+}
+export const getJob = (api, id, waitSecs = 0) => sendJson(api, 'GET', `/v1/jobs/${encodeURIComponent(id)}${waitSecs ? `?wait=${waitSecs}` : ''}`).then((r) => r.json);
+export function listJobs(api, q = {}) {
+    const qs = new URLSearchParams();
+    for (const [k, v] of Object.entries(q))
+        if (v !== undefined)
+            qs.set(k, String(v));
+    const tail = qs.toString() ? `?${qs}` : '';
+    return sendJson(api, 'GET', `/v1/jobs${tail}`).then((r) => r.json);
+}
+export async function* readSse(body) {
+    const decoder = new TextDecoder();
+    let buf = '', event = '', id = '', data = [];
+    for await (const chunk of body) {
+        buf += decoder.decode(chunk, { stream: true });
+        let nl;
+        while ((nl = buf.search(/\r\n|\n|\r/)) >= 0) {
+            const line = buf.slice(0, nl);
+            buf = buf.slice(nl + (buf.startsWith('\r\n', nl) ? 2 : 1));
+            if (line === '') {
+                if (data.length)
+                    yield { event: event || 'message', id, data: data.join('\n') };
+                event = '';
+                data = [];
+                continue;
+            }
+            if (line.startsWith(':'))
+                continue;
+            const colon = line.indexOf(':');
+            const field = colon < 0 ? line : line.slice(0, colon);
+            const value = colon < 0 ? '' : line.slice(colon + 1).replace(/^ /, '');
+            if (field === 'event')
+                event = value;
+            else if (field === 'data')
+                data.push(value);
+            else if (field === 'id')
+                id = value;
+        }
+    }
+}
+const MAX_RECONNECTS = 8;
+const POLL_WAIT_SECS = 60;
+export async function followJob(api, id, onEvent = () => { }, after = 0) {
+    let last = after;
+    for (let attempt = 0; attempt <= MAX_RECONNECTS; attempt++) {
+        let res;
+        try {
+            res = await send({ ...api, retries: 2 }, 'GET', `/v1/jobs/${encodeURIComponent(id)}/events`, {
+                headers: { Accept: 'text/event-stream', ...(last ? { 'Last-Event-ID': String(last) } : {}) },
+            });
+        }
+        catch (e) {
+            if (e instanceof ApiError && e.status >= 400 && e.status < 500 && e.status !== 429)
+                throw e;
+            break;
+        }
+        try {
+            for await (const ev of readSse(res.body)) {
+                const seq = Number(ev.id);
+                if (Number.isInteger(seq) && seq <= last)
+                    continue;
+                if (Number.isInteger(seq))
+                    last = seq;
+                let payload = {};
+                try {
+                    payload = JSON.parse(ev.data);
+                }
+                catch { }
+                onEvent({ name: ev.event, seq, data: payload });
+                if (TERMINAL.includes(ev.event)) {
+                    const job = payload.job;
+                    return job && typeof job === 'object' ? job : await getJob(api, id);
+                }
+            }
+        }
+        catch {
+        }
+        const ms = backoffMs(attempt, null);
+        api.onWait?.(`the event stream dropped after event ${last}; resuming`, ms);
+        await api.sleep(ms);
+    }
+    for (;;) {
+        const job = await getJob(api, id, POLL_WAIT_SECS);
+        if (TERMINAL.includes(job.status))
+            return job;
+    }
+}

package/dist/assets/bakeoff.js

@@ -0,0 +1,61 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { decodePng } from "../look/png.js";
+import { identityFacts } from "../cast/measure.js";
+import { findBench, ENTRYPOINT, refusal } from "../model/bench.js";
+import { findBlender, runVerb } from "../model/blender.js";
+export const BAKEOFF_WEIGHTS = { silhouette: 0.65, colour: 0.35 };
+export const BAKEOFF_TIE = 0.03;
+export function scoreView(master, front) {
+    const f = identityFacts(master, front, 'same');
+    if (f.iou === null || f.palette === null)
+        return { score: null, iou: null, palette: null, verdict: f.verdict, why: f.why };
+    const score = Math.round((BAKEOFF_WEIGHTS.silhouette * f.iou + BAKEOFF_WEIGHTS.colour * (f.palette / 100)) * 1000) / 1000;
+    return { score, iou: f.iou, palette: f.palette, verdict: f.verdict, why: f.why };
+}
+export async function bakeoff(master, candidates, render, outRoot) {
+    const out = [];
+    for (const c of candidates) {
+        const dir = join(outRoot, `d${c.draw}`);
+        const views = await render(c.file, dir);
+        if ('why' in views || !views.length) {
+            out.push({ draw: c.draw, file: c.file, score: null, iou: null, palette: null, verdict: 'not_observed', why: ['why' in views ? views.why : 'no view rendered'] });
+            continue;
+        }
+        const best = views.map((v) => ({ v, s: scoreView(master, v.img) })).reduce((a, b) => ((b.s.score ?? -1) > (a.s.score ?? -1) ? b : a));
+        out.push({ draw: c.draw, file: c.file, ...best.s, render: best.v.file });
+    }
+    return out.sort((a, b) => (b.score ?? -1) - (a.score ?? -1) || a.draw - b.draw);
+}
+export function bakeoffLines(ranked) {
+    const [a, b] = ranked;
+    const lines = ranked.map((c, i) => `${i ? '  ' : '✓ '}d${c.draw}: ${c.score === null ? `not observed (${c.why[0]})` : `score ${c.score} · silhouette ${Math.round((c.iou ?? 0) * 100)}% · colour ${c.palette}%`}`);
+    if (a?.score != null && b?.score != null && a.score - b.score < BAKEOFF_TIE)
+        lines.push(`a tie by the numbers (d${a.draw} ${a.score} vs d${b.draw} ${b.score}): kept d${a.draw}; \`judge identity\` or the owner decides between them`);
+    return lines;
+}
+export function localRenderer() {
+    const bench = findBench();
+    if ('missing' in bench)
+        return { why: bench.missing };
+    const blender = findBlender();
+    if ('missing' in blender)
+        return { why: blender.missing };
+    return async (glb, outDir) => {
+        const no = refusal(glb, readFileSync(glb));
+        if (no)
+            return { why: `${glb}: ${no}` };
+        mkdirSync(outDir, { recursive: true });
+        const a = await runVerb(blender.bin, join(bench.dir, ENTRYPOINT), 'render_turntable', { model_path: resolve(glb), format: 'glb', out_dir: resolve(outDir), frames: VIEWS, size: 256 });
+        if (!a.ok)
+            return { why: a.error };
+        return turntableViews(outDir);
+    };
+}
+export const VIEWS = 8;
+export function turntableViews(dir) {
+    if (!existsSync(dir))
+        return [];
+    const files = readdirSync(dir).filter((f) => f === 'front.png' || /^turn_\d+\.png$/.test(f)).sort((x, y) => (x === 'front.png' ? -1 : y === 'front.png' ? 1 : x.localeCompare(y)));
+    return files.map((f) => ({ file: join(dir, f), img: decodePng(readFileSync(join(dir, f))) }));
+}

package/dist/assets/counts.js

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { familyOf, MANIFEST, readAssetManifest, readStyle } from "./manifest.js";
+import { readLock, spend } from "./lock.js";
+import { planGen } from "./plan.js";
+export function assetCounts(game) {
+    if (!existsSync(join(game, MANIFEST)))
+        return null;
+    let items;
+    try {
+        items = readAssetManifest(game);
+    }
+    catch {
+        return null;
+    }
+    const lock = readLock(game);
+    let statuses;
+    try {
+        statuses = planGen(game, items, readStyle(game), lock).statuses;
+    }
+    catch {
+        return null;
+    }
+    const by_family = {};
+    let made = 0, failed = 0;
+    for (const [i, s] of statuses.entries()) {
+        const fam = familyOf(items[i]) ?? items[i].kind;
+        const f = (by_family[fam] ??= { planned: 0, made: 0 });
+        f.planned++;
+        const ok = s.state === 'fresh' || s.state === 'edited';
+        if (ok) {
+            made++;
+            f.made++;
+        }
+        if (s.state === 'rejected' || (s.state === 'missing' && lock.items[s.name]?.verdict === 'failed'))
+            failed++;
+    }
+    const off_model = items.filter((i) => lock.items[i.name]?.identity?.verdict === 'off_model').map((i) => i.name);
+    return { planned: items.length, made, todo: items.length - made, failed, off_model, by_family, credits: spend(lock).total, budget: readBudget(game)?.credits ?? null };
+}
+export function countsLine(c) {
+    return `assets ${c.made} of ${c.planned} made${c.failed ? ` · ${c.failed} failed` : ''}${c.off_model.length ? ` · ${c.off_model.length} off model (${c.off_model.slice(0, 4).join(', ')}${c.off_model.length > 4 ? ', …' : ''})` : ''} · ${c.credits}${c.budget !== null ? ` of ${c.budget}` : ''} credits`;
+}
+export function readBudget(game) {
+    try {
+        const b = JSON.parse(readFileSync(join(game, 'funpixel.json'), 'utf8'))?.assets?.budget;
+        return b && Number.isFinite(b.credits) && b.credits >= 0 ? b : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeBudget(game, credits, by, now = new Date()) {
+    const p = join(game, 'funpixel.json');
+    const j = existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : {};
+    const b = { credits, by, at: now.toISOString() };
+    j.assets = { ...(j.assets ?? {}), budget: b };
+    writeFileSync(p, JSON.stringify(j, null, 2) + '\n');
+    return b;
+}