@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/review/model.js

@@ -0,0 +1,348 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { decodePng } from "../look/png.js";
+import { found, together, unseen } from "./media.js";
+const JSON_CHUNK = 0x4e4f534a;
+const BIN_CHUNK = 0x004e4942;
+export const EDGE_MAX_TRIANGLES = 2_000_000;
+export function readGltf(path) {
+    const bytes = readFileSync(path);
+    let json, bin = null;
+    if (bytes.subarray(0, 4).toString('latin1') === 'glTF') {
+        if (bytes.length < 20)
+            throw new Error('a GLB shorter than its header');
+        if (bytes.readUInt32LE(4) !== 2)
+            throw new Error(`glTF version ${bytes.readUInt32LE(4)}, not 2`);
+        const total = bytes.readUInt32LE(8);
+        if (total > bytes.length)
+            throw new Error(`a GLB cut short: ${bytes.length} of ${total} bytes`);
+        let o = 12;
+        while (o + 8 <= total) {
+            const len = bytes.readUInt32LE(o), type = bytes.readUInt32LE(o + 4);
+            if (o + 8 + len > total)
+                throw new Error('a GLB chunk runs past the end');
+            const chunk = bytes.subarray(o + 8, o + 8 + len);
+            if (type === JSON_CHUNK && json === undefined)
+                json = JSON.parse(chunk.toString('utf8'));
+            else if (type === BIN_CHUNK && !bin)
+                bin = chunk;
+            o += 8 + len + ((4 - (len % 4)) % 4);
+        }
+        if (json === undefined)
+            throw new Error('the GLB has no JSON chunk');
+    }
+    else {
+        const text = bytes.toString('utf8').trimStart();
+        if (!text.startsWith('{'))
+            throw new Error('neither a GLB nor glTF JSON');
+        json = JSON.parse(text);
+    }
+    if (!json || typeof json !== 'object')
+        throw new Error('the glTF JSON is not an object');
+    const bufferErrors = [];
+    const buffers = (Array.isArray(json.buffers) ? json.buffers : []).map((b, i) => {
+        if (typeof b?.uri !== 'string')
+            return i === 0 ? bin : null;
+        const got = uriBytes(b.uri, path);
+        if (!got.bytes) {
+            bufferErrors.push(`buffer ${i}: ${got.error}`);
+            return null;
+        }
+        if (typeof b.byteLength === 'number' && got.bytes.length < b.byteLength)
+            bufferErrors.push(`buffer ${i}: ${got.bytes.length} of ${b.byteLength} bytes`);
+        return got.bytes;
+    });
+    return { path, json, buffers, bufferErrors };
+}
+function uriBytes(uri, from) {
+    if (uri.startsWith('data:')) {
+        const comma = uri.indexOf(',');
+        if (comma < 0)
+            return { error: 'a data: URI with no data' };
+        return { bytes: /;base64$/i.test(uri.slice(0, comma)) ? Buffer.from(uri.slice(comma + 1), 'base64') : Buffer.from(decodeURIComponent(uri.slice(comma + 1)), 'latin1') };
+    }
+    if (/^[a-z]+:\/\//i.test(uri))
+        return { error: `${uri} is on the network (not read)` };
+    let rel;
+    try {
+        rel = decodeURIComponent(uri);
+    }
+    catch {
+        rel = uri;
+    }
+    const p = join(dirname(from), rel);
+    if (!existsSync(p))
+        return { error: `${rel} is not beside the file` };
+    return { bytes: readFileSync(p) };
+}
+function viewBytes(g, vi) {
+    const v = g.json.bufferViews?.[vi];
+    if (!v)
+        return { error: `buffer view ${vi} does not exist` };
+    if (v.extensions?.EXT_meshopt_compression || v.extensions?.KHR_meshopt_compression)
+        return { compressed: true };
+    const buf = g.buffers[v.buffer];
+    if (!buf)
+        return { error: `buffer ${v.buffer} is missing` };
+    const off = v.byteOffset ?? 0, len = v.byteLength ?? 0;
+    if (off + len > buf.length)
+        return { error: `buffer view ${vi} runs past its buffer (${off + len} > ${buf.length})` };
+    return { bytes: buf.subarray(off, off + len) };
+}
+const SIZE = { 5120: 1, 5121: 1, 5122: 2, 5123: 2, 5125: 4, 5126: 4 };
+const COMPS = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT4: 16 };
+export function readAccessor(g, ai) {
+    const a = g.json.accessors?.[ai];
+    if (!a)
+        return { error: `accessor ${ai} does not exist` };
+    if (a.sparse)
+        return { error: 'a sparse accessor (not read here)' };
+    const comps = COMPS[a.type], size = SIZE[a.componentType];
+    if (!comps || !size)
+        return { error: `accessor ${ai} has an unknown type` };
+    const count = a.count ?? 0;
+    if (a.bufferView === undefined)
+        return { count, comps, get: () => 0, float: a.componentType === 5126 };
+    const vb = viewBytes(g, a.bufferView);
+    if (!vb.bytes)
+        return { error: vb.error, compressed: vb.compressed };
+    const stride = g.json.bufferViews[a.bufferView].byteStride || comps * size;
+    const base = a.byteOffset ?? 0;
+    const b = vb.bytes;
+    if (count > 0 && base + (count - 1) * stride + comps * size > b.length)
+        return { error: `accessor ${ai} runs past its buffer view` };
+    const read = {
+        5120: (o) => b.readInt8(o), 5121: (o) => b.readUInt8(o), 5122: (o) => b.readInt16LE(o),
+        5123: (o) => b.readUInt16LE(o), 5125: (o) => b.readUInt32LE(o), 5126: (o) => b.readFloatLE(o),
+    }[a.componentType];
+    return { count, comps, get: (i, c) => read(base + i * stride + c * size), float: a.componentType === 5126 };
+}
+const MAGIC = [
+    ['image/png', (b) => b.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))],
+    ['image/jpeg', (b) => b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff],
+    ['image/webp', (b) => b.subarray(0, 4).toString('latin1') === 'RIFF' && b.subarray(8, 12).toString('latin1') === 'WEBP'],
+    ['image/ktx2', (b) => b.subarray(1, 7).toString('latin1') === 'KTX 20'],
+    ['image/avif', (b) => b.subarray(4, 12).toString('latin1') === 'ftypavif'],
+];
+export function imageProblem(bytes, mime) {
+    if (!bytes.length)
+        return 'no bytes';
+    const kind = MAGIC.find(([, is]) => is(bytes))?.[0];
+    if (!kind)
+        return 'not an image (no PNG, JPEG, WebP, KTX2 or AVIF signature)';
+    if (mime && mime !== kind)
+        return `${kind} bytes labelled ${mime}`;
+    if (kind === 'image/png') {
+        try {
+            decodePng(bytes);
+        }
+        catch (e) {
+            return `a PNG that does not decode (${e.message})`;
+        }
+    }
+    if (kind === 'image/jpeg' && !bytes.subarray(-16).includes(Buffer.from([0xff, 0xd9])))
+        return 'a JPEG cut short (no end marker)';
+    return null;
+}
+export function textureErrors(g) {
+    const errors = [];
+    const images = Array.isArray(g.json.images) ? g.json.images : [];
+    const textures = Array.isArray(g.json.textures) ? g.json.textures : [];
+    const imageName = (i) => (images[i]?.name ? `image ${i} (${images[i].name})` : `image ${i}`);
+    images.forEach((im, i) => {
+        let bytes, why;
+        if (typeof im?.bufferView === 'number') {
+            const v = viewBytes(g, im.bufferView);
+            bytes = v.bytes;
+            why = v.error;
+        }
+        else if (typeof im?.uri === 'string') {
+            const u = uriBytes(im.uri, g.path);
+            bytes = u.bytes;
+            why = u.error;
+        }
+        else
+            why = 'names no bytes (no bufferView, no uri)';
+        const p = bytes ? imageProblem(bytes, im?.mimeType) : null;
+        if (!bytes)
+            errors.push(`${imageName(i)} is missing: ${why}`);
+        else if (p)
+            errors.push(`${imageName(i)} is broken: ${p}`);
+    });
+    textures.forEach((t, i) => {
+        const ext = t?.extensions ?? {};
+        const sources = [t?.source, ...Object.values(ext).map((e) => e?.source)].filter((s) => s !== undefined);
+        if (!sources.length)
+            errors.push(`texture ${i} has no image`);
+        for (const s of sources)
+            if (typeof s !== 'number' || !images[s])
+                errors.push(`texture ${i} names image ${s}, which is not there`);
+    });
+    (Array.isArray(g.json.materials) ? g.json.materials : []).forEach((m, mi) => {
+        const walk = (o, path) => {
+            if (!o || typeof o !== 'object')
+                return;
+            for (const [k, v] of Object.entries(o)) {
+                if (/Texture$/.test(k) && v && typeof v === 'object' && 'index' in v) {
+                    const ix = v.index;
+                    if (typeof ix !== 'number' || !textures[ix])
+                        errors.push(`material ${m?.name ?? mi}: ${path}${k} names texture ${ix}, which is not there`);
+                }
+                else if (typeof v === 'object')
+                    walk(v, `${path}${k}.`);
+            }
+        };
+        walk(m, '');
+    });
+    return { errors: [...new Set(errors)], images: images.length, textures: textures.length };
+}
+export function meshGeometry(g, mi) {
+    const mesh = g.json.meshes?.[mi];
+    const name = mesh?.name ? String(mesh.name) : `mesh ${mi}`;
+    const out = { name, triangles: 0, open: 0, nonManifold: 0, nan: 0, degenerate: 0, read: true };
+    const prims = Array.isArray(mesh?.primitives) ? mesh.primitives : [];
+    const tris = [];
+    const ids = new Map();
+    let skipped;
+    for (const p of prims) {
+        const mode = p?.mode ?? 4;
+        if (mode !== 4)
+            continue;
+        const posIx = p?.attributes?.POSITION;
+        const counted = g.json.accessors?.[p.indices ?? posIx]?.count;
+        if (typeof counted === 'number')
+            out.triangles += Math.floor(counted / 3);
+        if (p?.extensions?.KHR_draco_mesh_compression) {
+            skipped = 'Draco-compressed geometry';
+            continue;
+        }
+        const pos = typeof posIx === 'number' ? readAccessor(g, posIx) : { error: 'no POSITION' };
+        if (!('get' in pos)) {
+            skipped = pos.compressed ? 'meshopt-compressed geometry' : pos.error;
+            continue;
+        }
+        const idx = p.indices !== undefined ? readAccessor(g, p.indices) : null;
+        if (idx && !('get' in idx)) {
+            skipped = idx.compressed ? 'meshopt-compressed geometry' : idx.error;
+            continue;
+        }
+        const n = idx ? idx.count : pos.count;
+        const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+        const P = new Array(pos.count * 3);
+        for (let i = 0; i < pos.count; i++)
+            for (let c = 0; c < 3; c++) {
+                const v = pos.get(i, c);
+                P[i * 3 + c] = v;
+                if (!Number.isFinite(v)) {
+                    out.nan++;
+                    continue;
+                }
+                lo[c] = Math.min(lo[c], v);
+                hi[c] = Math.max(hi[c], v);
+            }
+        const diag = Math.hypot(hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]) || 1;
+        const q = diag * 1e-6;
+        const local = new Array(pos.count);
+        for (let i = 0; i < pos.count; i++) {
+            const k = `${Math.round(P[i * 3] / q)},${Math.round(P[i * 3 + 1] / q)},${Math.round(P[i * 3 + 2] / q)}`;
+            let id = ids.get(k);
+            if (id === undefined) {
+                id = ids.size;
+                ids.set(k, id);
+            }
+            local[i] = id;
+        }
+        for (let t = 0; t + 2 < n; t += 3) {
+            const at = (j) => (idx ? idx.get(j, 0) : j);
+            const a = local[at(t)], b = local[at(t + 1)], c = local[at(t + 2)];
+            if (a === undefined || b === undefined || c === undefined) {
+                out.degenerate++;
+                continue;
+            }
+            tris.push([a, b, c]);
+        }
+    }
+    if (skipped && !tris.length)
+        return { ...out, read: false, why: skipped };
+    if (tris.length > EDGE_MAX_TRIANGLES)
+        return { ...out, read: false, why: `${tris.length} triangles: too many to count edges here` };
+    const N = ids.size + 1;
+    const edges = new Map();
+    for (const [a, b, c] of tris) {
+        if (a === b || b === c || a === c) {
+            out.degenerate++;
+            continue;
+        }
+        for (const [x, y] of [[a, b], [b, c], [c, a]]) {
+            const k = x < y ? x * N + y : y * N + x;
+            edges.set(k, (edges.get(k) ?? 0) + 1);
+        }
+    }
+    for (const n of edges.values()) {
+        if (n === 1)
+            out.open++;
+        else if (n > 2)
+            out.nonManifold++;
+    }
+    if (skipped)
+        out.why = `part not read: ${skipped}`;
+    return out;
+}
+function instances(g) {
+    const meshes = Array.isArray(g.json.meshes) ? g.json.meshes : [];
+    const nodes = Array.isArray(g.json.nodes) ? g.json.nodes : [];
+    const count = meshes.map(() => 0);
+    const scenes = Array.isArray(g.json.scenes) ? g.json.scenes : [];
+    const scene = scenes[g.json.scene ?? 0];
+    if (!scene)
+        return meshes.map(() => 1);
+    const seen = new Set();
+    const visit = (ni) => {
+        if (seen.has(ni) || !nodes[ni])
+            return;
+        seen.add(ni);
+        if (typeof nodes[ni].mesh === 'number' && count[nodes[ni].mesh] !== undefined)
+            count[nodes[ni].mesh]++;
+        for (const c of nodes[ni].children ?? [])
+            visit(c);
+        seen.delete(ni);
+    };
+    for (const r of scene.nodes ?? [])
+        visit(r);
+    return count.map((c) => c || 1);
+}
+export function reviewModel(file, rel, o = {}) {
+    const r = { file: rel, trade: 'model', errors: unseen('not measured'), overlaps: unseen('no honest overlap count for a model here (parts passing through each other need a render)'), seams: unseen('not measured for a model'), notes: [] };
+    let g;
+    try {
+        g = readGltf(file);
+    }
+    catch (e) {
+        r.errors = found([`not a model that reads: ${e.message}`]);
+        return r;
+    }
+    const tex = textureErrors(g);
+    const meshes = (Array.isArray(g.json.meshes) ? g.json.meshes : []).map((_, i) => meshGeometry(g, i));
+    const inst = instances(g);
+    const geometry = meshes.map((m) => {
+        if (!m.read)
+            return unseen(`${m.name}: ${m.why}`);
+        const p = [];
+        if (m.open)
+            p.push(`${m.name}: ${m.open} open edge(s) (a hole or a loose border)`);
+        if (m.nonManifold)
+            p.push(`${m.name}: ${m.nonManifold} non-manifold edge(s) (shared by 3+ faces)`);
+        if (m.nan)
+            p.push(`${m.name}: ${m.nan} NaN or infinite position value(s)`);
+        return found(p);
+    });
+    const triangles = meshes.reduce((s, m, i) => s + m.triangles * (inst[i] ?? 1), 0);
+    const budget = o.triangles !== undefined ? [found(triangles > o.triangles ? [`${triangles.toLocaleString('en-US')} triangles, over the budget of ${o.triangles.toLocaleString('en-US')} (${o.triangleSource ?? '--triangles'})`] : [])] : [];
+    const files = g.bufferErrors.length || tex.errors.length || tex.images || tex.textures ? found([...g.bufferErrors, ...tex.errors]) : unseen('no textures to read');
+    r.errors = together(files, ...(geometry.length ? geometry : [unseen('no meshes')]), ...budget);
+    r.notes.push(`${triangles.toLocaleString('en-US')} triangles in ${meshes.length} mesh(es)${o.triangles !== undefined ? ` (budget ${o.triangles.toLocaleString('en-US')})` : ' (no triangle budget set)'}, ${tex.textures} texture(s), ${tex.images} image(s)`);
+    for (const m of meshes)
+        if (m.why)
+            r.notes.push(`${m.name}: ${m.read ? m.why : `edges and positions not observed: ${m.why} (decode it first; the bench reads it)`}`);
+    return r;
+}

