@nodecraft/rendermite 1.7.4 → 1.9.0

package/dist/datapack-D6eH46ay.js

@@ -0,0 +1,71 @@
+//#region src/blocks/datapack.ts
+/**
+* 1.21 renamed the tag folders to the registry's singular name. Normalised here so a consumer asks
+* for `block` at every version rather than knowing which spelling a jar used.
+*/
+const PLURAL_TAG_FOLDERS = {
+	blocks: "block",
+	items: "item",
+	fluids: "fluid",
+	entity_types: "entity_type",
+	game_events: "game_event",
+	functions: "function"
+};
+/** `advancements/` before 1.21, `advancement/` from it. */
+const ADVANCEMENT_FOLDER = /^advancements?\//;
+async function readJson(resources, locator) {
+	const raw = await resources.getResource("data", locator);
+	if (raw === null) return null;
+	try {
+		return JSON.parse(raw.toString("utf8"));
+	} catch {
+		return null;
+	}
+}
+async function collectDatapack(resources, namespaces) {
+	const tags = {};
+	const advancements = {};
+	const unreadable = [];
+	for (const namespace of namespaces) {
+		const listed = await resources.listResources("data", namespace);
+		for (const locator of listed.toSorted((left, right) => left.path.localeCompare(right.path))) {
+			const tag = /^tags\/(.+)$/.exec(locator.path);
+			if (tag) {
+				const rest = tag[1];
+				const split = /^(worldgen\/[^/]+)\/(.+)$/.exec(rest) ?? /^([^/]+)\/(.+)$/.exec(rest);
+				if (!split) continue;
+				const registry = PLURAL_TAG_FOLDERS[split[1]] ?? split[1];
+				const json = await readJson(resources, locator);
+				if (!Array.isArray(json?.values)) {
+					unreadable.push(locator.toString());
+					continue;
+				}
+				const values = json.values.flatMap((value) => {
+					if (typeof value === "string") return [value];
+					const id = value?.id;
+					return typeof id === "string" ? [id] : [];
+				});
+				tags[registry] ??= {};
+				tags[registry][`${namespace}:${split[2]}`] = values;
+				continue;
+			}
+			if (ADVANCEMENT_FOLDER.test(locator.path)) {
+				const name = locator.path.replace(ADVANCEMENT_FOLDER, "");
+				if (name.startsWith("recipes/")) continue;
+				const json = await readJson(resources, locator);
+				if (typeof json?.criteria !== "object" || json.criteria === null) {
+					unreadable.push(locator.toString());
+					continue;
+				}
+				advancements[`${namespace}:${name}`] = Object.keys(json.criteria);
+			}
+		}
+	}
+	return {
+		tags,
+		advancements,
+		unreadable
+	};
+}
+//#endregion
+export { collectDatapack as t };

package/dist/{descriptor-JyXhfd-c.js → descriptor-Dz2cR-BH.js}

@@ -1,6 +1,6 @@
-import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
-import { t as JarResourceManager } from "./jar-W2cV2ZVO.js";
 import { n as MapResourceManager, t as KindFilteredResourceManager } from "./synthetic-rc9BPT4P.js";
