@nodecraft/rendermite 1.1.4 → 1.2.1

package/dist/export-DY5sGwt0.js

@@ -0,0 +1,790 @@
+import { t as packAtlas } from "./atlas-pack-CoOih7By.js";
+import { n as ResourceLocator } from "./locator-COMEtEn9.js";
+import { n as blockEntityGeometry, r as synthesizeVariants, t as INVISIBLE_BLOCKS } from "./block-entities-xv3bQpEX.js";
+import { a as parseBlockState, n as collectModels } from "./blockstate-eval-BRQ3NWY2.js";
+import { a as salvageJson, i as resolveTexture, t as ModelLoader } from "./loader-C-NuJaEi.js";
+import { n as buildObjMesh } from "./obj-mesh-rnYbSbpv.js";
+import { t as buildBlockTints } from "./tints-a9FWZLma.js";
+import { t as loadAtlasResolver } from "./registry-DlduyjtM.js";
+import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-CYbAkWuT.js";
+import { n as TextureLoader } from "./loader-C18GpurU.js";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import sharp from "sharp";
+//#region src/blocks/export.ts
+/**
+* Block pack export: block geometry and textures as data, for a renderer that
+* draws blocks itself rather than consuming finished icons.
+*
+* Everything above the rasterizer is reused unchanged — jar layering, parent
+* chain flattening, `#texture` resolution, atlas sources — and the output is
+* flat: a stitched atlas plus JSON that names sprites, baked elements and the
+* blockstate → model mapping with nothing left to resolve at runtime.
+*
+* Scope is Java Edition, 1.13 and up (see docs/block-pack-export.md). Nothing
+* here is version-gated: 1.13+ sits entirely inside the `models` and `modern`
+* eras, so `prepareVersionResources` layers the jar and little else.
+*/
+/** `render_type` values collapsed onto the pack's three layers. */
+const RENDER_TYPES = {
+	solid: "solid",
+	cutout: "cutout",
+	cutout_mipped: "cutout",
+	cutout_mipped_all: "cutout",
+	tripwire: "cutout",
+	translucent: "translucent",
+	translucent_moving_block: "translucent"
+};
+/**
+* A sprite whose strip is longer than this exports as its first frame only.
+* A broken `.mcmeta` can claim thousands of frames, and packing them would
+* blow the atlas out for one texture.
+*/
+const MAX_FRAMES_PER_SPRITE = 256;
+const FACE_DIRECTIONS = /* @__PURE__ */ new Set([
+	"down",
+	"up",
+	"north",
+	"south",
+	"west",
+	"east"
+]);
+/** Old models spell the vertical faces `bottom`/`top` in `cullface`. */
+const CULLFACE_ALIASES = {
+	bottom: "down",
+	top: "up"
+};
+/**
+* Vanilla's own id for the missing-texture sprite. A face whose texture does
+* not resolve is drawn by the game in black and magenta rather than skipped —
+* Blockbench leaves `"texture": "#missing"` on unassigned faces and mods ship
+* models naming textures they forgot to include. Dropping those faces would
+* put holes in geometry the player can see, and would read as our bug rather
+* than the mod's.
+*/
+const MISSING_SPRITE = "minecraft:missingno";
+/**
+* Fluids are blocks in `blockstates.json` but the game meshes them in code, so
+* their models state nothing and their textures would otherwise never reach the
+* atlas — leaving a consumer that has to mesh fluids itself with no pixels to do
+* it from.
+*
+* Which textures those are is read off the files rather than listed: a fluid's
+* two frames are `<name>_still` and `<name>_flow` (or `_flowing`) by a
+* convention every loader follows, and mods put them wherever they like —
+* Create under `fluid/`, Immersive Engineering under `block/fluid/`, Mekanism
+* under `liquid/`. A vanilla-only list would have missed all of them.
+*/
+const FLUID_SUFFIX = /_(?:still|flow|flowing)$/;
+/** Sampled where water meets a non-opaque neighbour; matches no suffix. */
+const EXTRA_FLUID_SPRITES = ["minecraft:block/water_overlay"];
+/** `MissingTextureAtlasSprite`: 16x16, black and magenta in 8px quarters. */
+function missingTexture() {
+	const size = 16;
+	const data = /* @__PURE__ */ new Uint8ClampedArray(1024);
+	for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
+		const magenta = x < 8 !== y < 8;
+		const offset = (y * size + x) * 4;
+		data[offset] = magenta ? 248 : 0;
+		data[offset + 1] = 0;
+		data[offset + 2] = magenta ? 248 : 0;
+		data[offset + 3] = 255;
+	}
+	return {
+		width: size,
+		height: size,
+		data
+	};
+}
+/**
+* Vanilla's `BlockElement.uvsByFace`: the UV a face gets when the model states
+* none. Deliberately not `render/geometry.ts`'s auto-UVs — those are in the
+* rasterizer's own unflipped convention, and the pack has to speak the same
+* language a model file's explicit `uv` does.
+*/
+function defaultFaceUv(direction, from, to) {
+	switch (direction) {
+		case "down": return [
+			from[0],
+			16 - to[2],
+			to[0],
+			16 - from[2]
+		];
+		case "up": return [
+			from[0],
+			from[2],
+			to[0],
+			to[2]
+		];
+		case "north": return [
+			16 - to[0],
+			16 - to[1],
+			16 - from[0],
+			16 - from[1]
+		];
+		case "south": return [
+			from[0],
+			16 - to[1],
+			to[0],
+			16 - from[1]
+		];
+		case "west": return [
+			from[2],
+			16 - to[1],
+			to[2],
+			16 - from[1]
+		];
+		case "east": return [
+			16 - to[2],
+			16 - to[1],
+			16 - from[2],
+			16 - from[1]
+		];
+	}
+}
+/**
+* Alpha decides the render layer: vanilla assets do not state cutout versus
+* translucent (`render_type` is a loader extension adopted only recently), and
+* inferring it covers mods for free.
+*/
+function inferRenderLayer(frames) {
+	let sawHole = false;
+	for (const frame of frames) for (let offset = 3; offset < frame.data.length; offset += 4) {
+		const alpha = frame.data[offset];
+		if (alpha === 0) sawHole = true;
+		else if (alpha !== 255) return "translucent";
+	}
+	return sawHole ? "cutout" : "solid";
+}
+function sortedByKey(entries) {
+	return Object.fromEntries(Object.entries(entries).toSorted(([left], [right]) => left.localeCompare(right)));
+}
+/**
+* Serialize a definition, keeping only the variants whose model was exported.
+* Returns null when that leaves nothing — the consumer must never be handed a
+* model id the pack does not carry.
+*/
+/**
+* Shifts a vendored model's boxes without touching anything else. The array is
+* returned as-is when there is nothing to shift, because models loaded from a
+* shared parent hand out the same element array and callers rely on that.
+*/
+function translateElements(elements, offset) {
+	if (offset === void 0) return elements;
+	const move = (point) => [
+		point[0] + offset[0],
+		point[1] + offset[1],
+		point[2] + offset[2]
+	];
+	return elements.map((element) => {
+		const rotation = element.rotation;
+		return {
+			...element,
+			from: move(element.from),
+			to: move(element.to),
+			...rotation && { rotation: {
+				...rotation,
+				origin: move(rotation.origin)
+			} }
+		};
+	});
+}
+function serializeBlockState(definition, exported) {
+	const cases = [];
+	for (const entry of definition.cases) {
+		const apply = entry.apply.filter((variant) => exported(variant.model));
+		if (apply.length === 0) continue;
+		cases.push({
+			when: entry.when,
+			apply: apply.map((variant) => {
+				return {
+					model: variant.model,
+					...variant.x !== 0 && { x: variant.x },
+					...variant.y !== 0 && { y: variant.y },
+					...variant.z !== 0 && { z: variant.z },
+					...variant.uvlock && { uvlock: true },
+					...variant.weight !== 1 && { weight: variant.weight }
+				};
+			})
+		});
+	}
+	if (cases.length === 0) return null;
+	return definition.kind === "variants" ? { variants: cases } : { multipart: cases };
+}
+/**
+* Any texture the model binds, for a model that declares no `particle`. Ordered
+* by the chain's own key order so a run is reproducible, and `particle` itself
+* is not a candidate: it was already tried.
+*/
+function firstBoundTexture(model) {
+	for (const name of Object.keys(model.textures)) {
+		if (name === "particle") continue;
+		const resolved = resolveTexture(model, `#${name}`);
+		if (resolved !== null) return resolved;
+	}
+	return null;
+}
+/**
+* The block's own item model, baked, for a block model that draws nothing.
+*
+* A mod that builds a block's shape in Java still has to put something in the
+* inventory, so it ships an item model with real geometry, and that is the
+* closest the assets come to describing the block: Ender IO's conduit is a cube
+* of its own texture, AE2's formed quantum ring is the ring, MoreRed's wire is
+* the cross it draws with nothing connected. Flat icons fall out on their own,
+* since `item/generated` states no elements.
+*
+* Null unless the substitute is whole: a part-magenta stand-in reads as a broken
+* texture, which is worse than the recorded gap it replaces.
+*/
+async function itemModelSubstitute(blockId, resources, models) {
+	const block = ResourceLocator.tryParse(blockId);
+	if (block === null) return null;
+	const item = new ResourceLocator(block.namespace, `item/${block.path}`);
+	if (!await resources.hasResource("model", item)) return null;
+	let resolved;
+	try {
+		resolved = await models.load(item.toString());
+	} catch {
+		return null;
+	}
+	const { emitted, sprites, tintIndices } = bakeModel(item.toString(), resolved, []);
+	if (emitted.elements.length === 0) return null;
+	if ((await Promise.all([...sprites].map(async (sprite) => sprite !== MISSING_SPRITE && await resources.hasResource("texture", ResourceLocator.parse(sprite))))).includes(false)) return null;
+	return {
+		id: item.toString(),
+		emitted,
+		sprites,
+		tintIndices
+	};
+}
+/** Bake one flattened model into pack form, reporting every face it loses. */
+function bakeModel(id, model, failures) {
+	const sprites = /* @__PURE__ */ new Set();
+	const tintIndices = /* @__PURE__ */ new Set();
+	const elements = [];
+	for (const element of model.elements) {
+		const faces = {};
+		for (const [name, face] of Object.entries(element.faces)) {
+			if (!face || !FACE_DIRECTIONS.has(name)) continue;
+			const direction = name;
+			const texture = resolveTexture(model, face.texture);
+			if (texture === null) failures.push({
+				id,
+				kind: "texture",
+				reason: `unresolved texture ${face.texture} on ${direction}; using the missing-texture sprite`
+			});
+			const sprite = texture === null ? MISSING_SPRITE : texture.toString();
+			sprites.add(sprite);
+			const cullRaw = typeof face.cullface === "string" ? face.cullface : null;
+			const cullface = cullRaw === null ? void 0 : CULLFACE_ALIASES[cullRaw] ?? (FACE_DIRECTIONS.has(cullRaw) ? cullRaw : void 0);
+			if (typeof face.tintindex === "number" && face.tintindex >= 0) tintIndices.add(face.tintindex);
+			faces[direction] = {
+				sprite,
+				uv: face.uv ?? defaultFaceUv(direction, element.from, element.to),
+				...face.rotation && { rotation: face.rotation },
+				...typeof face.tintindex === "number" && face.tintindex >= 0 && { tintindex: face.tintindex },
+				...cullface !== void 0 && { cullface }
+			};
+		}
+		if (Object.keys(faces).length === 0) continue;
+		elements.push({
+			from: element.from,
+			to: element.to,
+			...element.rotation && { rotation: element.rotation },
+			...element.shade === false && { shade: false },
+			faces
+		});
+	}
+	const renderType = model.renderType === null ? void 0 : RENDER_TYPES[model.renderType];
+	const particle = resolveTexture(model, "#particle") ?? (elements.length === 0 ? firstBoundTexture(model) : null);
+	if (particle !== null) sprites.add(particle.toString());
+	return {
+		emitted: {
+			ao: model.ambientOcclusion,
+			elements,
+			...particle !== null && { particle: particle.toString() },
+			...renderType !== void 0 && { renderType },
+			...model.splitParts && { multiblock: model.splitParts }
+		},
+		sprites,
+		tintIndices
+	};
+}
+async function exportBlockPack(options) {
+	const { output, version } = options;
+	const resources = options.builtin ? new LayeredResourceManager([options.resources, new FolderResourceManager(options.builtin)]) : options.resources;
+	const namespaces = options.namespaces ?? ["minecraft"];
+	const failures = [];
+	const report = (stage, done, total) => options.onProgress?.(stage, done, total);
+	const textures = new TextureLoader(resources);
+	textures.setAtlasResolver(await loadAtlasResolver(resources, (locator) => textures.load(locator)));
+	const models = new ModelLoader(resources);
+	const definitions = /* @__PURE__ */ new Map();
+	const blockModels = /* @__PURE__ */ new Map();
+	const modelRefs = /* @__PURE__ */ new Set();
+	const blockLocators = [];
+	for (const namespace of namespaces) blockLocators.push(...await resources.listResources("blockstate", namespace));
+	let done = 0;
+	for (const locator of blockLocators) {
+		const id = locator.toString();
+		report("blockstates", ++done, blockLocators.length);
+		const raw = await resources.getResource("blockstate", locator);
+		if (raw === null) {
+			failures.push({
+				id,
+				kind: "blockstate",
+				reason: "listed but unreadable"
+			});
+			continue;
+		}
+		try {
+			const text = raw.toString("utf8");
+			let json;
+			try {
+				json = JSON.parse(text);
+			} catch {
+				json = salvageJson(text);
+			}
+			const definition = parseBlockState(locator.namespace, json, id, {
+				onCaseError: (reason) => {
+					failures.push({
+						id,
+						kind: "blockstate",
+						reason: `${reason}; case dropped`
+					});
+				},
+				onNote: (reason) => {
+					failures.push({
+						id,
+						kind: "blockstate",
+						reason
+					});
+				}
+			});
+			const references = collectModels(definition);
+			definitions.set(id, definition);
+			blockModels.set(id, references);
+			for (const model of references) modelRefs.add(model);
+		} catch (err) {
+			failures.push({
+				id,
+				kind: "blockstate",
+				reason: err.message
+			});
+		}
+	}
+	const emittedModels = {};
+	const modelTintIndices = /* @__PURE__ */ new Map();
+	const spriteIds = /* @__PURE__ */ new Set();
+	done = 0;
+	for (const reference of [...modelRefs].toSorted((left, right) => left.localeCompare(right))) {
+		report("models", ++done, modelRefs.size);
+		let resolved;
+		try {
+			resolved = await models.load(reference);
+		} catch (err) {
+			failures.push({
+				id: reference,
+				kind: "model",
+				reason: err.message
+			});
+			continue;
+		}
+		const { emitted, sprites, tintIndices } = bakeModel(reference, resolved, failures);
+		if (resolved.splitParts) failures.push({
+			id: reference,
+			kind: "geometry",
+			reason: `split multiblock spanning ${resolved.splitParts.length} block positions; the pack carries the whole mesh, since which slice a position draws lives in the block entity`
+		});
+		if (resolved.obj) try {
+			const mesh = await buildObjMesh(resolved, resources, MISSING_SPRITE);
+			if (mesh) {
+				emitted.mesh = mesh.groups;
+				for (const group of mesh.groups) sprites.add(group.sprite);
+				for (const material of mesh.unresolved) failures.push({
+					id: reference,
+					kind: "texture",
+					reason: `OBJ material ${material} resolves to no texture; using the missing-texture sprite`
+				});
+				if (mesh.conditional && mesh.available.length > 1) failures.push({
+					id: reference,
+					kind: "geometry",
+					reason: `the loader picks between this OBJ's ${mesh.available.length} named objects at runtime (${mesh.available.slice(0, 8).join(", ")}${mesh.available.length > 8 ? ", …" : ""}) and nothing in the assets says which; the pack draws all of them, tagged with their object names`
+				});
+			}
+		} catch (err) {
+			failures.push({
+				id: reference,
+				kind: "geometry",
+				reason: err.message
+			});
+		}
+		emittedModels[reference] = emitted;
+		modelTintIndices.set(reference, tintIndices);
+		for (const sprite of sprites) spriteIds.add(sprite);
+	}
+	for (const [id, references] of blockModels) {
+		if (references.some((reference) => {
+			const model = emittedModels[reference];
+			return model !== void 0 && (model.elements.length > 0 || model.mesh?.length);
+		})) continue;
+		const invisible = INVISIBLE_BLOCKS[id];
+		if (invisible !== void 0) {
+			failures.push({
+				id,
+				kind: "intentional",
+				reason: `empty on purpose: ${invisible}`
+			});
+			continue;
+		}
+		const geometry = await blockEntityGeometry(id, {
+			resources,
+			textures,
+			models
+		});
+		if (geometry === null) {
+			failures.push({
+				id,
+				kind: "geometry",
+				reason: "the game draws this block in code and no geometry is vendored for it"
+			});
+			continue;
+		}
+		const cases = [];
+		const substituted = [];
+		for (const shape of geometry.shapes) {
+			const textures = {
+				...geometry.textures,
+				...shape.textures
+			};
+			if ((await Promise.all(Object.values(textures).map(async (texture) => resources.hasResource("texture", ResourceLocator.parse(texture))))).includes(false)) continue;
+			let resolved;
+			try {
+				resolved = await models.load(shape.model);
+			} catch (err) {
+				failures.push({
+					id,
+					kind: "geometry",
+					reason: `substitute ${shape.model} did not load: ${err.message}`
+				});
+				continue;
+			}
+			const bound = {
+				...resolved,
+				textures: {
+					...resolved.textures,
+					...textures
+				},
+				elements: translateElements(resolved.elements, shape.translate)
+			};
+			const suffix = Object.values(shape.when ?? {}).join("_");
+			const substituteId = `rendermite:block/${ResourceLocator.parse(id).path}${suffix && `_${suffix}`}`;
+			const { emitted, sprites, tintIndices } = bakeModel(substituteId, bound, failures);
+			if (emitted.elements.length === 0) continue;
+			if ((await Promise.all([...sprites].map(async (sprite) => sprite !== MISSING_SPRITE && await resources.hasResource("texture", ResourceLocator.parse(sprite))))).includes(false)) {
+				failures.push({
+					id,
+					kind: "geometry",
+					reason: `substitute ${shape.model} left textures unresolved, so the block is left empty rather than part magenta`
+				});
+				continue;
+			}
+			const still = emitted.elements[0].faces.up?.sprite;
+			const flow = emitted.elements[0].faces.north?.sprite;
+			if (geometry.fluid !== void 0 && still !== void 0 && flow !== void 0) emitted.fluid = {
+				still,
+				flow,
+				...geometry.fluid
+			};
+			emittedModels[substituteId] = emitted;
+			modelTintIndices.set(substituteId, tintIndices);
+			substituted.push(substituteId);
+			for (const sprite of sprites) spriteIds.add(sprite);
+			for (const variant of synthesizeVariants(geometry.orient)) cases.push({
+				when: {
+					...shape.when,
+					...variant.when
+				},
+				apply: [{
+					model: substituteId,
+					x: variant.x,
+					y: variant.y,
+					z: 0,
+					uvlock: false,
+					weight: 1
+				}]
+			});
+		}
+		if (cases.length === 0) {
+			failures.push({
+				id,
+				kind: "geometry",
+				reason: `the game draws this block in code; vendored ${geometry.shapes.map((shape) => shape.model).join(", ")} could not be bound to it`
+			});
+			continue;
+		}
+		definitions.set(id, {
+			kind: "variants",
+			cases
+		});
+		blockModels.set(id, substituted);
+		failures.push({
+			id,
+			kind: "geometry",
+			reason: `the game draws this block in code; the pack substitutes vendored geometry from ${geometry.shapes.map((shape) => shape.model).join(", ")} and synthesises the orientation variants the blockstate does not carry`
+		});
+	}
+	const adoptSubstitute = (substitute) => {
+		emittedModels[substitute.id] = substitute.emitted;
+		modelTintIndices.set(substitute.id, substitute.tintIndices);
+		for (const sprite of substitute.sprites) spriteIds.add(sprite);
+		return substitute.id;
+	};
+	for (const [id, references] of blockModels) {
+		if (INVISIBLE_BLOCKS[id] !== void 0) continue;
+		const empty = references.filter((reference) => {
+			const model = emittedModels[reference];
+			return model === void 0 || model.elements.length === 0 && !model.mesh?.length;
+		});
+		if (empty.length === 0) continue;
+		const substitute = await itemModelSubstitute(id, resources, models);
+		if (substitute === null) continue;
+		const stood = adoptSubstitute(substitute);
+		for (const part of definitions.get(id)?.cases ?? []) for (const variant of part.apply) if (empty.includes(variant.model)) variant.model = stood;
+		blockModels.set(id, [...references.filter((reference) => !empty.includes(reference)), stood]);
+		const drawnInCode = empty.length === references.length ? "this block" : empty.join(", ");
+		failures.push({
+			id,
+			kind: "geometry",
+			reason: `the game draws ${drawnInCode} in code; the pack substitutes the block's own item model ${stood}, which carries the shape but not the orientation or connections`
+		});
+	}
+	const blockStates = {};
+	for (const [id, definition] of definitions) {
+		const serialized = serializeBlockState(definition, (model) => emittedModels[model] !== void 0);
+		if (serialized === null) {
+			failures.push({
+				id,
+				kind: "blockstate",
+				reason: "every case named a model that could not be exported"
+			});
+			blockModels.delete(id);
+			continue;
+		}
+		blockStates[id] = serialized;
+	}
+	for (const locator of blockLocators) {
+		const id = locator.toString();
+		if (blockStates[id] !== void 0 || INVISIBLE_BLOCKS[id] !== void 0) continue;
+		const substitute = await itemModelSubstitute(id, resources, models);
+		if (substitute === null) continue;
+		const stood = adoptSubstitute(substitute);
+		blockStates[id] = { variants: [{
+			when: {},
+			apply: [{ model: stood }]
+		}] };
+		blockModels.set(id, [stood]);
+		failures.push({
+			id,
+			kind: "geometry",
+			reason: `no case of this blockstate could be read; the pack substitutes the block's own item model ${stood}, which carries the shape but not the orientation`
+		});
+	}
+	for (const namespace of namespaces) for (const locator of await resources.listResources("texture", namespace)) if (FLUID_SUFFIX.test(locator.path)) spriteIds.add(locator.toString());
+	for (const extra of EXTRA_FLUID_SPRITES) if (await resources.hasResource("texture", ResourceLocator.parse(extra))) spriteIds.add(extra);
+	const loaded = [];
+	const missingSprites = /* @__PURE__ */ new Set();
+	done = 0;
+	for (const id of [...spriteIds].toSorted((left, right) => left.localeCompare(right))) {
+		report("sprites", ++done, spriteIds.size);
+		if (id === MISSING_SPRITE) continue;
+		let animated;
+		try {
+			animated = await textures.loadAnimated(ResourceLocator.parse(id));
+		} catch (err) {
+			failures.push({
+				id,
+				kind: "sprite",
+				reason: err.message
+			});
+			missingSprites.add(id);
+			continue;
+		}
+		if (!animated) {
+			failures.push({
+				id,
+				kind: "sprite",
+				reason: "texture not found"
+			});
+			missingSprites.add(id);
+			continue;
+		}
+		const overlong = animated.frameCount > MAX_FRAMES_PER_SPRITE;
+		if (overlong) failures.push({
+			id,
+			kind: "sprite",
+			reason: `${animated.frameCount} frames exceeds the ${MAX_FRAMES_PER_SPRITE} cap; exported static`
+		});
+		const starts = overlong ? [0] : animated.frameStartTicks();
+		const total = overlong ? 1 : animated.tickLength;
+		const sequence = starts.map((start, index) => {
+			return {
+				frame: animated.resolveFrame(start).frame,
+				time: (index + 1 < starts.length ? starts[index + 1] : total) - start
+			};
+		});
+		const frames = /* @__PURE__ */ new Map();
+		for (const entry of sequence) if (!frames.has(entry.frame)) frames.set(entry.frame, animated.frame(entry.frame));
+		loaded.push({
+			id,
+			frames,
+			sequence,
+			interpolate: animated.interpolated
+		});
+	}
+	spriteIds.add(MISSING_SPRITE);
+	loaded.push({
+		id: MISSING_SPRITE,
+		frames: /* @__PURE__ */ new Map([[0, missingTexture()]]),
+		sequence: [{
+			frame: 0,
+			time: 1
+		}],
+		interpolate: false
+	});
+	const packed = packAtlas(loaded.flatMap((sprite) => [...sprite.frames].map(([index, texture]) => {
+		return {
+			key: `${sprite.id}#${index}`,
+			texture
+		};
+	})), {
+		padding: options.padding,
+		maxPageSize: options.maxPageSize
+	});
+	for (const key of packed.oversized) {
+		const id = key.split("#", 1)[0];
+		if (!missingSprites.has(id)) {
+			failures.push({
+				id,
+				kind: "sprite",
+				reason: "sprite is larger than one atlas page; drawn as the missing texture"
+			});
+			missingSprites.add(id);
+		}
+	}
+	if (missingSprites.has(MISSING_SPRITE)) throw new Error("the missing-texture sprite does not fit an atlas page; maxPageSize is too small");
+	if (missingSprites.size > 0) for (const model of Object.values(emittedModels)) {
+		for (const element of model.elements) for (const face of Object.values(element.faces)) if (missingSprites.has(face.sprite)) face.sprite = MISSING_SPRITE;
+		for (const group of model.mesh ?? []) if (missingSprites.has(group.sprite)) group.sprite = MISSING_SPRITE;
+		if (model.particle !== void 0 && missingSprites.has(model.particle)) model.particle = MISSING_SPRITE;
+	}
+	for (const [id, model] of Object.entries(emittedModels)) {
+		const sprites = [...model.elements.flatMap((element) => Object.values(element.faces).map((face) => face.sprite)), ...(model.mesh ?? []).map((group) => group.sprite)];
+		if (sprites.length > 0 && sprites.every((sprite) => sprite === MISSING_SPRITE)) failures.push({
+			id,
+			kind: "texture",
+			reason: "every face uses the missing-texture sprite; the model binds none of the textures it names"
+		});
+		if (model.elements.length === 0 && !model.mesh?.length) failures.push({
+			id,
+			kind: "geometry",
+			reason: "model has no drawable elements"
+		});
+	}
+	const rects = new Map(packed.rects.map((rect) => [rect.key, rect]));
+	const emittedSprites = {};
+	for (const sprite of loaded) {
+		const first = rects.get(`${sprite.id}#${sprite.sequence[0].frame}`);
+		if (!first) continue;
+		const frames = [];
+		for (const entry of sprite.sequence) {
+			const rect = rects.get(`${sprite.id}#${entry.frame}`);
+			if (rect) frames.push({
+				page: rect.page,
+				x: rect.x,
+				y: rect.y,
+				time: entry.time
+			});
+		}
+		emittedSprites[sprite.id] = {
+			page: first.page,
+			x: first.x,
+			y: first.y,
+			w: first.width,
+			h: first.height,
+			layer: inferRenderLayer(sprite.frames.values().toArray()),
+			...frames.length === sprite.sequence.length && frames.length > 1 && { frames },
+			...sprite.interpolate && { interpolate: true }
+		};
+	}
+	const tints = await buildBlockTints(resources, textures);
+	for (const [block, references] of blockModels) {
+		const used = /* @__PURE__ */ new Set();
+		for (const reference of references) for (const index of modelTintIndices.get(reference) ?? []) used.add(index);
+		for (const index of used) if (tints.pack.blocks[block]?.[String(index)] === void 0) failures.push({
+			id: block,
+			kind: "tint",
+			reason: `tintindex ${index} is not in the tint table; exported untinted`
+		});
+	}
+	await mkdir(output, { recursive: true });
+	const hashes = {};
+	let writtenFiles = 0;
+	const emit = async (file, data) => {
+		const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+		const target = path.join(output, file);
+		await mkdir(path.dirname(target), { recursive: true });
+		await writeFile(target, buffer);
+		hashes[file] = createHash("sha256").update(buffer).digest("hex");
+		writtenFiles++;
+	};
+	const pageFiles = [];
+	for (const [index, page] of packed.pages.entries()) {
+		const file = `atlas-${index}.png`;
+		const raw = Buffer.from(page.data.buffer, page.data.byteOffset, page.data.byteLength);
+		await emit(file, await sharp(raw, { raw: {
+			width: page.width,
+			height: page.height,
+			channels: 4
+		} }).png({ compressionLevel: 9 }).toBuffer());
+		pageFiles.push({
+			file,
+			width: page.width,
+			height: page.height
+		});
+	}
+	for (const file of tints.files) await emit(file.path, file.data);
+	await emit("atlas.json", JSON.stringify({
+		padding: packed.padding,
+		pages: pageFiles,
+		sprites: sortedByKey(emittedSprites)
+	}));
+	await emit("models.json", JSON.stringify(sortedByKey(emittedModels)));
+	await emit("blockstates.json", JSON.stringify(sortedByKey(blockStates)));
+	await emit("tints.json", JSON.stringify(tints.pack));
+	failures.sort((left, right) => left.id.localeCompare(right.id) || left.kind.localeCompare(right.kind));
+	await emit("failures.json", JSON.stringify(failures, null, "	"));
+	const counts = {
+		blocks: Object.keys(blockStates).length,
+		models: Object.keys(emittedModels).length,
+		sprites: Object.keys(emittedSprites).length,
+		pages: packed.pages.length,
+		failures: failures.length
+	};
+	await emit("meta.json", JSON.stringify({
+		generator: "rendermite",
+		version,
+		namespaces,
+		counts,
+		hashes: sortedByKey(hashes)
+	}, null, "	"));
+	return {
+		...counts,
+		writtenFiles,
+		failures
+	};
+}
+//#endregion
+export { exportBlockPack as t };