package/dist/review/picture.js

@@ -0,0 +1,113 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { decodePng } from "../look/png.js";
+import { onPaletteShare, PALETTE_LOW } from "../assets/palette-fit.js";
+import { found, hasFfmpeg, named, probe, round1, together, unseen } from "./media.js";
+import { pictureRule } from "./specs.js";
+import { BUSY_CEILING, CLIPPED_WARN, comfortRead } from "../score/comfort.js";
+export const TILE_RATIO = 3;
+export const TILE_MIN = 6;
+const DATA_MAP = 'normal|normals|nrm|rough|roughness|metal|metallic|metalness|ao|orm|height|depth|mask|disp|displacement|bump';
+export function pngHasAlpha(b) {
+    if (b.length < 33)
+        return false;
+    const type = b[25];
+    if (type === 4 || type === 6)
+        return true;
+    for (let o = 8; o + 8 <= b.length;) {
+        const len = b.readUInt32BE(o), name = b.subarray(o + 4, o + 8).toString('latin1');
+        if (name === 'tRNS')
+            return true;
+        if (name === 'IDAT' || name === 'IEND')
+            return false;
+        o += 12 + len;
+    }
+    return false;
+}
+export function decodePicture(file) {
+    const bytes = readFileSync(file);
+    if (/\.png$/i.test(file))
+        return { img: decodePng(bytes), alpha: pngHasAlpha(bytes) };
+    if (!hasFfmpeg())
+        throw new Error('no ffmpeg to decode it (PNG only without it)');
+    const p = probe(file);
+    if ('error' in p)
+        throw new Error(p.error);
+    const v = p.streams.find((s) => s.codec_type === 'video');
+    if (!v?.width || !v.height)
+        throw new Error('no picture in it');
+    const r = spawnSync('ffmpeg', ['-hide_banner', '-v', 'error', '-i', file, '-frames:v', '1', '-f', 'rawvideo', '-pix_fmt', 'rgba', 'pipe:1'], { timeout: 60_000, maxBuffer: v.width * v.height * 4 + 1_000_000 });
+    const out = r.stdout;
+    if (r.status !== 0 || !out || out.length < v.width * v.height * 4)
+        throw new Error((r.stderr?.toString() ?? '').trim().split('\n')[0] || 'ffmpeg could not decode it');
+    return { img: { width: v.width, height: v.height, data: new Uint8Array(out.subarray(0, v.width * v.height * 4)) }, alpha: /^(yuva|rgba|argb|bgra|abgr|ya|gbrap)/.test(v.pix_fmt ?? '') };
+}
+const allOpaque = (img) => { for (let i = 3; i < img.data.length; i += 4)
+    if (img.data[i] < 250)
+        return false; return true; };
+export function tileSeams(img) {
+    const { width: w, height: h, data: d } = img;
+    const px = (x, y) => (y * w + x) * 4;
+    const diff = (a, b) => (Math.abs(d[a] - d[b]) + Math.abs(d[a + 1] - d[b + 1]) + Math.abs(d[a + 2] - d[b + 2])) / 3;
+    const out = [];
+    if (w >= 4 && h >= 2) {
+        const col = (x0, x1) => { let s = 0; for (let y = 0; y < h; y++)
+            s += diff(px(x0, y), px(x1, y)); return s / h; };
+        const steps = Array.from({ length: Math.min(w - 1, 64) }, (_, i) => col(Math.floor((i * (w - 1)) / 64), Math.floor((i * (w - 1)) / 64) + 1)).sort((a, b) => a - b);
+        out.push({ axis: 'left↔right', jump: col(w - 1, 0), step: steps[Math.floor(steps.length / 2)] });
+    }
+    if (h >= 4 && w >= 2) {
+        const row = (y0, y1) => { let s = 0; for (let x = 0; x < w; x++)
+            s += diff(px(x, y0), px(x, y1)); return s / w; };
+        const steps = Array.from({ length: Math.min(h - 1, 64) }, (_, i) => row(Math.floor((i * (h - 1)) / 64), Math.floor((i * (h - 1)) / 64) + 1)).sort((a, b) => a - b);
+        out.push({ axis: 'top↔bottom', jump: row(h - 1, 0), step: steps[Math.floor(steps.length / 2)] });
+    }
+    return out.map((s) => ({ ...s, jump: round1(s.jump), step: round1(s.step) }));
+}
+export function reviewPicture(file, rel, o) {
+    const r = { file: rel, trade: 'picture', errors: unseen('not measured'), overlaps: unseen('a picture has nothing to overlap'), seams: unseen('not a tile (name it tile or seamless)'), notes: [] };
+    let pic;
+    try {
+        pic = decodePicture(file);
+    }
+    catch (e) {
+        const why = e.message;
+        r.errors = /no ffmpeg/.test(why) ? unseen(why) : found([`does not decode: ${why}`]);
+        r.seams = unseen('does not decode');
+        return r;
+    }
+    const { img } = pic;
+    r.notes.push(`${img.width}×${img.height}${pic.alpha ? ', alpha' : ''}`);
+    const rule = pictureRule(o.specs, rel);
+    const cf = comfortRead(img);
+    const tiring = [cf.busyness > BUSY_CEILING ? `busy over ${BUSY_CEILING}` : '', cf.clipped > CLIPPED_WARN ? `clipped over ${CLIPPED_WARN}%` : ''].filter(Boolean);
+    r.notes.push(`comfort: busyness ${cf.busyness}, ${cf.clipped}% clipped${tiring.length ? ` (warning: ${tiring.join(', ')}; fine for a target, tiring for a game frame)` : ''}`);
+    const alphaWhy = o.alpha === true ? '--alpha'
+        : rule?.alpha === true ? rule.from
+            : rule?.alpha === false ? null
+                : o.specs.alphaPaths.has(rel) ? 'assets/assets.json (a transparent item)'
+                    : named(rel, 'sprite|sprites|cutout|cutouts|cut-out|cut_out|transparent|keyed|alpha') ? 'its name' : null;
+    const alpha = [];
+    if (alphaWhy && !pic.alpha)
+        alpha.push(`no alpha channel, but a cut-out is expected (${alphaWhy})`);
+    else if (alphaWhy && allOpaque(img))
+        alpha.push(`its alpha is opaque everywhere: the background was never keyed (a cut-out, by ${alphaWhy})`);
+    const want = o.size ? { ...o.size, from: '--size' } : rule?.size ? { ...rule.size, from: rule.from } : null;
+    const size = want ? found(img.width === want.w && img.height === want.h ? [] : [`${img.width}×${img.height}, the spec is ${want.w}×${want.h} (${want.from})`]) : unseen('no size spec');
+    const pal = o.specs.palette;
+    const palette = !pal ? unseen('no palette in the project (design/palette.json, .gpl or .hex; funpixel.json review.palette)')
+        : named(rel, DATA_MAP) ? unseen('a data map (normal, roughness…): not held to the palette')
+            : (() => {
+                const share = onPaletteShare(img, pal.colours);
+                r.notes.push(`${share}% of its colour on the palette (${pal.from})`);
+                return found(share < PALETTE_LOW ? [`off the palette: ${share}% of its colour on it, under ${PALETTE_LOW}% (${pal.from})`] : []);
+            })();
+    if (!pal)
+        r.notes.push('palette: not observed (the project has none)');
+    r.errors = together(found(alpha), size, palette);
+    if (named(rel, 'tile|tiles|tileable|seamless|pattern')) {
+        const seams = tileSeams(img).filter((s) => s.jump > TILE_MIN && s.jump > TILE_RATIO * Math.max(s.step, 1));
+        r.seams = found(seams.map((s) => `does not tile ${s.axis}: the edges differ by ${s.jump}, ${round1(s.jump / Math.max(s.step, 1))}× the ordinary step (${s.step})`));
+    }
+    return r;
+}