+import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-D6zXmFrO.js";
+import { t as JarResourceManager } from "./jar-DvofBm71.js";
 //#region src/resources/descriptor.ts
 /**
 * Serializable descriptions of a resource tree, so the same layered tree can be

package/dist/{discovery-Cmir3QfC.d.ts → discovery-DWe_kX8W.d.ts}

@@ -1,4 +1,4 @@
-import { a as ResourceManager } from "./manager-exOIcdyx.js";
+import { a as ResourceManager } from "./manager-Ct0dEOMg.js";
 import { i as ItemRenderInstruction, r as ItemProperties } from "./definition-ricL7Jqf.js";
 //#region src/items/discovery.d.ts
 declare class ItemResolutionError extends Error {}

package/dist/dynamic/generators.d.ts

@@ -1,2 +1,2 @@
-import { a as TRIM_DARKER_MATERIALS, i as POTTERY_SHERDS, n as DynamicItem, o as TRIM_MATERIALS, r as DynamicResources, s as builtinDynamicResources, t as ARMOR_ITEM_TYPES } from "../generators-BnIzAftW.js";
+import { a as TRIM_DARKER_MATERIALS, i as POTTERY_SHERDS, n as DynamicItem, o as TRIM_MATERIALS, r as DynamicResources, s as builtinDynamicResources, t as ARMOR_ITEM_TYPES } from "../generators-hu_vk10m.js";
 export { ARMOR_ITEM_TYPES, DynamicItem, DynamicResources, POTTERY_SHERDS, TRIM_DARKER_MATERIALS, TRIM_MATERIALS, builtinDynamicResources };

package/dist/{encode-Br_vPrd8.d.ts → encode-BNEYHHR0.d.ts}

@@ -1,4 +1,4 @@
-import { n as FloatTexture } from "./blend-C5UYzink.js";
+import { n as FloatTexture } from "./blend-mJAeQB3C.js";
 //#region src/output/encode.d.ts
 interface EncodedIcon {
   png: Buffer;

package/dist/entities/classfile.d.ts

@@ -1,2 +1,2 @@
-import { a as parseClassFile, i as MethodInfo, n as Constant, r as ConstantTag, t as ClassFile } from "../classfile-BdLIk4Pe.js";
+import { a as parseClassFile, i as MethodInfo, n as Constant, r as ConstantTag, t as ClassFile } from "../classfile-CsLXlh5z.js";
 export { ClassFile, Constant, ConstantTag, MethodInfo, parseClassFile };

package/dist/entities/classfile.js

@@ -1,2 +1,2 @@
-import { t as parseClassFile } from "../classfile-Bo7FUrrD.js";
+import { t as parseClassFile } from "../classfile-CiIDF3vc.js";
 export { parseClassFile };

package/dist/entities/geo-model.d.ts

@@ -1,5 +1,5 @@
 import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
-import { t as ParsedGeo } from "../geo-C9QYeLVN.js";
+import { t as ParsedGeo } from "../geo-DsWwuC5o.js";
 //#region src/entities/geo-model.d.ts
 /**
  * Converts one parsed `.geo.json` into a model.

package/dist/entities/inherit.d.ts

@@ -1,6 +1,6 @@
+import { t as ClassFile } from "../classfile-CsLXlh5z.js";
 import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
-import { t as ClassFile } from "../classfile-BdLIk4Pe.js";
-import { t as ModelCode } from "../model-code-BY44ao27.js";
+import { t as ModelCode } from "../model-code-Csc3bs3h.js";
 //#region src/entities/inherit.d.ts
 interface Ancestry {
   /** The class and its ancestors by internal name, parsed. */

package/dist/entities/inherit.js

@@ -1,2 +1,2 @@
-import { n as extractInheritedModel, t as ancestryOf } from "../inherit-BYLi3Q28.js";
+import { n as extractInheritedModel, t as ancestryOf } from "../inherit-BUn0Cve9.js";
 export { ancestryOf, extractInheritedModel };

package/dist/entities/jar-classes.js

@@ -1,2 +1,2 @@
-import { n as layeredClasses, t as JarClassReader } from "../jar-classes-3GVCJZT7.js";
+import { n as layeredClasses, t as JarClassReader } from "../jar-classes-0wqWbTax.js";
 export { JarClassReader, layeredClasses };

package/dist/entities/link.d.ts

