@dice-o-rolla/dice-assets 0.4.0 → 0.5.0

package/dist/tools/build.js

@@ -0,0 +1,232 @@
+import { execFile } from 'node:child_process';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { getDieGeometry } from '@dice-o-rolla/dice-geometry';
+import { validateSurfaceUvs } from '@dice-o-rolla/dice-renderer-three';
+import { Resvg } from '@resvg/resvg-js';
+import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
+import { DiceAssetRegistry, } from '../index.js';
+import { assertImageSize, assertPortableId, assertTemplateType, geometryType } from './template.js';
+import { writeDirectory } from './write-directory.js';
+const execute = promisify(execFile);
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function assertSource(value) {
+    if (!isRecord(value) ||
+        value.schemaVersion !== 1 ||
+        typeof value.id !== 'string' ||
+        !isRecord(value.dice))
+        throw new TypeError('Source manifest requires schemaVersion 1, id and dice');
+    assertPortableId(value.id);
+    if (value.name !== undefined && typeof value.name !== 'string')
+        throw new TypeError('name must be a string');
+    if (value.material !== undefined) {
+        if (!isRecord(value.material))
+            throw new TypeError('material must be an object');
+        const material = value.material;
+        for (const key of ['roughness', 'metalness'])
+            if (typeof material[key] !== 'number' || !Number.isFinite(material[key]))
+                throw new TypeError(`material.${key} must be a finite number`);
+        for (const key of ['normalScale', 'clearcoat', 'clearcoatRoughness'])
+            if (material[key] !== undefined &&
+                (typeof material[key] !== 'number' || !Number.isFinite(material[key])))
+                throw new TypeError(`material.${key} must be a finite number`);
+        if (material.metadata !== undefined &&
+            (!isRecord(material.metadata) ||
+                !Object.values(material.metadata).every((item) => typeof item === 'string' ||
+                    typeof item === 'boolean' ||
+                    (typeof item === 'number' && Number.isFinite(item)))))
+            throw new TypeError('Invalid material metadata');
+    }
+    if (Object.keys(value.dice).length === 0)
+        throw new TypeError('Source manifest must contain at least one die');
+    for (const [type, entry] of Object.entries(value.dice)) {
+        assertTemplateType(type);
+        if (!isRecord(entry) ||
+            typeof entry.unwrap !== 'string' ||
+            entry.unwrap.length === 0 ||
+            typeof entry.baseColor !== 'string' ||
+            entry.baseColor.length === 0)
+            throw new TypeError(`${type} requires unwrap and baseColor paths`);
+        for (const map of ['normal', 'orm'])
+            if (entry[map] !== undefined && (typeof entry[map] !== 'string' || entry[map].length === 0))
+                throw new TypeError(`${type}.${map} must be a path`);
+    }
+}
+function svgWithoutGuides(source) {
+    const document = new DOMParser({
+        onError: (_level, message) => {
+            throw new Error(`Invalid SVG: ${message}`);
+        },
+    }).parseFromString(source, 'image/svg+xml');
+    if (document.doctype !== null || document.documentElement?.localName !== 'svg')
+        throw new Error('Expected an SVG document without a doctype');
+    const elements = Array.from(document.getElementsByTagName('*'));
+    for (const element of elements) {
+        if (element.localName === 'script')
+            throw new Error('SVG scripts are not supported');
+        if (element.getAttribute('id') === 'guides')
+            element.parentNode?.removeChild(element);
+        const href = element.getAttribute('href') ?? element.getAttribute('xlink:href');
+        if (href && !href.startsWith('#') && !/^data:image\/(?:png|jpeg|webp);base64,/i.test(href))
+            throw new Error('Embed linked SVG images as PNG/JPEG/WebP data URIs before building');
+    }
+    return new XMLSerializer().serializeToString(document);
+}
+async function loadImage(path, allowSvg) {
+    const bytes = await readFile(path), extension = extname(path).toLowerCase();
+    let png, preview;
+    if (extension === '.svg' && allowSvg) {
+        preview = bytes.toString('utf8');
+        const svg = svgWithoutGuides(preview);
+        const renderer = new Resvg(svg);
+        if (renderer.width !== renderer.height)
+            throw new RangeError(`${path}: texture must be square`);
+        assertImageSize(renderer.width);
+        png = renderer.render().asPng();
+    }
+    else if (extension === '.png') {
+        png = bytes;
+        preview = bytes;
+    }
+    else
+        throw new Error(`${path}: expected ${allowSvg ? 'SVG or PNG' : 'PNG'}`);
+    if (png.length < 24 || !png.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+        throw new Error(`${path}: invalid PNG`);
+    const size = png.readUInt32BE(16);
+    if (size !== png.readUInt32BE(20))
+        throw new RangeError(`${path}: texture must be square`);
+    assertImageSize(size);
+    return { png, size, preview, extension: extension === '.svg' ? 'svg' : 'png' };
+}
+async function runKtx(executable, args) {
+    try {
+        await execute(executable, [...args], { maxBuffer: 8 * 1024 * 1024 });
+    }
+    catch (error) {
+        if (isRecord(error) && error.code === 'ENOENT')
+            throw new Error('KTX CLI was not found. Install KTX-Software and put ktx on PATH, or set ktxExecutable.', { cause: error });
+        throw new Error(`KTX ${args[0]} failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+}
+export async function buildTexturedSkinSet(options) {
+    const input = resolve(options.input), output = resolve(options.outputDirectory);
+    const toInput = relative(output, input);
+    if (!isAbsolute(toInput) &&
+        toInput !== '..' &&
+        !toInput.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`))
+        throw new Error('Keep the source manifest outside the output directory');
+    const source = JSON.parse(await readFile(input, 'utf8'));
+    assertSource(source);
+    const root = dirname(input);
+    const material = {
+        ...source.material,
+        roughness: source.material?.roughness ?? 0.7,
+        metalness: source.material?.metalness ?? 0,
+        id: `${source.id}-material`,
+    };
+    const prepared = await Promise.all(Object.entries(source.dice).map(async ([rawType, entry]) => {
+        assertTemplateType(rawType);
+        const raw = JSON.parse(await readFile(resolve(root, entry.unwrap), 'utf8'));
+        if (!isRecord(raw) || raw.geometryId !== geometryType(rawType) || !isRecord(raw.faces))
+            throw new Error(`${rawType}: unwrap geometry must be ${geometryType(rawType)}`);
+        const faces = {};
+        for (const [key, coordinates] of Object.entries(raw.faces)) {
+            if (!/^[1-9]\d*$/.test(key) || !Array.isArray(coordinates))
+                throw new TypeError(`${rawType}: invalid face ${key}`);
+            faces[Number(key)] = coordinates.map((uv) => {
+                if (!Array.isArray(uv) ||
+                    uv.length !== 2 ||
+                    typeof uv[0] !== 'number' ||
+                    typeof uv[1] !== 'number')
+                    throw new TypeError(`${rawType}: invalid UV on face ${key}`);
+                return [uv[0], uv[1]];
+            });
+        }
+        const unwrap = { geometryId: geometryType(rawType), faces };
+        validateSurfaceUvs(getDieGeometry(geometryType(rawType)), unwrap.faces);
+        const [baseColor, normal, orm] = await Promise.all([
+            loadImage(resolve(root, entry.baseColor), true),
+            entry.normal === undefined ? undefined : loadImage(resolve(root, entry.normal), false),
+            entry.orm === undefined ? undefined : loadImage(resolve(root, entry.orm), false),
+        ]);
+        if ((normal !== undefined && normal.size !== baseColor.size) ||
+            (orm !== undefined && orm.size !== baseColor.size))
+            throw new Error(`${rawType}: baseColor, normal and ORM dimensions must match`);
+        return { type: rawType, unwrap, baseColor, normal, orm };
+    }));
+    const catalog = {
+        schemaVersion: 1,
+        materials: [material],
+        patterns: prepared.map((die) => ({
+            id: `${source.id}-${die.type}`,
+            baseColor: texture(die.type, 'baseColor'),
+            ...(die.normal === undefined ? {} : { normal: texture(die.type, 'normal') }),
+            ...(die.orm === undefined ? {} : { orm: texture(die.type, 'orm') }),
+            unwrap: {
+                geometryId: die.unwrap.geometryId,
+                faces: die.unwrap.faces,
+                preview: {
+                    uri: `./previews/${die.type}.${die.baseColor.extension}`,
+                    mediaType: die.baseColor.extension === 'svg' ? 'image/svg+xml' : 'image/png',
+                },
+            },
+        })),
+        skins: prepared.map((die) => ({
+            id: `${source.id}-${die.type}`,
+            materialId: material.id,
+            patternId: `${source.id}-${die.type}`,
+        })),
+        skinSets: [
+            {
+                id: source.id,
+                ...(source.name === undefined ? {} : { name: source.name }),
+                skins: Object.fromEntries(prepared.map((die) => [die.type, `${source.id}-${die.type}`])),
+            },
+        ],
+    };
+    new DiceAssetRegistry().registerCatalog(catalog);
+    const executable = options.ktxExecutable ?? 'ktx';
+    await writeDirectory(output, options.overwrite ?? false, async (staging) => {
+        await Promise.all(['textures', 'previews', '.intermediate'].map((directory) => mkdir(join(staging, directory))));
+        await prepared.reduce(async (previous, die) => {
+            await previous;
+            await writeFile(join(staging, 'previews', `${die.type}.${die.baseColor.extension}`), die.baseColor.preview);
+            await ['baseColor', 'normal', 'orm'].reduce(async (prior, map) => {
+                await prior;
+                const image = die[map];
+                if (image === undefined)
+                    return;
+                const pngPath = join(staging, '.intermediate', `${die.type}-${map}.png`), outputPath = join(staging, 'textures', `${die.type}-${map}.ktx2`);
+                await writeFile(pngPath, image.png);
+                await runKtx(executable, [
+                    'create',
+                    '--format',
+                    map === 'baseColor' ? 'R8G8B8A8_SRGB' : 'R8G8B8A8_UNORM',
+                    '--assign-tf',
+                    map === 'baseColor' ? 'srgb' : 'linear',
+                    '--convert-texcoord-origin',
+                    'bottom-left',
+                    '--encode',
+                    'uastc-ldr-4x4',
+                    '--generate-mipmap',
+                    '--zstd',
+                    '12',
+                    pngPath,
+                    outputPath,
+                ]);
+                await runKtx(executable, ['validate', outputPath]);
+            }, Promise.resolve());
+        }, Promise.resolve());
+        await writeFile(join(staging, 'catalog.json'), `${JSON.stringify(catalog, null, 2)}\n`);
+        const { rm } = await import('node:fs/promises');
+        await rm(join(staging, '.intermediate'), { recursive: true });
+    });
+    return { outputDirectory: output, catalog };
+}
+const texture = (type, map) => ({
+    uri: `./textures/${type}-${map}.ktx2`,
+    mediaType: 'image/ktx2',
+    colorSpace: map === 'baseColor' ? 'srgb' : 'linear',
+    mipmaps: true,
+});

package/dist/tools/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/tools/cli.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { buildTexturedSkinSet } from './build.js';
+import { assertTemplateType, writeTextureTemplates } from './template.js';
+import { TEXTURE_TEMPLATE_TYPES } from './types.js';
+async function main() {
+    const { values, positionals } = parseArgs({
+        options: {
+            help: { type: 'boolean' },
+            types: { type: 'string' },
+            out: { type: 'string' },
+            input: { type: 'string' },
+            id: { type: 'string' },
+            size: { type: 'string' },
+            overwrite: { type: 'boolean' },
+            ktx: { type: 'string' },
+        },
+        allowPositionals: true,
+    });
+    if (values.help || positionals.length === 0) {
+        console.log('dice-assets template --types d6|standard|d4,d6 --out DIR [--id custom] [--size 2048]\ndice-assets build --input skin-set.source.json --out DIR [--ktx PATH]\nUse --overwrite to replace the entire destination directory after success.');
+        return;
+    }
+    if (positionals.length !== 1 || values.out === undefined)
+        throw new Error('Specify one command and --out DIR; see --help');
+    const shared = { outputDirectory: values.out, overwrite: values.overwrite ?? false };
+    if (positionals[0] === 'template') {
+        if (values.input !== undefined || values.ktx !== undefined)
+            throw new Error('--input and --ktx are build options');
+        const types = values.types === undefined || values.types === 'standard'
+            ? TEXTURE_TEMPLATE_TYPES
+            : values.types.split(',').map((value) => {
+                assertTemplateType(value);
+                return value;
+            });
+        await writeTextureTemplates({
+            ...shared,
+            types,
+            ...(values.id === undefined ? {} : { id: values.id }),
+            ...(values.size === undefined ? {} : { size: Number(values.size) }),
+        });
+        console.log(`Templates written to ${values.out}`);
+    }
+    else if (positionals[0] === 'build') {
+        if (values.input === undefined ||
+            values.types !== undefined ||
+            values.id !== undefined ||
+            values.size !== undefined)
+            throw new Error('build requires --input and does not accept template options');
+        await buildTexturedSkinSet({
+            ...shared,
+            input: values.input,
+            ...(values.ktx === undefined ? {} : { ktxExecutable: values.ktx }),
+        });
+        console.log(`Catalog written to ${values.out}/catalog.json`);
+    }
+    else
+        throw new Error(`Unknown command: ${positionals[0]}`);
+}
+void main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/tools/index.d.ts

@@ -0,0 +1,3 @@
+export { createTextureTemplate, writeTextureTemplates } from './template.js';
+export { buildTexturedSkinSet } from './build.js';
+export { TEXTURE_TEMPLATE_TYPES, type TextureTemplateType, type TextureTemplate, type TextureSourceEntry, type TexturedSkinSetSource, type WriteTextureTemplatesOptions, type BuildTexturedSkinSetOptions, type BuiltTexturedSkinSet, } from './types.js';

package/dist/tools/index.js

@@ -0,0 +1,3 @@
+export { createTextureTemplate, writeTextureTemplates } from './template.js';
+export { buildTexturedSkinSet } from './build.js';
+export { TEXTURE_TEMPLATE_TYPES, } from './types.js';

package/dist/tools/template.d.ts

@@ -0,0 +1,9 @@
+import { type TextureTemplate, type TextureTemplateType, type TexturedSkinSetSource, type WriteTextureTemplatesOptions } from './types.js';
+export declare function geometryType(type: TextureTemplateType): "d10" | "d12" | "d20" | "d4" | "d6" | "d8";
+export declare function assertImageSize(size: number): void;
+export declare function assertTemplateType(type: string): asserts type is TextureTemplateType;
+export declare function assertPortableId(id: string): void;
+export declare function createTextureTemplate(type: TextureTemplateType, options?: {
+    readonly size?: number;
+}): TextureTemplate;
+export declare function writeTextureTemplates(options: WriteTextureTemplatesOptions): Promise<TexturedSkinSetSource>;

package/dist/tools/template.js

@@ -0,0 +1,88 @@
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createStandardDiceNet, getDieGeometry } from '@dice-o-rolla/dice-geometry';
+import { getFaceLabel } from '@dice-o-rolla/dice-renderer-three';
+import { TEXTURE_TEMPLATE_TYPES, } from './types.js';
+import { writeDirectory } from './write-directory.js';
+export function geometryType(type) {
+    return type === 'd100' ? 'd10' : type === 'd66' ? 'd6' : type;
+}
+export function assertImageSize(size) {
+    if (!Number.isSafeInteger(size) || size < 64 || size > 8192 || (size & (size - 1)) !== 0)
+        throw new RangeError('Texture size must be a power of two between 64 and 8192');
+}
+export function assertTemplateType(type) {
+    if (!TEXTURE_TEMPLATE_TYPES.some((value) => value === type))
+        throw new RangeError(`Unsupported dice texture type: ${type}`);
+}
+export function assertPortableId(id) {
+    if (!/^[a-z0-9][a-z0-9_-]*$/i.test(id))
+        throw new RangeError('Skin set id must contain only letters, digits, underscores and hyphens');
+}
+export function createTextureTemplate(type, options = {}) {
+    assertTemplateType(type);
+    const size = options.size ?? 2048;
+    assertImageSize(size);
+    const unwrap = createStandardDiceNet(geometryType(type));
+    const geometry = getDieGeometry(geometryType(type));
+    const artwork = [], labels = [], guides = [];
+    for (const face of geometry.faces) {
+        const points = unwrap.faces[face.value].map(([u, v]) => [u * size, (1 - v) * size]);
+        const polygon = points.map((point) => point.join(',')).join(' ');
+        const cx = points.reduce((sum, p) => sum + p[0], 0) / points.length, cy = points.reduce((sum, p) => sum + p[1], 0) / points.length;
+        const radius = Math.min(...points.map((p) => Math.hypot(p[0] - cx, p[1] - cy)));
+        artwork.push(`<polygon id="art-face-${face.value}" points="${polygon}" fill="#e0e6ed" stroke="#e0e6ed" stroke-width="${size / 128}" stroke-linejoin="round"/>`);
+        guides.push(`<polygon points="${polygon}" fill="none" stroke="#d72b65" stroke-width="${size / 1024}"/><text x="${cx}" y="${cy - radius * 0.3}" font-size="${radius * 0.09}" text-anchor="middle">${type} / face ${face.value}</text>`);
+        for (let edge = 0; edge < points.length; edge++) {
+            const a = points[edge], b = points[(edge + 1) % points.length];
+            const av = face.indices[edge], bv = face.indices[(edge + 1) % points.length];
+            guides.push(`<text x="${(a[0] + b[0]) * 0.43 + cx * 0.14}" y="${(a[1] + b[1]) * 0.43 + cy * 0.14}" font-size="${radius * 0.08}" text-anchor="middle">${Math.min(av, bv)}:${Math.max(av, bv)}</text>`);
+        }
+        const label = getFaceLabel(geometry, face);
+        if (typeof label === 'string' || typeof label === 'number') {
+            const display = type === 'd100'
+                ? face.value === 10
+                    ? '00'
+                    : String(face.value * 10)
+                : type === 'd66'
+                    ? String(face.value * 10)
+                    : String(label);
+            labels.push(`<text x="${cx}" y="${cy}" font-size="${radius * 0.5}" text-anchor="middle" dominant-baseline="central">${display}</text>`);
+        }
+        else {
+            for (const [index, value] of label.entries()) {
+                const point = points[index];
+                labels.push(`<text x="${(cx + point[0]) / 2}" y="${(cy + point[1]) / 2}" font-size="${radius * 0.24}" text-anchor="middle" dominant-baseline="central">${value}</text>`);
+            }
+        }
+    }
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" width="${size}" height="${size}" viewBox="0 0 ${size} ${size}" font-family="sans-serif" fill="#172535">${layer('artwork', artwork)}${layer('labels', labels)}${layer('guides', guides)}</svg>\n`;
+    return { type, unwrap, svg };
+}
+export async function writeTextureTemplates(options) {
+    const id = options.id ?? 'custom';
+    assertPortableId(id);
+    const types = options.types ?? TEXTURE_TEMPLATE_TYPES;
+    if (types.length === 0 || new Set(types).size !== types.length)
+        throw new RangeError('Choose at least one distinct dice type');
+    const templates = types.map((type) => createTextureTemplate(type, options.size === undefined ? {} : { size: options.size }));
+    const manifest = {
+        schemaVersion: 1,
+        id,
+        name: id,
+        material: { roughness: 0.7, metalness: 0 },
+        dice: Object.fromEntries(templates.map((template) => [
+            template.type,
+            { unwrap: `${template.type}.uv.json`, baseColor: `${template.type}.svg` },
+        ])),
+    };
+    await writeDirectory(options.outputDirectory, options.overwrite ?? false, async (directory) => {
+        await Promise.all(templates.flatMap((template) => [
+            writeFile(join(directory, `${template.type}.svg`), template.svg),
+            writeFile(join(directory, `${template.type}.uv.json`), `${JSON.stringify(template.unwrap, null, 2)}\n`),
+        ]));
+        await writeFile(join(directory, 'skin-set.source.json'), `${JSON.stringify(manifest, null, 2)}\n`);
+    });
+    return manifest;
+}
+const layer = (id, contents) => `<g id="${id}" inkscape:groupmode="layer" inkscape:label="${id}">${contents.join('')}</g>`;