package/dist/review/specs.js

@@ -0,0 +1,134 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { hexRgb, paletteOf, readGamePalette } from "../assets/palette-fit.js";
+import { readPixelArt } from "../assets/pixelart.js";
+import { readAssetManifest, targetOf } from "../assets/manifest.js";
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return undefined;
+} };
+export function sizeOf(v) {
+    if (typeof v === 'string') {
+        const m = /^\s*(\d+)\s*[x×]\s*(\d+)\s*$/i.exec(v);
+        return m ? { w: Number(m[1]), h: Number(m[2]) } : null;
+    }
+    if (Array.isArray(v) && v.length === 2 && v.every((n) => Number.isInteger(n) && n > 0))
+        return { w: v[0], h: v[1] };
+    if (v && typeof v === 'object' && Number.isInteger(v.w) && Number.isInteger(v.h))
+        return { w: v.w, h: v.h };
+    return null;
+}
+export function glob(pattern) {
+    const p = pattern.replace(/\\/g, '/').replace(/^\.\//, '');
+    let re = '';
+    for (let i = 0; i < p.length; i++) {
+        const c = p[i];
+        if (c === '*' && p[i + 1] === '*') {
+            const slash = p[i + 2] === '/';
+            re += slash ? '(?:.*/)?' : '.*';
+            i += slash ? 2 : 1;
+        }
+        else if (c === '*')
+            re += '[^/]*';
+        else if (c === '?')
+            re += '[^/]';
+        else
+            re += /[.+^${}()|[\]\\]/.test(c) ? `\\${c}` : c;
+    }
+    const rx = new RegExp(p.includes('/') ? `^${re}$` : `(^|/)${re}$`);
+    return (path) => rx.test(path.replace(/\\/g, '/'));
+}
+export function parsePalette(text, name) {
+    if (name.endsWith('.json')) {
+        const j = (() => { try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        } })();
+        const raw = j?.colours ?? j?.colors ?? j?.palette ?? j;
+        return paletteOf(Array.isArray(raw) ? raw.map((c) => (typeof c === 'object' && c ? c.hex ?? c : c)) : raw);
+    }
+    if (name.endsWith('.gpl')) {
+        return text.split('\n').flatMap((l) => { const m = /^\s*(\d{1,3})\s+(\d{1,3})\s+(\d{1,3})\b/.exec(l); return m ? [[Number(m[1]), Number(m[2]), Number(m[3])]] : []; });
+    }
+    return [...text.matchAll(/#?\b([0-9a-f]{6})\b/gi)].flatMap((m) => { const c = hexRgb(m[1]); return c ? [c] : []; });
+}
+export function readSpecs(root) {
+    const out = { pictures: [], models: [], triangles: null, palette: null, alphaPaths: new Set() };
+    const dir = join(root, 'design', 'specs');
+    if (existsSync(dir)) {
+        for (const f of readdirSync(dir).filter((n) => n.endsWith('.json')).sort()) {
+            const j = readJson(join(dir, f));
+            const from = `design/specs/${f}`;
+            const pics = Array.isArray(j) ? j : Array.isArray(j?.pictures) ? j.pictures : [];
+            for (const r of pics) {
+                const files = typeof r?.files === 'string' ? r.files : typeof r?.match === 'string' ? r.match : null;
+                if (!files)
+                    continue;
+                const size = sizeOf(r.size);
+                out.pictures.push({ files, ...(size ? { size } : {}), ...(typeof r.alpha === 'boolean' ? { alpha: r.alpha } : {}), from });
+            }
+            for (const r of Array.isArray(j?.models) ? j.models : []) {
+                const files = typeof r?.files === 'string' ? r.files : typeof r?.match === 'string' ? r.match : null;
+                if (files && Number.isInteger(r.triangles) && r.triangles > 0)
+                    out.models.push({ files, triangles: r.triangles, from });
+            }
+        }
+    }
+    const manifest = readJson(join(root, 'funpixel.json'));
+    const rv = manifest?.review;
+    if (Number.isInteger(rv?.triangles) && rv.triangles > 0)
+        out.triangles = { n: rv.triangles, from: 'funpixel.json review.triangles' };
+    const files = [...(typeof rv?.palette === 'string' ? [rv.palette] : []), ...['json', 'gpl', 'hex', 'txt'].map((e) => `design/palette.${e}`)];
+    for (const f of files) {
+        const p = join(root, f);
+        if (!existsSync(p))
+            continue;
+        const colours = (() => { try {
+            return parsePalette(readFileSync(p, 'utf8'), f);
+        }
+        catch {
+            return [];
+        } })();
+        if (colours.length) {
+            out.palette = { colours, from: f };
+            break;
+        }
+    }
+    if (!out.palette) {
+        const art = (() => { try {
+            return readPixelArt(root);
+        }
+        catch {
+            return null;
+        } })();
+        const inks = (art?.palette ?? []).flatMap((h) => { const c = hexRgb(h); return c ? [c] : []; });
+        if (inks.length)
+            out.palette = { colours: inks, from: 'funpixel.json pixelArt.palette' };
+    }
+    if (!out.palette) {
+        const g = readGamePalette(root);
+        if (g?.length)
+            out.palette = { colours: g, from: 'the game\'s palette (assets/style.json or funpixel.json metadata.palette)' };
+    }
+    try {
+        for (const it of readAssetManifest(root)) {
+            if (it.transparent === true || it.kind === 'sprite' || it.kind === 'pose' || it.kind === 'parts')
+                out.alphaPaths.add(targetOf(it).replace(/\\/g, '/'));
+        }
+    }
+    catch { }
+    return out;
+}
+export const pictureRule = (s, rel) => s.pictures.find((r) => glob(r.files)(rel));
+export function modelBudget(s, rel, flag) {
+    if (flag !== undefined)
+        return { n: flag, from: '--triangles' };
+    const r = s.models.find((m) => glob(m.files)(rel));
+    if (r)
+        return { n: r.triangles, from: r.from };
+    return s.triangles ?? undefined;
+}