@@ -1,5 +1,5 @@
-import { t as Mappings } from "../mappings-DxX4KoZl.js";
-import { t as ClassFile } from "../classfile-BdLIk4Pe.js";
+import { t as ClassFile } from "../classfile-CsLXlh5z.js";
+import { t as Mappings } from "../mappings-DhOPQTgV.js";
 //#region src/entities/link.d.ts
 /**
  * Entity types whose renderer or model is not named after them. Values are class simple names to look

package/dist/entities/link.js

@@ -1,2 +1,2 @@
-import { a as linkEntityModel, i as classReader, n as RENDERER_ALIASES, o as normaliseModelName, r as buildModelNameIndex, t as NO_MODEL } from "../link-5GmBLTzk.js";
+import { a as linkEntityModel, i as classReader, n as RENDERER_ALIASES, o as normaliseModelName, r as buildModelNameIndex, t as NO_MODEL } from "../link-Cuhyrz07.js";
 export { NO_MODEL, RENDERER_ALIASES, buildModelNameIndex, classReader, linkEntityModel, normaliseModelName };

package/dist/entities/mappings.d.ts

@@ -1,2 +1,2 @@
-import { a as isObfuscated, c as resolveMappings, i as identityMappings, n as MappingsUnavailableError, o as loadMappings, r as downloadClientMappings, s as parseMappings, t as Mappings } from "../mappings-DxX4KoZl.js";
-export { Mappings, MappingsUnavailableError, downloadClientMappings, identityMappings, isObfuscated, loadMappings, parseMappings, resolveMappings };
+import { a as isObfuscated, c as remapDescriptor, i as identityMappings, l as resolveMappings, n as MappingsUnavailableError, o as loadMappings, r as downloadClientMappings, s as parseMappings, t as Mappings } from "../mappings-DhOPQTgV.js";
+export { Mappings, MappingsUnavailableError, downloadClientMappings, identityMappings, isObfuscated, loadMappings, parseMappings, remapDescriptor, resolveMappings };

package/dist/entities/mappings.js

@@ -1,2 +1,2 @@
-import { a as loadMappings, i as isObfuscated, n as downloadClientMappings, o as parseMappings, r as identityMappings, s as resolveMappings, t as MappingsUnavailableError } from "../mappings-BEPVaiwE.js";
-export { MappingsUnavailableError, downloadClientMappings, identityMappings, isObfuscated, loadMappings, parseMappings, resolveMappings };
+import { a as loadMappings, c as resolveMappings, i as isObfuscated, n as downloadClientMappings, o as parseMappings, r as identityMappings, s as remapDescriptor, t as MappingsUnavailableError } from "../mappings-DEl_7xxQ.js";
+export { MappingsUnavailableError, downloadClientMappings, identityMappings, isObfuscated, loadMappings, parseMappings, remapDescriptor, resolveMappings };

package/dist/entities/model-bytecode.d.ts

@@ -1,6 +1,11 @@
+import { t as ClassFile } from "../classfile-CsLXlh5z.js";
 import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
-import { t as ClassFile } from "../classfile-BdLIk4Pe.js";
 //#region src/entities/model-bytecode.d.ts
+/** Argument slot count and shape of a descriptor's parameter list. */
+declare function parseDescriptor(descriptor: string): {
+  args: string[];
+  returns: string;
+};
 /**
  * Extracts whatever geometry a class's methods build.
  *
@@ -43,4 +48,4 @@ interface Following {
 declare function extractArmourMesh(bytes: Uint8Array, following: Following): ExtractedModel;
 declare function extractModel(bytes: Uint8Array, following?: Following): ExtractedModel;
 //#endregion
-export { Following, extractArmourMesh, extractModel };
+export { Following, extractArmourMesh, extractModel, parseDescriptor };

package/dist/entities/model-bytecode.js

@@ -1,2 +1,2 @@
-import { n as extractModel, t as extractArmourMesh } from "../model-bytecode-B43uSqet.js";
-export { extractArmourMesh, extractModel };
+import { n as extractModel, r as parseDescriptor, t as extractArmourMesh } from "../model-bytecode-VaLUQfGO.js";
+export { extractArmourMesh, extractModel, parseDescriptor };

package/dist/entities/model-code.d.ts

@@ -1,2 +1,2 @@
-import { n as isModelCode, r as loadModelCode, t as ModelCode } from "../model-code-BY44ao27.js";
+import { n as isModelCode, r as loadModelCode, t as ModelCode } from "../model-code-Csc3bs3h.js";
 export { ModelCode, isModelCode, loadModelCode };

package/dist/entities/model-code.js

@@ -1,2 +1,2 @@
-import { n as loadModelCode, t as isModelCode } from "../model-code-1Vuk-zj_.js";
+import { n as loadModelCode, t as isModelCode } from "../model-code-DbN2uVhp.js";
 export { isModelCode, loadModelCode };

package/dist/{entity-models-DUKiHpn1.js → entity-models-BYAxrTsk.js}

@@ -1,11 +1,11 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
 import { t as findGeoForEntity } from "./entity-geo-DbTtMlPL.js";
 import { t as EQUIPMENT_SLOTS } from "./pack-format-BP5dJMYY.js";
-import { n as extractModel, t as extractArmourMesh } from "./model-bytecode-B43uSqet.js";
-import { n as extractInheritedModel, t as ancestryOf } from "./inherit-BYLi3Q28.js";
-import { a as linkEntityModel, i as classReader, r as buildModelNameIndex } from "./link-5GmBLTzk.js";
-import { s as resolveMappings, t as MappingsUnavailableError } from "./mappings-BEPVaiwE.js";
-import { n as loadModelCode } from "./model-code-1Vuk-zj_.js";
+import { n as extractModel, t as extractArmourMesh } from "./model-bytecode-VaLUQfGO.js";
+import { n as extractInheritedModel, t as ancestryOf } from "./inherit-BUn0Cve9.js";
+import { a as linkEntityModel, i as classReader, r as buildModelNameIndex } from "./link-Cuhyrz07.js";
+import { c as resolveMappings, t as MappingsUnavailableError } from "./mappings-DEl_7xxQ.js";
+import { n as loadModelCode } from "./model-code-DbN2uVhp.js";
 //#region src/blocks/entity-models.ts
 /**
 * Entity geometry for the pack: link each entity to the class that builds it, read that class's

package/dist/entity-sizes-CpO1gA7p.js

@@ -0,0 +1,194 @@
+import { t as parseClassFile } from "./classfile-CiIDF3vc.js";
+import { c as resolveMappings, t as MappingsUnavailableError } from "./mappings-DEl_7xxQ.js";
+//#region src/blocks/entity-sizes.ts
+/**
+* Each entity type's hitbox, read out of the code that registers it.
+*
+* `EntityType.Builder.of(Cow::new, CREATURE).sized(0.9F, 1.4F)` is the only place a cow's size is
+* stated, so a consumer drawing a stand-in box for a mob either reads it here or hardcodes a table
+* that is a release behind. The two floats are always pushed right before the call, and the name is
+* a string near it: before it in vanilla's `register("cow", …)`, after it in a mod's
+* `build("name")`, or before the lambda a `DeferredRegister.register("name", () -> …)` was handed.
+* A linear pass over each method finds all three without interpreting anything.
+*
+* 1.13 has no builder size (a mob set its own in its constructor) and no mappings to read the call by,
+* so it gets none. Sizes are the base ones: a baby or a large slime scales its own at runtime.
+*/
+/**
+* `sized` by every name a jar can call it: Mojang's (vanilla, NeoForge), Forge's SRG name, and
+* Fabric's intermediary one, since a mod jar keeps whichever its loader compiles against.
+*/
+const SIZED_NAMES = /* @__PURE__ */ new Set([
+	"sized",
+	"m_20699_",
+	"method_17687"
+]);
+/** Operand bytes after each opcode that has a fixed number, for walking a method without decoding it. */
+const OPERANDS = /* @__PURE__ */ new Map([
+	[16, 1],
+	[18, 1],
+	[21, 1],
+	[22, 1],
+	[23, 1],
+	[24, 1],
+	[25, 1],
+	[54, 1],
+	[55, 1],
+	[56, 1],
+	[57, 1],
+	[58, 1],
+	[169, 1],
+	[188, 1],
+	[17, 2],
+	[19, 2],
+	[20, 2],
+	[132, 2],
+	[167, 2],
+	[168, 2],
+	[198, 2],
+	[199, 2],
+	[178, 2],
+	[179, 2],
+	[180, 2],
+	[181, 2],
+	[182, 2],
+	[183, 2],
+	[184, 2],
+	[187, 2],
+	[189, 2],
+	[192, 2],
+	[193, 2],
+	[197, 3],
+	[185, 4],
+	[186, 4],
+	[200, 4],
+	[201, 4]
+]);
+/** Every instruction of a method, in order. */
+function* instructions(code) {
+	let at = 0;
+	while (at < code.length) {
+		const op = code[at];
+		const start = at;
+		at++;
+		if (op >= 153 && op <= 166) at += 2;
+		else if (op === 170 || op === 171) {
+			at += (4 - at % 4) % 4;
+			const read = (offset) => code[offset] << 24 | code[offset + 1] << 16 | code[offset + 2] << 8 | code[offset + 3];
+			if (op === 170) {
+				const low = read(at + 4);
+				const high = read(at + 8);
+				at += 12 + (high - low + 1) * 4;
+			} else at += 8 + read(at + 4) * 8;
+		} else if (op === 196) at += code[at] === 132 ? 5 : 3;
+		else at += OPERANDS.get(op) ?? 0;
+		yield {
+			op,
+			index: op === 18 ? code[start + 1] : code[start + 1] << 8 | code[start + 2]
+		};
+	}
+}
+function looksLikeId(text) {
+	return /^[a-z0-9_.\-/]+(?::[a-z0-9_.\-/]+)?$/.test(text) && text.length < 128;
+}
+/** A float as Java wrote it: `0.6F` widens to 0.6000000238418579, and 0.6 is what the code says. */
+function float32(value) {
+	for (let digits = 1; digits < 10; digits++) {
+		const candidate = Number(value.toPrecision(digits));
+		if (Math.fround(candidate) === Math.fround(value)) return candidate;
+	}
+	return value;
+}
+async function collectEntitySizes(options) {
+	const sizes = /* @__PURE__ */ new Map();
+	const failures = [];
+	const names = await options.classes.list();
+	let mappings;
+	try {
+		({mappings} = await resolveMappings(options.version, options.cacheDir, async () => names));
+	} catch (err) {
+		if (!(err instanceof MappingsUnavailableError)) throw err;
+		failures.push({
+			id: options.version,
+			reason: `no entity sizes: ${err.message}`
+		});
+		return {
+			sizes,
+			failures
+		};
+	}
+	const originalName = (owner, name, descriptor) => mappings.nameOf?.get(`${owner.replaceAll("/", ".")}.${name}${descriptor}`) ?? name;
+	const parsed = [];
+	for (const name of names) {
+		const bytes = await options.classes.read(name);
+		if (!bytes) continue;
+		try {
+			parsed.push(parseClassFile(bytes));
+		} catch {}
+	}
+	const keyNames = /* @__PURE__ */ new Map();
+	const lambdaNames = /* @__PURE__ */ new Map();
+	for (const classFile of parsed) for (const method of classFile.methods) {
+		if (!method.code) continue;
+		let last = null;
+		for (const { op, index } of instructions(method.code)) if (op === 18 || op === 19) {
+			const literal = classFile.literal(index);
+			if (typeof literal === "string" && looksLikeId(literal)) last = literal;
+		} else if (op === 179 && last !== null && method.name === "<clinit>") {
+			const field = classFile.reference(index);
+			if (field && /ResourceKey;$|^Ljava\/lang\/String;$/.test(field.descriptor)) keyNames.set(`${field.owner}.${field.name}`, last);
+			last = null;
+		} else if (op === 186 && last !== null) {
+			const target = classFile.lambdaTarget(index);
+			if (target) lambdaNames.set(`${target.owner}.${target.name}${target.descriptor}`, last);
+		}
+	}
+	const idsByPath = /* @__PURE__ */ new Map();
+	for (const id of options.entityIds) {
+		const path = id.slice(id.indexOf(":") + 1);
+		idsByPath.set(path, [...idsByPath.get(path) ?? [], id]);
+	}
+	const vanillaClass = (name) => name.startsWith("net/minecraft/") || mappings.originalOf.has(name.replaceAll("/", "."));
+	const resolveId = (name, owner) => {
+		if (name.includes(":")) return options.entityIds.includes(name) ? name : null;
+		const candidates = idsByPath.get(name) ?? [];
+		const vanilla = vanillaClass(owner);
+		return candidates.find((id) => id.startsWith("minecraft:") === vanilla) ?? null;
+	};
+	for (const classFile of parsed) for (const method of classFile.methods) {
+		if (!method.code) continue;
+		let last = lambdaNames.get(`${classFile.thisClass}.${method.name}${method.descriptor}`) ?? null;
+		const floats = [];
+		let pending = null;
+		const settle = (name) => {
+			const id = pending && resolveId(name, classFile.thisClass);
+			if (pending && id && !sizes.has(id)) sizes.set(id, [float32(pending[0]), float32(pending[1])]);
+			pending = null;
+		};
+		for (const { op, index } of instructions(method.code)) if (op >= 11 && op <= 13) floats.push(op - 11);
+		else if (op === 18 || op === 19) {
+			const literal = classFile.literal(index);
+			if (typeof literal === "number" && classFile.constants[index]?.tag === "float") floats.push(literal);
+			else if (typeof literal === "string" && looksLikeId(literal)) {
+				if (pending) settle(literal);
+				last = literal;
+			}
+		} else if (op === 178) {
+			const field = classFile.reference(index);
+			const key = field && keyNames.get(`${field.owner}.${field.name}`);
+			if (key) last = key;
+		} else if (op === 182 || op === 185) {
+			const call = classFile.reference(index);
+			if (call && call.descriptor.startsWith("(FF)") && SIZED_NAMES.has(originalName(call.owner, call.name, call.descriptor)) && floats.length >= 2) {
+				pending = [floats.at(-2), floats.at(-1)];
+				if (last !== null) settle(last);
+			}
+		}
+	}
+	return {
+		sizes,
+		failures
+	};
+}
+//#endregion
+export { instructions as n, collectEntitySizes as t };