package/dist/tools/types.d.ts

@@ -0,0 +1,40 @@
+import type { DiceAssetCatalogManifest, DiceMaterialDefinition, DiceSurfaceUnwrap } from '../index.js';
+export declare const TEXTURE_TEMPLATE_TYPES: readonly ['d4', 'd6', 'd8', 'd10', 'd12', 'd20', 'd100', 'd66'];
+export type TextureTemplateType = (typeof TEXTURE_TEMPLATE_TYPES)[number];
+export interface TextureTemplate {
+    readonly type: TextureTemplateType;
+    readonly unwrap: DiceSurfaceUnwrap;
+    readonly svg: string;
+}
+export interface TextureSourceEntry {
+    readonly unwrap: string;
+    readonly baseColor: string;
+    readonly normal?: string;
+    readonly orm?: string;
+}
+export interface TexturedSkinSetSource {
+    readonly schemaVersion: 1;
+    readonly id: string;
+    readonly name?: string;
+    readonly material?: Omit<DiceMaterialDefinition, 'id'>;
+    readonly dice: Partial<Readonly<Record<TextureTemplateType, TextureSourceEntry>>>;
+}
+export interface WriteTextureTemplatesOptions {
+    readonly outputDirectory: string;
+    readonly types?: readonly TextureTemplateType[];
+    readonly id?: string;
+    readonly size?: number;
+    /** Replace the entire output directory after successful preparation. */
+    readonly overwrite?: boolean;
+}
+export interface BuildTexturedSkinSetOptions {
+    readonly input: string;
+    readonly outputDirectory: string;
+    readonly ktxExecutable?: string;
+    /** Replace the entire output directory only after a successful build. */
+    readonly overwrite?: boolean;
+}
+export interface BuiltTexturedSkinSet {
+    readonly outputDirectory: string;
+    readonly catalog: DiceAssetCatalogManifest;
+}

