@funpixel/tools 0.0.0-stage → 0.1.0

package/dist/gen/prompt-lint.js

@@ -0,0 +1,35 @@
+const MOOD = [
+    'dark', 'gloomy', 'grim', 'gritty', 'moody', 'bleak', 'scary', 'creepy', 'cute', 'childish', 'cartoonish', 'cartoony',
+    'realistic', 'photorealistic', 'photographic', 'busy', 'cluttered', 'noisy', 'blurry', 'muddy', 'muted', 'dull',
+    'saturated', 'oversaturated', 'neon', 'garish', 'bright', 'flat', 'shiny', 'glossy', 'plastic', 'generic', 'boring',
+    'sad', 'angry', 'violent', 'detailed', 'complex', 'messy', 'washed', 'pastel', 'grungy', 'retro', 'modern', 'futuristic',
+];
+const POSITIVE = {
+    dark: 'sunlit, high-key', gloomy: 'warm, sunlit', grim: 'hopeful, warm', gritty: 'clean, smooth', moody: 'even, daylit',
+    scary: 'friendly, round shapes', creepy: 'friendly, warm', cute: 'stern, angular', cartoonish: 'grounded proportions',
+    cartoony: 'grounded proportions', realistic: 'stylised, flat colour', photorealistic: 'painterly, flat colour', photographic: 'illustrated, flat colour',
+    busy: 'one clear subject, empty space round it', cluttered: 'sparse, one clear subject', noisy: 'clean flat shapes', blurry: 'crisp edges',
+    muddy: 'clean, separated colours', muted: 'saturated, bold colour', dull: 'vivid', saturated: 'muted, soft colour',
+    oversaturated: 'soft, natural colour', neon: 'earthy, natural colour', garish: 'harmonious, limited palette', bright: 'dim, low-key',
+    flat: 'volumetric shading', shiny: 'matte', glossy: 'matte', plastic: 'natural materials', detailed: 'simple shapes, few details',
+    complex: 'simple shapes', messy: 'tidy, ordered', pastel: 'deep, saturated colour', retro: 'contemporary', modern: 'period, aged',
+};
+const NEG = new RegExp(`\\b(?:no|not|non-|without|never|avoid|don'?t (?:make it|be))\\s*(?:too\\s+|overly\\s+|very\\s+|any\\s+)?(${MOOD.join('|')})\\b`, 'gi');
+const TRANSPARENT_WORDS = /\b(transparent|see-through|alpha)\s+(background|bg|backdrop)\b|\bon (a )?transparen(t|cy)\b|\bpng with transparency\b/i;
+export function promptLint(prompt, input = {}) {
+    const out = [];
+    const seen = new Set();
+    for (const m of prompt.matchAll(NEG)) {
+        const w = m[1].toLowerCase();
+        if (seen.has(w))
+            continue;
+        seen.add(w);
+        out.push(`"${m[0].trim()}" names the mood it wants to avoid, and the model hears "${w}": say what you want instead${POSITIVE[w] ? ` (e.g. "${POSITIVE[w]}")` : ''}. Leaving out a concrete thing ("no text", "no border") is fine`);
+    }
+    if (TRANSPARENT_WORDS.test(prompt)) {
+        out.push(input.transparent === true
+            ? 'the transparent flag already asks for alpha; the words "transparent background" get painted (a checkerboard, a pale plate): say "the subject alone on a plain field" instead'
+            : 'transparency is asked for in words, which the model paints: pass --transparent (native alpha) and say "the subject alone on a plain field"');
+    }
+    return out;
+}

package/dist/gen/record.js