package/dist/{export-Ds1EelMa.js → export-CbG2Rx3i.js}

@@ -1,19 +1,24 @@
-import { r as buildBiomeClimates } from "./biomes-5ZwYxMYe.js";
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
+import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-D6zXmFrO.js";
+import { a as buildBiomeClimates } from "./biomes-BGOF6gRM.js";
 import { n as blockEntityGeometry, r as synthesizeVariants, t as INVISIBLE_BLOCKS } from "./block-entities-C807EY2I.js";
 import { a as parseBlockState, n as collectModels } from "./blockstate-eval-CV_LwUwj.js";
+import { t as collectDatapack } from "./datapack-D6eH46ay.js";
 import { a as salvageJson, i as resolveTexture, t as ModelLoader } from "./loader-qOH0Jynq.js";
 import { t as enderStorageBlockModel } from "./ender-storage-Dgomp6r2.js";
 import { t as collectEntities } from "./entities-rQ4TZjEo.js";
-import { n as collectEntityGeometry } from "./entity-models-DUKiHpn1.js";
+import { n as collectEntityGeometry } from "./entity-models-BYAxrTsk.js";
+import { t as collectEntitySizes } from "./entity-sizes-CpO1gA7p.js";
+import { t as collectGameRules } from "./game-rules-DuLlFc7o.js";
 import { t as geoBlockModel } from "./geo-blocks-W79q5A0f.js";
 import { n as discoverItems } from "./discovery-CD0QqxSF.js";
 import { t as collectItemSprites } from "./item-sprites-CwiEBEAJ.js";