package/dist/tools/types.js

@@ -0,0 +1,10 @@
+export const TEXTURE_TEMPLATE_TYPES = [
+    'd4',
+    'd6',
+    'd8',
+    'd10',
+    'd12',
+    'd20',
+    'd100',
+    'd66',
+];

package/dist/tools/write-directory.d.ts

@@ -0,0 +1,2 @@
+/** Stage beside the destination so the final rename stays on the same filesystem. */
+export declare function writeDirectory(destination: string, overwrite: boolean, write: (directory: string) => Promise<void>): Promise<void>;

package/dist/tools/write-directory.js

@@ -0,0 +1,56 @@
+import { lstat, mkdir, mkdtemp, rename, rm } from 'node:fs/promises';
+import { basename, dirname, resolve } from 'node:path';
+/** Stage beside the destination so the final rename stays on the same filesystem. */
+export async function writeDirectory(destination, overwrite, write) {
+    const output = resolve(destination), parent = dirname(output);
+    if (output === parent)
+        throw new Error('Output must not be a filesystem root');
+    await mkdir(parent, { recursive: true });
+    const lock = `${output}.dice-assets-lock`;
+    try {
+        await mkdir(lock);
+    }
+    catch {
+        throw new Error(`Output is locked: ${output}`);
+    }
+    let staging, backup;
+    try {
+        const existing = await lstat(output).catch((error) => {
+            if (isMissing(error))
+                return undefined;
+            throw error;
+        });
+        if (existing !== undefined &&
+            (!overwrite || !existing.isDirectory() || existing.isSymbolicLink()))
+            throw new Error(`Output already exists; use overwrite only for a disposable output directory: ${output}`);
+        staging = await mkdtemp(resolve(parent, `.${basename(output)}-staging-`));
+        await write(staging);
+        if (existing !== undefined) {
+            backup = `${staging}-previous`;
+            await rename(output, backup);
+        }
+        try {
+            await rename(staging, output);
+            staging = undefined;
+        }
+        catch (error) {
+            if (backup !== undefined) {
+                await rename(backup, output);
+                backup = undefined;
+            }
+            throw error;
+        }
+        if (backup !== undefined) {
+            await rm(backup, { recursive: true, force: true });
+            backup = undefined;
+        }
+    }
+    finally {
+        if (staging !== undefined)
+            await rm(staging, { recursive: true, force: true });
+        await rm(lock, { recursive: true, force: true });
+    }
+}
+function isMissing(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}