@@ -0,0 +1,73 @@
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+export const RECORD = join('.funtools', 'assets.json');
+const sha256 = (b) => createHash('sha256').update(b).digest('hex');
+export function keyOf(game, path) {
+    const rel = relative(resolve(game), resolve(path));
+    return !rel || rel.startsWith('..') || isAbsolute(rel) ? null : rel.split('\\').join('/');
+}
+async function read(game) {
+    const p = join(resolve(game), RECORD);
+    if (!existsSync(p))
+        return {};
+    try {
+        return JSON.parse(await readFile(p, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+export async function recordAssets(game, jobId, tool, files) {
+    const records = await read(game);
+    let changed = false;
+    for (const f of files) {
+        const key = keyOf(game, f.path);
+        if (!key || !f.asset_id)
+            continue;
+        records[key] = { asset_id: f.asset_id, job_id: jobId, tool, sha256: sha256(f.bytes) };
+        changed = true;
+    }
+    if (!changed)
+        return;
+    const p = join(resolve(game), RECORD);
+    await mkdir(dirname(p), { recursive: true });
+    await writeFile(p, JSON.stringify(records, null, 2) + '\n');
+}
+export async function recordLocal(game, tool, generatedBy, files) {
+    const records = await read(game);
+    let changed = false;
+    for (const f of files) {
+        const key = keyOf(game, f.path);
+        if (!key)
+            continue;
+        records[key] = { asset_id: '', job_id: '', tool, sha256: sha256(f.bytes), generated_by: generatedBy };
+        changed = true;
+    }
+    if (!changed)
+        return;
+    const p = join(resolve(game), RECORD);
+    await mkdir(dirname(p), { recursive: true });
+    await writeFile(p, JSON.stringify(records, null, 2) + '\n');
+}
+function gameOf(path) {
+    for (let d = dirname(resolve(path));; d = dirname(d)) {
+        if (existsSync(join(d, RECORD)))
+            return d;
+        if (dirname(d) === d)
+            return null;
+    }
+}
+export async function assetOf(path) {
+    const game = gameOf(path);
+    const key = game && keyOf(game, path);
+    const rec = game && key ? (await read(game))[key] : undefined;
+    if (!rec)
+        return { why: 'no job of yours made this file (funtools records what gen and `job --wait` save, in .funtools/assets.json)' };
+    if (rec.generated_by)
+        return { why: `${rec.generated_by} made it on this machine, so the server holds no copy of it` };
+    if (sha256(await readFile(path)) !== rec.sha256)
+        return { why: `it changed since job ${rec.job_id} made it, so the server's copy (${rec.asset_id}) is not this file` };
+    return { asset_id: rec.asset_id };
+}

package/dist/gen/save.js

@@ -0,0 +1,101 @@
+import { existsSync, statSync } from 'node:fs';
+import { mkdir, rename, writeFile } from 'node:fs/promises';
+import { dirname, extname, join, relative, resolve } from 'node:path';
+import { recordAssets, recordLocal } from "./record.js";
+export const FOLDER = {
+    image: 'images', texture: 'textures', strip: 'images', sprite: 'sprites', sound: 'sfx', music: 'music', model3d: 'models',
+    skybox: 'skyboxes', 'find-material': 'materials', material: 'materials', inspect: 'models', 'optimize-model': 'models',
+    fracture: 'models', lod: 'models', rig: 'models', render: 'models', finalize: 'models',
+    level: 'models', skin: 'models', retexture: 'models',
+    video: 'video', 'edit-video': 'video', lipsync: 'video', edit: 'sprites', sheet: 'sprites', voice: 'voice', line: 'voice', dialogue: 'voice',
+    characters: 'characters', character: 'characters', 'restyle-character': 'characters',
+    motion: 'models', retarget: 'models',
+    review: 'playtest/hosted', play: 'playtest/hosted',
+};
+const SET = new Set(['material', 'sheet', 'character', 'restyle-character', 'dialogue']);
+const PROOF = new Set(['render', 'finalize', 'level', 'skin', 'retexture']);
+const PRIVATE = new Set(['video', 'edit-video', 'lipsync', 'review', 'play', 'voice']);
+export const slugOf = (s) => s.toLowerCase().normalize('NFKD').replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40).replace(/-+$/, '') || 'asset';
+const suffixOf = (name) => {
+    const dot = name.indexOf('.');
+    return dot < 0 ? '' : name.slice(dot);
+};
+function free(path) {
+    if (!existsSync(path))
+        return path;
+    const ext = extname(path), stem = path.slice(0, path.length - ext.length);
+    for (let n = 2;; n++)
+        if (!existsSync(`${stem}-${n}${ext}`))
+            return `${stem}-${n}${ext}`;
+}
+export function plan(game, kind, prompt, outputs, out) {
+    const asFile = out !== undefined && outputs.length === 1 && extname(out) !== '' && !(existsSync(out) && statSync(out).isDirectory());
+    if (asFile)
+        return [resolve(out)];
+    const dir = out !== undefined ? resolve(out)
+        : PRIVATE.has(kind) ? join(resolve(game), '.funtools', FOLDER[kind])
+            : join(resolve(game), 'public', 'assets', FOLDER[kind]);
+    const proofs = out !== undefined ? resolve(out) : join(resolve(game), '.funtools', 'renders');
+    const base = slugOf(prompt || (PROOF.has(kind) ? kind : outputs[0]?.name.split('.')[0]) || kind);
+    if (SET.has(kind)) {
+        let folder = join(dir, base);
+        for (let n = 2; existsSync(folder); n++)
+            folder = join(dir, `${base}-${n}`);
+        return outputs.map((o) => join(folder, o.name));
+    }
+    const taken = new Set();
+    return outputs.map((o) => {
+        if (o.name.endsWith('.source.glb') && out === undefined) {
+            const p = free(join(resolve(game), '.funtools', 'sources', FOLDER[kind], `${base}.glb`));
+            taken.add(p);
+            return p;
+        }
+        const proof = PROOF.has(kind) && o.content_type === 'image/png';
+        let p = free(proof ? join(proofs, base, o.name) : join(dir, `${base}${suffixOf(o.name) || extname(o.name)}`));
+        while (taken.has(p))
+            p = free(p.replace(/(\.[^./]+)$/, '-x$1'));
+        taken.add(p);
+        return p;
+    });
+}
+export async function saveOutputs(job, kind, prompt, game, out) {
+    const paths = plan(game, kind, prompt, job.outputs, out);
+    const saved = [];
+    const made = [];
+    for (const [i, o] of job.outputs.entries()) {
+        if (!o.url)
+            throw new Error(`the job's file ${o.name} has no URL (storage is not configured on the server)`);
+        const res = await fetch(o.url);
+        if (!res.ok)
+            throw new Error(`downloading ${o.name} answered ${res.status} — the URL lasts an hour; \`funtools job ${job.job_id} --wait\` mints fresh ones`);
+        const bytes = Buffer.from(await res.arrayBuffer());
+        if (o.size_bytes > 0 && bytes.length !== o.size_bytes)
+            throw new Error(`${o.name}: got ${bytes.length} bytes, the job says ${o.size_bytes}`);
+        const path = paths[i];
+        await mkdir(dirname(path), { recursive: true });
+        const tmp = `${path}.part`;
+        await writeFile(tmp, bytes);
+        await rename(tmp, path);
+        saved.push({ path, bytes: bytes.length, asset_id: o.asset_id, content_type: o.content_type });
+        made.push({ path, asset_id: o.asset_id, bytes });
+    }
+    await recordAssets(game, job.job_id, job.tool, made).catch(() => { });
+    return saved;
+}
+export async function saveLocal(files, kind, prompt, game, tool, generatedBy, out) {
+    const paths = plan(game, kind, prompt, files, out);
+    const saved = [];
+    for (const [i, f] of files.entries()) {
+        const path = paths[i];
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(`${path}.part`, f.bytes);
+        await rename(`${path}.part`, path);
+        saved.push({ path, bytes: f.bytes.length, asset_id: '', content_type: f.content_type });
+    }
+    await recordLocal(game, tool, generatedBy, files.map((f, i) => ({ path: paths[i], bytes: f.bytes }))).catch(() => { });
+    return saved;
+}
+export function servedAs(game, path) {
+    const rel = relative(join(resolve(game), 'public'), path);
+    return rel.startsWith('..') ? relative(resolve(game), path) : `/${rel.split('\\').join('/')}`;
+}

package/dist/gen/title.js

@@ -0,0 +1,55 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function gameTitle(game) {
+    try {
+        const name = JSON.parse(readFileSync(join(game, 'funpixel.json'), 'utf8')).name;
+        return typeof name === 'string' && name.trim() ? name.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+function pattern(title) {
+    const core = title.replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, '');
+    if (core.length < 3)
+        return null;
+    const words = core.split(/[^\p{L}\p{N}']+/u).filter(Boolean).map(escape).join(`[^\\p{L}\\p{N}]+`);
+    return new RegExp(`["'“‘]?(?<![\\p{L}\\p{N}])${words}(?![\\p{L}\\p{N}])[!?.]?["'”’]?`, 'giu');
+}
+export function checkTitle(prompt, title) {
+    if (!title)
+        return { state: 'not_observed', why: 'no name in funpixel.json' };
+    if (!prompt.trim())
+        return { state: 'not_observed', why: 'no prompt' };
+    const re = pattern(title);
+    if (!re)
+        return { state: 'not_observed', why: `the title "${title}" is too short to look for` };
+    const m = re.exec(prompt);
+    return m ? { state: 'found', title, match: m[0] } : { state: 'clear', title };
+}
+export function stripTitle(prompt, title) {
+    const re = pattern(title);
+    if (!re)
+        return prompt;
+    return prompt.replace(re, ' ')
+        .replace(/\b(of|for|from|in|called|named|titled)\s+(?=[,.;:]|$)/gi, '')
+        .replace(/\s+([,.;:!?])/g, '$1').replace(/\s{2,}/g, ' ').replace(/^[\s,.;:]+/, '').trim();
+}
+export const titleNote = (c, stripped) => stripped ? `sent without the game's name "${c.title}" (--strip-title): image models letter a name they are given, and garble it`
+    : `the prompt names the game ("${c.match.trim()}"): image models try to letter it and garble it — describe the look instead, or pass --strip-title (keep it only when you want the words drawn, and check them)`;
+const PICTURE_KINDS = new Set(['image', 'texture', 'strip', 'sprite', 'edit', 'sheet', 'skybox', 'retexture', 'restyle-character', 'model3d', 'video']);
+export function titleGuard(req, game, strip) {
+    const words = req.input.prompt;
+    if (!PICTURE_KINDS.has(req.kind) || typeof words !== 'string')
+        return { req, check: { state: 'not_observed', why: 'no picture prompt' } };
+    const check = checkTitle(words, gameTitle(game));
+    if (check.state !== 'found')
+        return { req, check };
+    if (!strip)
+        return { req, check, note: titleNote(check, false) };
+    const left = stripTitle(words, check.title);
+    if (!left)
+        throw new Error(`the prompt is only the game's name "${check.title}" — describe what the picture shows`);
+    return { req: { ...req, input: { ...req.input, prompt: left } }, check, note: titleNote(check, true) };
+}

package/dist/gen/unity.js

@@ -0,0 +1,334 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, extname, join, relative, resolve } from 'node:path';
+import { slugOf } from "./save.js";
+export const UNITY_ROOT = 'Assets/_Game/Generated';
+export const IMPORT_RULE = `${UNITY_ROOT}/Editor/FunpixelGenImport.cs`;
+const RULE_MARK = '// Written by `funtools gen --unity`';
+export const UNITY_FOLDER = {
+    image: 'Images', sprite: 'Sprites', strip: 'Sprites', edit: 'Sprites', sheet: 'Sprites',
+    texture: 'Textures', material: 'Materials', skybox: 'Skyboxes', model3d: 'Models',
+    sound: 'Sfx', music: 'Music', line: 'Voice',
+};
+export function unityProject(given) {
+    const at = resolve(given);
+    for (const p of [at, join(at, 'unity')]) {
+        if (existsSync(join(p, 'ProjectSettings', 'ProjectVersion.txt')) && existsSync(join(p, 'Assets')))
+            return { project: p };
+    }
+    return { why: `${given} is not a Unity project (no ProjectSettings/ProjectVersion.txt and Assets/ there or in its unity/)` };
+}
+export const looksLikeUnity = (dir) => existsSync(join(dir, 'ProjectSettings', 'ProjectVersion.txt')) && !existsSync(join(dir, 'funpixel.json'));
+export function unityOut(project, kind, prompt, loop) {
+    const folder = kind === 'sound' && loop ? 'Loops' : UNITY_FOLDER[kind];
+    if (!folder)
+        return { why: `--unity takes ${Object.keys(UNITY_FOLDER).join(', ')}; for ${kind}, use --out` };
+    const base = join(project, UNITY_ROOT, folder);
+    if (kind !== 'model3d')
+        return { dir: base };
+    const slug = slugOf(prompt || 'model');
+    let dir = join(base, slug);
+    for (let n = 2; existsSync(dir); n++)
+        dir = join(base, `${slug}-${n}`);
+    return { dir };
+}
+const ROLES = [['normalTexture', 'normal'], ['occlusionTexture', 'occlusion'], ['emissiveTexture', 'emissive']];
+const NEEDS_PACKAGE = {
+    KHR_draco_mesh_compression: 'com.unity.cloud.draco', EXT_meshopt_compression: 'com.unity.meshopt.decompress', KHR_texture_basisu: 'com.unity.cloud.ktx',
+};
+function rolesByImage(j) {
+    const texRole = new Map();
+    const set = (i, role) => { if (typeof i === 'number' && !texRole.has(i))
+        texRole.set(i, role); };
+    for (const m of j.materials ?? []) {
+        const pbr = m.pbrMetallicRoughness ?? {};
+        set(pbr.baseColorTexture?.index, 'basecolor');
+        set(pbr.metallicRoughnessTexture?.index, 'mr');
+        for (const [key, role] of ROLES)
+            set(m[key]?.index, role);
+    }
+    const imgRole = new Map();
+    (j.textures ?? []).forEach((t, ti) => {
+        if (typeof t.source === 'number' && texRole.has(ti) && !imgRole.has(t.source))
+            imgRole.set(t.source, texRole.get(ti));
+    });
+    return imgRole;
+}
+export function splitGlb(file) {
+    const data = readFileSync(file);
+    if (data.length < 20 || data.readUInt32LE(0) !== 0x46546c67 || data.readUInt32LE(4) !== 2)
+        return { kept: 'not a glTF 2 binary' };
+    const length = Math.min(data.readUInt32LE(8), data.length);
+    let off = 12;
+    let j = null;
+    let bin = Buffer.alloc(0);
+    while (off + 8 <= length) {
+        const clen = data.readUInt32LE(off), type = data.readUInt32LE(off + 4);
+        const chunk = data.subarray(off + 8, off + 8 + clen);
+        if (type === 0x4e4f534a)
+            j = JSON.parse(chunk.toString('utf8'));
+        else if (type === 0x004e4942)
+            bin = chunk;
+        off += 8 + clen;
+    }
+    if (!j)
+        return { kept: 'no JSON chunk' };
+    const needs = [...(j.extensionsRequired ?? []), ...(j.extensionsUsed ?? [])].filter((e) => NEEDS_PACKAGE[e]);
+    if (needs.length)
+        return { kept: `it uses ${[...new Set(needs)].join(', ')}: add ${[...new Set(needs.map((e) => NEEDS_PACKAGE[e]))].join(', ')} to Packages/manifest.json, or make it again with --raw` };
+    const stem = basename(file, extname(file));
+    const dir = dirname(file);
+    const roles = rolesByImage(j);
+    const used = new Map();
+    const writes = [];
+    const images = j.images ?? [];
+    for (const [i, im] of images.entries()) {
+        if (typeof im.bufferView !== 'number')
+            continue;
+        const bv = j.bufferViews?.[im.bufferView];
+        if (!bv)
+            return { kept: `image ${i} names a bufferView that is not there` };
+        const blob = bin.subarray(bv.byteOffset ?? 0, (bv.byteOffset ?? 0) + bv.byteLength);
+        const ext = blob.subarray(0, 4).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47])) ? 'png' : blob[0] === 0xff && blob[1] === 0xd8 ? 'jpg' : null;
+        if (!ext)
+            return { kept: `image ${i} is neither PNG nor JPEG, which Unity's texture importer reads` };
+        const role = roles.get(i) ?? `img${i}`;
+        const n = (used.get(role) ?? 0) + 1;
+        used.set(role, n);
+        const name = `${stem}__${role}${n === 1 ? '' : n}.${ext}`;
+        writes.push([join(dir, name), Buffer.from(blob)]);
+        delete im.bufferView;
+        delete im.mimeType;
+        im.uri = name;
+    }
+    if (j.buffers?.[0] && j.buffers[0].uri === undefined)
+        j.buffers[0].uri = `${stem}.bin`;
+    for (const [p, b] of writes)
+        writeFileSync(p, b);
+    writeFileSync(join(dir, `${stem}.bin`), bin);
+    writeFileSync(join(dir, `${stem}.gltf`), JSON.stringify(j));
+    rmSync(file, { force: true });
+    return { files: [join(dir, `${stem}.gltf`), join(dir, `${stem}.bin`), ...writes.map(([p]) => p)], images: writes.length };
+}
+const realRun = (cmd, args) => {
+    const r = spawnSync(cmd, args, { encoding: 'utf8', timeout: 300_000 });
+    return { code: r.status ?? (r.error ? 127 : 1), out: `${r.stderr ?? ''}${r.error ? r.error.message : ''}`.trim() };
+};
+export function toWav(file, run = realRun) {
+    const wav = file.replace(/\.mp3$/i, '.wav');
+    const r = run('ffmpeg', ['-nostdin', '-v', 'error', '-y', '-i', file, '-ar', '48000', '-c:a', 'pcm_s16le', wav]);
+    if (r.code !== 0 || !existsSync(wav) || statSync(wav).size === 0) {
+        rmSync(wav, { force: true });
+        return { kept: r.code === 127 ? 'ffmpeg is not on PATH' : `ffmpeg could not convert it: ${r.out.slice(-200)}` };
+    }
+    rmSync(file, { force: true });
+    return { file: wav };
+}
+export const IMPORT_RULE_SOURCE = `${RULE_MARK} (v1). Import settings for what it writes under
+// ${UNITY_ROOT}/, set once, when Unity first imports a file (no .meta yet): from then on the settings are the
+// project's, kept in the .meta Unity writes, and a change you make in the Inspector stays. One exception: a normal
+// map is kept a NormalMap on every import, because a rule that imports every model texture as Default (Joydle
+// Core's TextureBudget) would turn it back. funtools rewrites this file while this first line stays; delete the
+// line to keep your own edits, or the file to stop it.
+#if UNITY_EDITOR
+using System.Text.RegularExpressions;
+using UnityEditor;
+using UnityEngine;
+
+namespace Funpixel.Generated.EditorTools
+{
+    public sealed class FunpixelGenImport : AssetPostprocessor
+    {
+        const string Root = "${UNITY_ROOT}/";
+        // A file named by role (model__basecolor, model__normal: the GLB split) is read by its role; any other by the
+        // words in its name (a Poly Haven set's rock_nor_gl, rock_rough).
+        static readonly Regex Normal = new Regex(@"(^|[_\\-. ])(nor|normal|nrm)(_gl|_dx)?($|[_\\-. ]|\\d)", RegexOptions.IgnoreCase);
+        static readonly Regex Data = new Regex(@"(^|[_\\-. ])(rough|roughness|metal|metallic|ao|occlusion|height|disp|displacement|mask|arm|orm)($|[_\\-. ]|\\d)", RegexOptions.IgnoreCase);
+
+        // After the project's own rules (Joydle Core's TextureBudget runs at 0), so these settings win on first import.
+        public override int GetPostprocessOrder() => 100;
+
+        static bool Ours(string path) => path.Replace('\\\\', '/').StartsWith(Root, System.StringComparison.Ordinal);
+        static bool In(string path, string folder) => path.Replace('\\\\', '/').StartsWith(Root + folder + "/", System.StringComparison.Ordinal);
+
+        void OnPreprocessTexture()
+        {
+            if (!Ours(assetPath)) return;
+            var ti = (TextureImporter)assetImporter;
+            var name = System.IO.Path.GetFileNameWithoutExtension(assetPath);
+            var role = Role(name);
+            bool art = In(assetPath, "Sprites") || In(assetPath, "Images");
+            bool normal = !art && (role != null ? role == "normal" : Normal.IsMatch(name));
+            bool colour = role != null ? role is "basecolor" or "emissive" : !normal && !Data.IsMatch(name);
+            if (!assetImporter.importSettingsMissing)
+            {
+                if (normal && ti.textureType != TextureImporterType.NormalMap) ti.textureType = TextureImporterType.NormalMap;
+                return;
+            }
+            if (art)
+            {
+                // Sprites and UI art: Sprite, no mipmaps, ASTC 5x5; backgrounds and plates (Images) ASTC 6x6.
+                ti.textureType = TextureImporterType.Sprite;
+                ti.spriteImportMode = SpriteImportMode.Single;
+                ti.spritePixelsPerUnit = 100;
+                ti.mipmapEnabled = false;
+                ti.alphaIsTransparency = true;
+                ti.wrapMode = TextureWrapMode.Clamp;
+                Mobile(ti, In(assetPath, "Sprites") ? TextureImporterFormat.ASTC_5x5 : TextureImporterFormat.ASTC_6x6, 2048);
+                return;
+            }
+            if (In(assetPath, "Skyboxes"))
+            {
+                // A 360-degree equirect for Skybox/Panoramic: no mipmaps (a seam at the poles), wraps round in U only.
+                ti.textureType = TextureImporterType.Default;
+                ti.mipmapEnabled = false;
+                ti.wrapModeU = TextureWrapMode.Repeat;
+                ti.wrapModeV = TextureWrapMode.Clamp;
+                Mobile(ti, TextureImporterFormat.ASTC_6x6, 4096);
+                return;
+            }
+            // Model textures (split from the GLB), tileable textures and material sets: mipmapped, ASTC 6x6, at most 1024;
+            // sRGB only for colour (base colour, emissive), never for a normal, roughness, metal, occlusion or height map.
+            ti.textureType = normal ? TextureImporterType.NormalMap : TextureImporterType.Default;
+            ti.textureShape = TextureImporterShape.Texture2D;
+            ti.sRGBTexture = colour;
+            ti.mipmapEnabled = true;
+            ti.npotScale = TextureImporterNPOTScale.ToNearest;
+            ti.wrapMode = In(assetPath, "Models") ? TextureWrapMode.Clamp : TextureWrapMode.Repeat;
+            Mobile(ti, TextureImporterFormat.ASTC_6x6, 1024);
+        }
+
+        /// <summary>The role after the last "__" (digits trimmed: model__basecolor2), or null.</summary>
+        static string Role(string name)
+        {
+            int i = name.LastIndexOf("__", System.StringComparison.Ordinal);
+            return i < 0 ? null : name.Substring(i + 2).TrimEnd('0', '1', '2', '3', '4', '5', '6', '7', '8', '9').ToLowerInvariant();
+        }
+
+        static void Mobile(TextureImporter ti, TextureImporterFormat format, int max)
+        {
+            ti.maxTextureSize = max;
+            foreach (var platform in new[] { "iPhone", "Android" })
+            {
+                var s = ti.GetPlatformTextureSettings(platform);
+                s.overridden = true;
+                s.maxTextureSize = max;
+                s.format = format;
+                ti.SetPlatformTextureSettings(s);
+            }
+        }
+
+        void OnPreprocessAudio()
+        {
+            if (!Ours(assetPath) || !assetImporter.importSettingsMissing) return;
+            var ai = (AudioImporter)assetImporter;
+            var s = ai.defaultSampleSettings;
+            bool mono = false;
+            s.sampleRateSetting = AudioSampleRateSetting.PreserveSampleRate;
+            if (In(assetPath, "Music"))
+            {
+                s.loadType = AudioClipLoadType.Streaming;
+                s.compressionFormat = AudioCompressionFormat.Vorbis;
+                s.quality = 0.7f;
+            }
+            else if (In(assetPath, "Loops"))
+            {
+                // ADPCM pads to 64-sample blocks and an MP3 carries encoder padding: either clicks at the seam.
+                s.loadType = AudioClipLoadType.DecompressOnLoad;
+                s.compressionFormat = AudioCompressionFormat.PCM;
+            }
+            else if (In(assetPath, "Voice"))
+            {
+                s.loadType = AudioClipLoadType.CompressedInMemory;
+                s.compressionFormat = AudioCompressionFormat.Vorbis;
+                s.quality = 0.6f;
+                mono = true;
+            }
+            else
+            {
+                s.loadType = AudioClipLoadType.DecompressOnLoad;
+                s.compressionFormat = AudioCompressionFormat.ADPCM;
+                mono = true;
+            }
+            ai.defaultSampleSettings = s;
+            if (mono) Mono(ai);
+        }
+
+        // Mono with normalisation off: left on, it made quiet effects about 7 dB too loud. The .meta calls it
+        // \`normalize\`; the serialized property is m_Normalize (read on 6000.6), set after the sample settings.
+        static void Mono(AudioImporter ai)
+        {
+            ai.forceToMono = true;
+            var so = new SerializedObject(ai);
+            var p = so.FindProperty("m_Normalize") ?? so.FindProperty("normalize");
+            if (p == null) return;
+            p.boolValue = false;
+            so.ApplyModifiedPropertiesWithoutUndo();
+        }
+    }
+}
+#endif
+`;
+export function ensureImportRule(project) {
+    const file = join(project, IMPORT_RULE);
+    if (existsSync(file)) {
+        const have = readFileSync(file, 'utf8');
+        if (have === IMPORT_RULE_SOURCE)
+            return 'current';
+        if (!have.startsWith(RULE_MARK))
+            return 'theirs';
+    }
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, IMPORT_RULE_SOURCE);
+    return 'written';
+}
+function manifestPackages(project) {
+    try {
+        return JSON.parse(readFileSync(join(project, 'Packages', 'manifest.json'), 'utf8')).dependencies ?? {};
+    }
+    catch {
+        return null;
+    }
+}
+export function afterSave(project, kind, saved, run = realRun) {
+    const notes = [];
+    const files = [];
+    const rel = (p) => relative(project, p).split('\\').join('/');
+    const asSaved = (from, path) => ({ ...from, path, bytes: statSync(path).size, content_type: contentType(path) });
+    for (const s of saved) {
+        if (/\.glb$/i.test(s.path)) {
+            const r = splitGlb(s.path);
+            if ('kept' in r) {
+                notes.push(`${rel(s.path)} kept as a GLB: ${r.kept}`);
+                files.push(s);
+            }
+            else
+                files.push(...r.files.map((p) => asSaved(s, p)));
+        }
+        else if (/\.mp3$/i.test(s.path)) {
+            const r = toWav(s.path, run);
+            if ('kept' in r) {
+                notes.push(`${rel(s.path)} kept as an MP3 (${r.kept}): a loop of it clicks in Unity, so convert it to 48 kHz WAV before it loops`);
+                files.push(s);
+            }
+            else
+                files.push(asSaved(s, r.file));
+        }
+        else
+            files.push(s);
+    }
+    const rule = ensureImportRule(project);
+    if (rule === 'written')
+        notes.push(`wrote the import rule ${IMPORT_RULE}: Unity sets each file's import settings when it first imports it`);
+    if (rule === 'theirs')
+        notes.push(`${IMPORT_RULE} is not the kit's (its first line changed): the import settings are yours to set`);
+    const pkgs = manifestPackages(project);
+    if (kind === 'model3d' && pkgs && !pkgs['com.unity.cloud.gltfast'])
+        notes.push('this project has no glTFast: add "com.unity.cloud.gltfast": "6.20.0" to Packages/manifest.json, or the .gltf imports as nothing');
+    notes.push('Unity imports them on its next refresh (focus the Editor, or the next batch run); commit each file with the .meta Unity writes');
+    return { files, notes };
+}
+function contentType(path) {
+    const ext = extname(path).toLowerCase();
+    return { '.gltf': 'model/gltf+json', '.bin': 'application/octet-stream', '.png': 'image/png', '.jpg': 'image/jpeg', '.wav': 'audio/wav' }[ext] ?? 'application/octet-stream';
+}