+import { n as collectBlockLight } from "./light-CC3VMsjl.js";
 import { n as buildObjMesh } from "./obj-mesh-BFhtTBXX.js";
 import { n as buildSpriteSheet, t as MISSING_SPRITE } from "./sprite-sheet-LQAEtGkp.js";
+import { t as readBlockStates } from "./states-BvoZA-ql.js";
 import { n as buildBlockTints, t as UNREGISTERED_TINTS } from "./tints-Cl0r-Ol3.js";
 import { t as loadAtlasResolver } from "./registry-DafxsAhG.js";
-import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
 import { n as TextureLoader } from "./loader-CsgtBuBo.js";
 import path from "node:path";
 import { createHash } from "node:crypto";
@@ -693,7 +698,41 @@ async function exportBlockPack(options) {
 			});
 		}
 	}
-	const biomes = await buildBiomeClimates(resources, namespaces);
+	let lightPack = {};
+	let behaviourPack = {};
+	if (options.classes) {
+		const collected = await collectBlockLight({
+			version,
+			cacheDir: options.cacheDir ?? output,
+			classes: options.classes,
+			blockIds: [.../* @__PURE__ */ new Set([...blockLocators.map((locator) => locator.toString()), ...Object.keys(blockStates)])],
+			onProgress: (count, total) => report("light", count, total)
+		});
+		lightPack = sortedByKey(collected.light);
+		for (const failure of collected.failures) failures.push({
+			id: failure.id,
+			kind: "light",
+			reason: failure.reason
+		});
+		behaviourPack = sortedByKey(collected.behaviour);
+		for (const failure of collected.behaviourFailures) failures.push({
+			id: failure.id,
+			kind: "behaviour",
+			reason: failure.reason
+		});
+		if (process.env.RENDERMITE_LIGHT_DEBUG) console.error(collected.notes.join("\n"));
+	}
+	const biomes = await buildBiomeClimates(resources, namespaces, version);
+	const datapack = await collectDatapack(resources, namespaces);
+	for (const file of datapack.unreadable) failures.push({
+		id: file,
+		kind: "data",
+		reason: "datapack file is unreadable or not in the shape its folder implies; left out"
+	});
+	const tagCount = Object.values(datapack.tags).reduce((sum, registry) => sum + Object.keys(registry).length, 0);
+	const gameRules = options.classes && namespaces.includes("minecraft") ? await collectGameRules(options.classes) : {};
+	const states = options.reports === void 0 ? null : await readBlockStates(options.reports);
+	const statesPack = states === null ? null : Object.fromEntries(Object.entries(states).filter(([id]) => namespaces.includes(id.split(":", 1)[0])));
 	let itemPack = null;
 	let itemPages = [];
 	if (options.items ?? true) {
@@ -768,6 +807,21 @@ async function exportBlockPack(options) {
 			reason: failure.reason
 		});
 		if (options.classes) {
+			const sized = await collectEntitySizes({
+				classes: options.classes,
+				version,
+				cacheDir: options.cacheDir ?? output,
+				entityIds: Object.keys(collected.entities)
+			});
+			for (const [id, [width, height]] of sized.sizes) {
+				collected.entities[id].width = width;
+				collected.entities[id].height = height;
+			}
+			for (const failure of sized.failures) failures.push({
+				id: failure.id,
+				kind: "entity",
+				reason: failure.reason
+			});
 			const textureOf = /* @__PURE__ */ new Map();
 			for (const [id, entry] of Object.entries(collected.entities)) if (entry.texture) textureOf.set(id, entry.texture);
 			const geometry = await collectEntityGeometry({
@@ -885,7 +939,16 @@ async function exportBlockPack(options) {
 	await emit("models.json", JSON.stringify(sortedByKey(emittedModels)));
 	await emit("blockstates.json", JSON.stringify(sortedByKey(blockStates)));
 	await emit("tints.json", JSON.stringify(tints.pack));
+	if (Object.keys(lightPack).length > 0) await emit("light.json", JSON.stringify(lightPack));
+	if (Object.keys(behaviourPack).length > 0) await emit("behaviour.json", JSON.stringify(behaviourPack));
 	if (Object.keys(biomes.pack).length > 0) await emit("biomes.json", JSON.stringify(sortedByKey(biomes.pack)));
+	if (tagCount > 0) {
+		const tags = Object.fromEntries(Object.entries(datapack.tags).map(([registry, entries]) => [registry, sortedByKey(entries)]));
+		await emit("tags.json", JSON.stringify(sortedByKey(tags)));
+	}
+	if (Object.keys(gameRules).length > 0) await emit("game-rules.json", JSON.stringify(sortedByKey(gameRules)));
+	if (statesPack !== null && Object.keys(statesPack).length > 0) await emit("states.json", JSON.stringify(sortedByKey(statesPack)));
+	if (Object.keys(datapack.advancements).length > 0) await emit("advancements.json", JSON.stringify(sortedByKey(datapack.advancements)));
 	for (const biome of biomes.unreadable) failures.push({
 		id: biome,
 		kind: "biome",
@@ -902,6 +965,12 @@ async function exportBlockPack(options) {
 		items: Object.keys(itemPack?.items ?? {}).length,
 		entities: Object.keys(entityPack ?? {}).length,
 		entityModels: Object.keys(entityModelPack?.models ?? {}).length,
+		light: Object.keys(lightPack).length,
+		behaviour: Object.keys(behaviourPack).length,
+		tags: tagCount,
+		advancements: Object.keys(datapack.advancements).length,
+		states: Object.keys(statesPack ?? {}).length,
+		gameRules: Object.keys(gameRules).length,
 		failures: failures.length
 	};
 	await emit("meta.json", JSON.stringify({

package/dist/{export-B8tPsf4K.d.ts → export-HEoqcV-Y.d.ts}

@@ -1,4 +1,4 @@
-import { a as ResourceManager } from "./manager-exOIcdyx.js";
+import { a as ResourceManager } from "./manager-Ct0dEOMg.js";
 import { t as ClassSource } from "./jar-classes-CSRrPAUy.js";
 //#region src/blocks/export.d.ts
 interface ExportBlockPackOptions {
@@ -42,6 +42,11 @@ interface ExportBlockPackOptions {
   classes?: ClassSource;
   /** Where mappings cache; the jar cache directory. */
   cacheDir?: string;
+  /**
+   * A data generator `reports` directory for this version (`java -jar server.jar --reports`). Its
+   * `blocks.json` becomes `states.json`; without it the pack has no full property sets or defaults.
+   */
+  reports?: string;
   onProgress?: (stage: string, done: number, total: number) => void;
 }
 interface BlockPackFailure {
@@ -50,7 +55,7 @@ interface BlockPackFailure {
    * `intentional` is not a failure: it marks a block that is empty because the
    * game draws nothing for it. Filter it out to get the real gaps.
    */
-  kind: 'blockstate' | 'model' | 'texture' | 'sprite' | 'geometry' | 'tint' | 'biome' | 'item' | 'entity' | 'intentional';
+  kind: 'blockstate' | 'model' | 'texture' | 'sprite' | 'geometry' | 'tint' | 'biome' | 'item' | 'entity' | 'light' | 'behaviour' | 'data' | 'intentional';
   reason: string;
 }
 interface BlockPackResult {
@@ -66,6 +71,18 @@ interface BlockPackResult {
   entities: number;
   /** Distinct entity models in `entity-models.json`; `0` means the file was not written. */
   entityModels: number;
+  /** Emitting blocks in `light.json`; `0` means the file was not written. */
+  light: number;
+  /** Blocks in `behaviour.json`; `0` means the file was not written. */
+  behaviour: number;
+  /** Tags across every registry in `tags.json`; `0` means the file was not written. */
+  tags: number;
+  /** Advancements in `advancements.json`; `0` means the file was not written. */
+  advancements: number;
+  /** Blocks in `states.json`; `0` means no reports were given and the file was not written. */
+  states: number;
+  /** Rules in `game-rules.json`; `0` means the file was not written. */
+  gameRules: number;
   /** Files actually written — the only trustworthy success signal. */
   writtenFiles: number;
   failures: BlockPackFailure[];

package/dist/{face-DqEd9G_U.d.ts → face-uWXECGNr.d.ts}

@@ -1,8 +1,8 @@
-import { n as FloatTexture } from "./blend-C5UYzink.js";
+import { n as FloatTexture } from "./blend-mJAeQB3C.js";
 import { t as Mat4 } from "./vector-DRKRi4--.js";
 import { n as FaceGeometry } from "./geometry--UzHu1Vh.js";
 import { r as LightSource } from "./lighting-3FGRC3Af.js";
-import { n as FaceBuffer } from "./rasterizer-C2wgJZ6J.js";
+import { n as FaceBuffer } from "./rasterizer-DjnurUgD.js";
 //#region src/render/face.d.ts
 interface TintColor {
   r: number;