package/dist/types.d.ts

@@ -1,3 +1,14 @@
+export interface DiceSurfaceUnwrap {
+    readonly geometryId: string;
+    /** Normalized UVs (origin bottom-left), in each geometry face's vertex order. */
+    readonly faces: Readonly<Record<number, readonly (readonly [u: number, v: number])[]>>;
+    readonly preview?: DiceAssetReference;
+}
+export interface DiceSkinSetDefinition {
+    readonly id: string;
+    readonly name?: string;
+    readonly skins: Readonly<Record<string, string>>;
+}
 export type DiceAssetMetadataValue = string | number | boolean;
 export interface DiceAssetReference {
     readonly uri: string;
@@ -46,6 +57,7 @@ export interface DiceMaterialDefinition {
     readonly metadata?: Readonly<Record<string, DiceAssetMetadataValue>>;
 }
 export interface DicePatternDefinition {
+    readonly unwrap?: DiceSurfaceUnwrap;
     readonly id: string;
     readonly baseColor: RuntimeTextureReference;
     readonly normal?: RuntimeTextureReference;
@@ -85,6 +97,7 @@ export interface DiceSkinDefinition {
 }
 export interface DiceAssetCatalogManifest {
     readonly schemaVersion: 1;
+    readonly skinSets?: readonly DiceSkinSetDefinition[];
     readonly audioSprites?: readonly AudioSpriteManifest[];
     readonly audioBanks?: readonly AudioBankDefinition[];
     readonly materials?: readonly DiceMaterialDefinition[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dice-o-rolla/dice-assets",
-  "version": "0.4.0",
-  "description": "Optional Web Audio and KTX2/PBR asset system for Dice O Rolla.",
+  "version": "0.5.0",
+  "description": "Web Audio and KTX2/PBR assets with texture authoring API and CLI for Dice O Rolla.",
   "keywords": [
     "assets",
     "dice",
@@ -19,6 +19,9 @@
     "url": "https://github.com/creepiest-space/dice-o-rolla.git",
     "directory": "packages/dice-assets"
   },
+  "bin": {
+    "dice-assets": "./dist/tools/cli.js"
+  },
   "files": [
     "dist",
     "assets/runtime",
@@ -36,15 +39,24 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./catalog.json": "./assets/runtime/catalog.json"
+    "./catalog.json": "./assets/runtime/catalog.json",
+    "./tools": {
+      "types": "./dist/tools/index.d.ts",
+      "import": "./dist/tools/index.js",
+      "default": "./dist/tools/index.js"
+    }
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@dice-o-rolla/dice-renderer-three": "0.4.0",
+    "@dice-o-rolla/dice-geometry": "0.5.0",
+    "@dice-o-rolla/dice-renderer": "0.5.0",
+    "@dice-o-rolla/dice-renderer-three": "0.5.0",
+    "@resvg/resvg-js": "^2.6.2",
     "@types/three": "^0.185.0",
+    "@xmldom/xmldom": "^0.9.12",
     "three": "^0.185.0"
   },
   "engines": {