@nodecraft/rendermite 1.5.0 → 1.6.1

package/dist/{export-sadR0pWp.js → export-BfEIwSxY.js}

@@ -2,10 +2,12 @@ import { r as buildBiomeClimates } from "./biomes-5ZwYxMYe.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 { t as collectEntities } from "./entities-DvmA9fEV.js";
+import { t as collectEntityGeometry } from "./entity-models-_EZ3PVtN.js";
 import { n as discoverItems } from "./discovery-CD0QqxSF.js";
 import { a as salvageJson, i as resolveTexture, t as ModelLoader } from "./loader-C-NuJaEi.js";
 import { t as collectItemSprites } from "./item-sprites-G-yikdfV.js";
-import { n as buildObjMesh } from "./obj-mesh-CazmV8ya.js";
+import { n as buildObjMesh } from "./obj-mesh-JwPkZEWL.js";
 import { n as buildSpriteSheet, t as MISSING_SPRITE } from "./sprite-sheet-LQAEtGkp.js";
 import { n as buildBlockTints, t as UNREGISTERED_TINTS } from "./tints-Cl0r-Ol3.js";
 import { t as loadAtlasResolver } from "./registry-DlduyjtM.js";
@@ -682,6 +684,84 @@ async function exportBlockPack(options) {
 			};
 		}
 	}
+	let entityPack = null;
+	let entityModelPack = null;
+	let entityPages = [];
+	if (options.entities ?? true) {
+		const collected = await collectEntities({
+			resources,
+			textures,
+			namespaces,
+			onProgress: (count, total) => report("entities", count, total)
+		});
+		for (const failure of collected.failures) failures.push({
+			id: failure.id,
+			kind: "entity",
+			reason: failure.reason
+		});
+		if (options.classes) {
+			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({
+				version,
+				cacheDir: options.cacheDir ?? output,
+				classes: options.classes,
+				entityIds: Object.keys(collected.entities),
+				textureOf,
+				resources,
+				onProgress: (count, total) => report("entity geometry", count, total)
+			});
+			for (const failure of geometry.failures) failures.push({
+				id: failure.id,
+				kind: "entity",
+				reason: failure.reason
+			});
+			for (const [id, model] of geometry.modelOf) collected.entities[id].model = model;
+			if (Object.keys(geometry.models).length > 0) {
+				const sheet = await buildSpriteSheet(geometry.spriteIds, textures, {
+					padding: options.padding,
+					maxPageSize: options.maxPageSize,
+					onProgress: (count, total) => report("entity sprites", count, total)
+				});
+				for (const failure of sheet.failures) failures.push({
+					id: failure.id,
+					kind: "sprite",
+					reason: failure.reason
+				});
+				const sheetSizes = /* @__PURE__ */ new Map();
+				for (const [id, model] of geometry.modelOf) {
+					const sprite = sheet.sprites[collected.entities[id].texture ?? ""];
+					if (sprite) {
+						const sizes = sheetSizes.get(model) ?? /* @__PURE__ */ new Set();
+						sizes.add(`${sprite.w}x${sprite.h}`);
+						sheetSizes.set(model, sizes);
+					}
+				}
+				for (const [model, sizes] of sheetSizes) {
+					const [only] = [...sizes];
+					if (sizes.size === 1) {
+						const [width, height] = only.split("x").map(Number);
+						geometry.models[model].textureSize = [width, height];
+					}
+				}
+				entityPages = sheet.pages;
+				entityModelPack = {
+					padding: sheet.padding,
+					pages: entityPages.map((page, index) => {
+						return {
+							file: `entity-atlas-${index}.png`,
+							width: page.width,
+							height: page.height
+						};
+					}),
+					sprites: sortedByKey(sheet.sprites),
+					models: sortedByKey(geometry.models)
+				};
+				for (const [id, entry] of Object.entries(collected.entities)) if (entry.texture && sheet.missing.has(entry.texture)) delete collected.entities[id].texture;
+			}
+		}
+		if (Object.keys(collected.entities).length > 0) entityPack = sortedByKey(collected.entities);
+	}
 	await mkdir(output, { recursive: true });
 	const hashes = {};
 	let writtenFiles = 0;
@@ -717,6 +797,16 @@ async function exportBlockPack(options) {
 		} }).png({ compressionLevel: 9 }).toBuffer());
 	}
 	if (itemPack) await emit("items.json", JSON.stringify(itemPack));
+	if (entityPack) await emit("entities.json", JSON.stringify(entityPack));
+	for (const [index, page] of entityPages.entries()) {
+		const raw = Buffer.from(page.data.buffer, page.data.byteOffset, page.data.byteLength);
+		await emit(`entity-atlas-${index}.png`, await sharp(raw, { raw: {
+			width: page.width,
+			height: page.height,
+			channels: 4
+		} }).png({ compressionLevel: 9 }).toBuffer());
+	}
+	if (entityModelPack) await emit("entity-models.json", JSON.stringify(entityModelPack));
 	for (const file of tints.files) await emit(file.path, file.data);
 	await emit("atlas.json", JSON.stringify({
 		padding: sheet.padding,
@@ -741,6 +831,8 @@ async function exportBlockPack(options) {
 		pages: sheet.pages.length,
 		biomes: Object.keys(biomes.pack).length,
 		items: Object.keys(itemPack?.items ?? {}).length,
+		entities: Object.keys(entityPack ?? {}).length,
+		entityModels: Object.keys(entityModelPack?.models ?? {}).length,
 		failures: failures.length
 	};
 	await emit("meta.json", JSON.stringify({

package/dist/geo-CmjrXu0G.d.ts

@@ -0,0 +1,59 @@
+import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
+import { a as ResourceManager } from "./manager-exOIcdyx.js";
+import { i as TextureLoader } from "./loader-DUlx29PC.js";
+import { n as FloatTexture } from "./blend-eT64Z6qm.js";
+import { n as FaceGeometry } from "./geometry-Bkur58Vi.js";
+import { i as RenderOptions } from "./renderer-C_DFi8DF.js";
+//#region src/render/geo.d.ts
+interface GeoCube {
+  origin?: number[];
+  size?: number[];
+  uv?: number[] | Record<string, {
+    uv: number[];
+    uv_size?: number[];
+  }>;
+  inflate?: number;
+  /** Bedrock mirrors a box's texture rather than its geometry, so only a consumer's UVs care. */
+  mirror?: boolean;
+  pivot?: number[];
+  rotation?: number[];
+}
+interface GeoBone {
+  name?: string;
+  parent?: string;
+  pivot?: number[];
+  rotation?: number[];
+  cubes?: GeoCube[];
+}
+interface GeoDescription {
+  texture_width?: number;
+  texture_height?: number;
+}
+interface GeoFile {
+  'minecraft:geometry'?: Array<{
+    description?: GeoDescription;
+    bones?: GeoBone[];
+  }>;
+  [key: string]: unknown;
+}
+interface ParsedGeo {
+  textureWidth: number;
+  textureHeight: number;
+  bones: GeoBone[];
+}
+/** Handles both the modern (1.12+) and legacy (`geometry.name` keyed) layouts. */
+declare function parseGeo(json: GeoFile): ParsedGeo | null;
+/** Convert a parsed geo into face geometry, unit-cube fitted with gui pose. */
+declare function geoToFaces(geo: ParsedGeo): FaceGeometry[];
+/** Conventional locations GeckoLib mods keep item geometry and textures. */
+declare function findGeoForItem(resources: ResourceManager, id: string): Promise<{
+  geo: ParsedGeo;
+  texture: ResourceLocator;
+} | null>;
+/** Name tokens, dropping the numeric suffixes mods use for shape variants. */
+/** Tokens of a name, for the matches that need to see through a mod's own spelling of it. */
+declare function nameTokens(name: string): string[];
+/** Render a parsed geo with the standard block gui pose. */
+declare function renderGeo(geo: ParsedGeo, texture: ResourceLocator, textures: TextureLoader, options: RenderOptions): Promise<FloatTexture | null>;
+//#endregion
+export { parseGeo as a, nameTokens as i, findGeoForItem as n, renderGeo as o, geoToFaces as r, ParsedGeo as t };

package/dist/{geo-BC8jtG5Q.js → geo-Desq-gRC.js}

@@ -1,10 +1,10 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
-import { n as displayMatrix } from "./vector-CCxLae_T.js";
 import { l as toFloatTexture } from "./blend-KXMclcHk.js";
-import { c as lightsForProfile } from "./lighting--5myudVu.js";
-import { i as createFaceBuffer } from "./rasterizer-DcVJzkxz.js";
 import { t as combineFaceBuffers } from "./compose-BGsNFR12.js";
-import { n as faceMaxZ, r as renderFace, t as createShadeCache } from "./face-CMJ3b3Ae.js";
+import { i as createFaceBuffer } from "./rasterizer-DcVJzkxz.js";
+import { n as displayMatrix } from "./vector-CCxLae_T.js";
+import { n as faceMaxZ, r as renderFace, t as createShadeCache } from "./face-B2JjWT46.js";
+import { c as lightsForProfile } from "./lighting--5myudVu.js";
 //#region src/render/geo.ts
 /**
 * Bedrock-format geometry (`.geo.json`) rendering, best-effort. GeckoLib mods
@@ -317,6 +317,7 @@ async function findGeoForItem(resources, id) {
 	return null;
 }
 /** Name tokens, dropping the numeric suffixes mods use for shape variants. */
+/** Tokens of a name, for the matches that need to see through a mod's own spelling of it. */
 function nameTokens(name) {
 	return name.split(/[/_]/).filter((token) => token.length > 0 && !/^\d+$/.test(token));
 }
@@ -407,4 +408,4 @@ async function renderGeo(geo, texture, textures, options) {
 	return combineFaceBuffers(renderSize, renderSize, buffers);
 }
 //#endregion
-export { renderGeo as i, geoToFaces as n, parseGeo as r, findGeoForItem as t };
+export { renderGeo as a, parseGeo as i, geoToFaces as n, nameTokens as r, findGeoForItem as t };

package/dist/geo-model-Bo1gpEwX.js

@@ -0,0 +1,163 @@
+//#region src/entities/geo-model.ts
+/** Where a `ModelPart`'s origin sits above the feet, in pixels: 1.5 blocks. */
+const FEET = 24;
+const DEGREES = Math.PI / 180;
+/** A cycle in `parent` links would otherwise walk forever; no real model nests anywhere near this. */
+const MAX_DEPTH = 32;
+const vec3 = (values) => [
+	values?.[0] ?? 0,
+	values?.[1] ?? 0,
+	values?.[2] ?? 0
+];
+/** A bedrock point in `ModelPart` space. */
+const toJava = (point) => [
+	point[0],
+	FEET - point[1],
+	point[2]
+];
+/** `-0` is what negating an unrotated bone leaves behind, and it has no business in a pack file. */
+const noMinusZero = (value) => value === 0 ? 0 : value;
+const toJavaRotation = (rotation) => {
+	const [pitch, yaw, roll] = vec3(rotation);
+	return [
+		noMinusZero(pitch * DEGREES),
+		noMinusZero(-yaw * DEGREES),
+		noMinusZero(-roll * DEGREES)
+	];
+};
+const FACES = [
+	"north",
+	"south",
+	"east",
+	"west",
+	"up",
+	"down"
+];
+/** Bedrock's per-face rects, which have no equivalent in a Java box unwrap. */
+function faceRects(cube, size) {
+	if (!cube.uv || Array.isArray(cube.uv)) return;
+	const faces = {};
+	for (const face of FACES) {
+		const entry = cube.uv[face];
+		if (entry?.uv) faces[face] = {
+			uv: [entry.uv[0], entry.uv[1]],
+			size: [entry.uv_size?.[0] ?? size[0], entry.uv_size?.[1] ?? size[1]]
+		};
+	}
+	return Object.keys(faces).length > 0 ? faces : void 0;
+}
+/**
+* One bedrock cube, in the space of the part that owns it.
+*
+* `pivot` is the *bone's* pivot in bedrock space: a cube's box is stated in absolute coordinates, and a
+* `ModelPart`'s is stated relative to where the part pivots. The y flip swaps which corner is the
+* minimum, so the origin is measured from the far side of the box.
+*/
+function toCube(cube, pivot) {
+	if (!cube.origin || !cube.size) return null;
+	const stated = vec3(cube.origin);
+	const extent = vec3(cube.size);
+	const origin = stated.map((value, axis) => Math.min(value, value + extent[axis]));
+	const size = extent.map((value) => Math.abs(value));
+	const rects = faceRects(cube, size);
+	const uv = Array.isArray(cube.uv) ? cube.uv : [];
+	return {
+		origin: [
+			origin[0] - pivot[0],
+			pivot[1] - origin[1] - size[1],
+			origin[2] - pivot[2]
+		],
+		size,
+		uv: [uv[0] ?? 0, uv[1] ?? 0],
+		inflate: cube.inflate ?? 0,
+		mirror: cube.mirror ?? false,
+		...rects && { faces: rects }
+	};
+}
+/**
+* Converts one parsed `.geo.json` into a model.
+*
+* Bones are a flat list joined by `parent` name, so the tree is rebuilt here. A bone whose parent is
+* missing becomes a root rather than being dropped, and a cube carrying its own rotation becomes a part
+* of its own: `Cube` has nowhere to put a rotation, and 18% of the corpus's cubes have one.
+*/
+function geoToModel(geo) {
+	const bones = geo.bones;
+	const byName = /* @__PURE__ */ new Map();
+	for (const bone of bones) if (bone.name) byName.set(bone.name, bone);
+	const notes = [];
+	const parts = /* @__PURE__ */ new Map();
+	const pivots = /* @__PURE__ */ new Map();
+	for (const bone of bones) {
+		const pivot = vec3(bone.pivot);
+		pivots.set(bone, pivot);
+		const cubes = [];
+		const rotated = [];
+		for (const cube of bone.cubes ?? []) {
+			if (cube.rotation?.some((value) => value !== 0) && cube.pivot) {
+				const cubePivot = vec3(cube.pivot);
+				const converted = toCube(cube, cubePivot);
+				if (converted) rotated.push({
+					name: `${bone.name ?? "bone"}_cube${rotated.length + 1}`,
+					pivot: subtract(toJava(cubePivot), toJava(pivot)),
+					rotation: toJavaRotation(cube.rotation),
+					cubes: [converted],
+					children: []
+				});
+				continue;
+			}
+			const converted = toCube(cube, pivot);
+			if (converted) cubes.push(converted);
+		}
+		parts.set(bone, {
+			name: bone.name ?? `bone${parts.size + 1}`,
+			pivot: [
+				0,
+				0,
+				0
+			],
+			rotation: toJavaRotation(bone.rotation),
+			cubes,
+			children: rotated
+		});
+	}
+	const roots = [];
+	for (const bone of bones) {
+		const part = parts.get(bone);
+		const parent = bone.parent ? byName.get(bone.parent) : void 0;
+		if (parent && parent !== bone && depthOf(bone, byName) < MAX_DEPTH) {
+			part.pivot = subtract(toJava(pivots.get(bone)), toJava(pivots.get(parent)));
+			parts.get(parent).children.push(part);
+			continue;
+		}
+		if (bone.parent && !parent) notes.push(`${bone.name ?? "a bone"} names a parent the file does not define, so it hangs from the model root`);
+		part.pivot = toJava(pivots.get(bone));
+		roots.push(part);
+	}
+	return {
+		textureSize: [geo.textureWidth, geo.textureHeight],
+		parts: roots,
+		notes
+	};
+}
+function subtract(left, right) {
+	return [
+		left[0] - right[0],
+		left[1] - right[1],
+		left[2] - right[2]
+	];
+}
+/** How far a bone sits from its root, which is also the cycle check. */
+function depthOf(bone, byName) {
+	const seen = /* @__PURE__ */ new Set();
+	let current = bone;
+	let depth = 0;
+	while (current && !seen.has(current) && depth < MAX_DEPTH) {
+		seen.add(current);
+		current = current.parent ? byName.get(current.parent) : void 0;
+		depth++;
+	}
+	return depth;
+}
+//#endregion
+export { geoToModel as t };

package/dist/index.d.ts

@@ -6,9 +6,9 @@ import { a as PackedRect, i as PackedPage, n as PackOptions, o as packAtlas, r a
 import { a as buildBiomeClimates, i as VANILLA_BIOME_CLIMATES, n as BiomeClimatePack, o as parseBiomeClimate, r as DEFAULT_WATER_COLOR, t as BiomeClimate } from "./biomes-CJDJQqJb.js";
 import { a as resolveTexture, n as ModelResolutionError, o as salvageJson, r as ResolvedModel, t as ModelLoader } from "./loader-DSir1-P0.js";
 import { a as BlockStateMultipartCase, d as matchesCondition, f as parseBlockState, i as BlockStateError, l as collectModels, n as BlockProperties, o as BlockStateVariantCase, p as weightedVariantIndex, r as BlockStateDefinition, s as MultipartCondition, t as BlockModelVariant, u as evaluateBlockState } from "./blockstate-eval-BzznRcVY.js";
-import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "./export-wvt0Fryo.js";
 import { i as buildObjMesh, n as ObjMesh, r as ObjMeshError, t as MeshGroup } from "./obj-mesh-ydhVfLKs.js";
 import { a as buildBlockTints, i as UNREGISTERED_TINTS, n as BlockTintPack, t as BlockTint } from "./tints-DoBv5S9v.js";
+import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "./export-B8tPsf4K.js";
 import { s as builtinDynamicResources } from "./generators-BnIzAftW.js";
 import { d as toFloatTexture, n as FloatTexture, u as toByteTexture } from "./blend-eT64Z6qm.js";
 import { a as LightingProfileName, i as LightingProfile, r as LightSource, u as lightsForProfile } from "./lighting-3FGRC3Af.js";

package/dist/index.js

@@ -1,26 +1,26 @@
 import { i as parseBiomeClimate, n as VANILLA_BIOME_CLIMATES, r as buildBiomeClimates, t as DEFAULT_WATER_COLOR } from "./biomes-5ZwYxMYe.js";
 import { n as ResourceLocator, t as InvalidResourceLocatorError } from "./locator-COMEtEn9.js";
 import { a as parseBlockState, i as matchesCondition, n as collectModels, o as weightedVariantIndex, r as evaluateBlockState, t as BlockStateError } from "./blockstate-eval-BRQ3NWY2.js";
+import { c as toByteTexture, l as toFloatTexture } from "./blend-KXMclcHk.js";
+import { c as lightsForProfile, r as LightingProfile } from "./lighting--5myudVu.js";
 import { a as defaultProperties, i as UNKNOWN_MODEL, n as InvalidItemDefinitionError, o as evaluateItemModel } from "./definition-ColsvWrH.js";
 import { i as resolveItem, n as discoverItems, t as ItemResolutionError } from "./discovery-CD0QqxSF.js";
 import { a as salvageJson, i as resolveTexture, n as ModelResolutionError, t as ModelLoader } from "./loader-C-NuJaEi.js";
 import { a as resolveTints, i as resolveTint, n as InvalidTinterDefinitionError, r as parseTintValue, t as DYE_COLORS } from "./tints-B3WQcPtx.js";
-import { c as toByteTexture, l as toFloatTexture } from "./blend-KXMclcHk.js";
-import { c as lightsForProfile, r as LightingProfile } from "./lighting--5myudVu.js";
-import { a as ItemRenderError, c as renderModel, l as renderModelFrames, o as boxDownscale, s as pointResize } from "./obj-BaGvPUbb.js";
-import { n as buildObjMesh, t as ObjMeshError } from "./obj-mesh-CazmV8ya.js";
+import { a as ItemRenderError, c as renderModel, l as renderModelFrames, o as boxDownscale, s as pointResize } from "./obj-CJHEHpki.js";
+import { n as buildObjMesh, t as ObjMeshError } from "./obj-mesh-JwPkZEWL.js";
 import { t as packAtlas } from "./atlas-pack-CoOih7By.js";
 import { n as buildBlockTints, t as UNREGISTERED_TINTS } from "./tints-Cl0r-Ol3.js";
 import { o as createAtlasResolver, s as parseAtlasSources, t as AtlasSourceError } from "./sources-BlUriDCs.js";
 import { n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "./manager-BNibYkmI.js";
 import { n as TextureLoader, r as TextureResolutionError, t as AnimatedTexture } from "./loader-C18GpurU.js";
-import { t as exportBlockPack } from "./export-sadR0pWp.js";
+import { t as exportBlockPack } from "./export-BfEIwSxY.js";
 import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "./jar-W2cV2ZVO.js";
-import { n as prepareModResources } from "./prepare-B_tRy9lB.js";
-import { a as prepareVersionResources, i as eraForVersion, r as compareVersions } from "./prepare-8LswFoS-.js";
+import { n as prepareModResources } from "./prepare-Myd_ec4v.js";
+import { a as prepareVersionResources, i as eraForVersion, r as compareVersions } from "./prepare-D49Gu4Lv.js";
 import { n as encodeIcon, t as encodeAnimatedIcon } from "./encode-LR9wxigC.js";
 import { a as builtinDynamicResources } from "./generators-BCZVlWig.js";
 import { t as minifyStylesheet } from "./minify-bjMRmr5J.js";
 import { n as itemClass, t as generateStylesheet } from "./stylesheet-CovT3B2S.js";
-import { t as run } from "./run-UKgVb-kW.js";
+import { t as run } from "./run-BQJkqc5f.js";
 export { AnimatedTexture, AtlasSourceError, BlockStateError, DEFAULT_WATER_COLOR, DYE_COLORS, FolderResourceManager, InvalidItemDefinitionError, InvalidResourceLocatorError, InvalidTinterDefinitionError, ItemRenderError, ItemResolutionError, JarResourceManager, LayeredResourceManager, LightingProfile, ModelLoader, ModelResolutionError, ObjMeshError, ResourceKind, ResourceLocator, TextureLoader, TextureResolutionError, UNKNOWN_MODEL, UNREGISTERED_TINTS, UnsafeJarError, VANILLA_BIOME_CLIMATES, boxDownscale, buildBiomeClimates, buildBlockTints, buildObjMesh, builtinDynamicResources, collectModels, compareVersions, createAtlasResolver, defaultProperties, discoverItems, encodeAnimatedIcon, encodeIcon, eraForVersion, evaluateBlockState, evaluateItemModel, exportBlockPack, generateStylesheet, isUnsafeEntryPath, itemClass, lightsForProfile, matchesCondition, minifyStylesheet, packAtlas, parseAtlasSources, parseBiomeClimate, parseBlockState, parseTintValue, pointResize, prepareModResources, prepareVersionResources, renderModel, renderModelFrames, resolveItem, resolveTexture, resolveTint, resolveTints, run, salvageJson, toByteTexture, toFloatTexture, weightedVariantIndex };

package/dist/inherit-ByHjOJX3.js

@@ -0,0 +1,77 @@
+import { t as parseClassFile } from "./classfile-Bo7FUrrD.js";
+import { i as mergeModels } from "./merge-NDYxpmL8.js";
+import { t as extractModel } from "./model-bytecode-gWy5_uCj.js";
+//#region src/entities/inherit.ts
+/**
+* A model class read together with its ancestors.
+*
+* Model code leans on its superclass everywhere. Before 1.17 a model's parts were fields assigned in
+* the constructor and a subclass overrode the two or three it cared about, leaving the rest to
+* `super()`; `CowModel` declares a head with horns and a body, and its four legs belong to
+* `QuadrupedModel`. It did not end with the old API either: 26.2's `PigModel` still starts from
+* `QuadrupedModel.createBodyMesh(6, …)` and only replaces the head.
+*
+* So the interpreter is handed the chain and follows calls into it, arguments and all. What it cannot
+* follow — a builder that loops, a frame past the budget — the name merge below still salvages, one
+* class at a time.
+*/
+/** `java/lang/Object` ends the walk; the cap is for a jar whose hierarchy has a cycle in it. */
+const MAX_ANCESTORS = 8;
+/** Reads a class and everything it inherits from that the jar still holds. */
+async function ancestryOf(internalName, read) {
+	const ancestors = /* @__PURE__ */ new Map();
+	const chain = [];
+	let next = internalName.replaceAll(".", "/");
+	for (let depth = 0; next && depth < MAX_ANCESTORS && !ancestors.has(next); depth++) {
+		const bytes = await read(next);
+		if (!bytes) break;
+		let classFile;
+		try {
+			classFile = parseClassFile(bytes);
+		} catch {
+			break;
+		}
+		ancestors.set(next, classFile);
+		chain.push({
+			internalName: next,
+			bytes
+		});
+		next = classFile.superClass;
+	}
+	return {
+		ancestors,
+		chain
+	};
+}
+/**
+* Geometry for one class, with the code it builds on available and its ancestors' parts filled in.
+*
+* `code` widens what a call may be followed into beyond the ancestors, which some models need: the
+* witch's body is the villager's, and a donkey's chest comes from the saddle model. Without it those
+* models still come out, minus the piece the other class holds.
+*
+* Every ancestor is merged rather than only the first with boxes, because a deep hierarchy splits
+* several ways: 1.16.5's sheep overrides a head in `SheepFurModel` and takes its legs from
+* `QuadrupedModel` two hops up.
+*/
+async function extractInheritedModel(internalName, read, code) {
+	const { ancestors, chain } = await ancestryOf(internalName, read);
+	const [own, ...inherited] = chain;
+	if (!own) return null;
+	const resolve = (name) => ancestors.get(name) ?? code?.resolve(name) ?? null;
+	const following = (name) => !code || code.resolve(name) !== null;
+	let model = extractModel(own.bytes, {
+		resolve,
+		isModelCode: following(own.internalName)
+	});
+	for (const ancestor of inherited) {
+		const inheritedModel = extractModel(ancestor.bytes, {
+			resolve,
+			isModelCode: following(ancestor.internalName)
+		});
+		model = mergeModels(model, inheritedModel);
+	}
+	return model;
+}
+//#endregion
+export { extractInheritedModel as n, ancestryOf as t };

package/dist/jar-classes-CSRrPAUy.d.ts

@@ -0,0 +1,41 @@
+//#region src/entities/jar-classes.d.ts
+/**
+ * Reading `.class` entries out of a jar.
+ *
+ * `JarResourceManager` deliberately indexes only `assets/` and `data/` — it is a *resource* manager,
+ * and a class file is not a resource. But entity geometry lives in the code (see
+ * `docs/entity-geometry.md`), so the extractor needs the other half of the archive, and it needs it
+ * by internal class name rather than by resource locator.
+ *
+ * Same shape as the resource manager for the same reason: index the central directory once, then read
+ * entries on demand. A client jar holds around eight thousand classes and the extractor touches a
+ * hundred of them.
+ */
+/** What the extractor reads code out of: one jar, or several layered into one view. */
+interface ClassSource {
+  list: () => Promise<string[]>;
+  read: (internalName: string) => Promise<Uint8Array | null>;
+  close: () => Promise<void>;
+}
+/**
+ * Several jars as one class view, first match winning — the same layering the resource managers use.
+ *
+ * A modded export needs this, and needed it before cross-jar linking did: the class source used to be
+ * the client jar alone, so a mod's own model classes were never read and its mobs came out as boxes
+ * however good the interpreter was. Layered, one view holds both, which is also what lets a mod entity
+ * link to a *vanilla* model — `ars_nouveau:summon_horse` is the game's own horse.
+ */
+declare function layeredClasses(sources: readonly ClassSource[]): ClassSource;
+/** Reads class files out of one jar, by internal name. */
+declare class JarClassReader {
+  private readonly jarPath;
+  private index;
+  constructor(jarPath: string);
+  private getIndex;
+  /** Every class in the jar, for a sweep that does not know what it is looking for. */
+  list(): Promise<string[]>;
+  read(internalName: string): Promise<Uint8Array | null>;
+  close(): Promise<void>;
+}
+//#endregion
+export { JarClassReader as n, layeredClasses as r, ClassSource as t };

package/dist/jar-classes-DCtELr1i.js

@@ -0,0 +1,102 @@
+import { t as openZip } from "./zip-reader-BSbJKUT1.js";
+import { n as UnsafeJarError, r as isUnsafeEntryPath } from "./jar-W2cV2ZVO.js";
+//#region src/entities/jar-classes.ts
+/**
+* Reading `.class` entries out of a jar.
+*
+* `JarResourceManager` deliberately indexes only `assets/` and `data/` — it is a *resource* manager,
+* and a class file is not a resource. But entity geometry lives in the code (see
+* `docs/entity-geometry.md`), so the extractor needs the other half of the archive, and it needs it
+* by internal class name rather than by resource locator.
+*
+* Same shape as the resource manager for the same reason: index the central directory once, then read
+* entries on demand. A client jar holds around eight thousand classes and the extractor touches a
+* hundred of them.
+*/
+/**
+* Several jars as one class view, first match winning — the same layering the resource managers use.
+*
+* A modded export needs this, and needed it before cross-jar linking did: the class source used to be
+* the client jar alone, so a mod's own model classes were never read and its mobs came out as boxes
+* however good the interpreter was. Layered, one view holds both, which is also what lets a mod entity
+* link to a *vanilla* model — `ars_nouveau:summon_horse` is the game's own horse.
+*/
+function layeredClasses(sources) {
+	return {
+		list: async () => {
+			const names = /* @__PURE__ */ new Set();
+			for (const source of sources) for (const name of await source.list()) names.add(name);
+			return [...names];
+		},
+		read: async (internalName) => {
+			for (const source of sources) {
+				const bytes = await source.read(internalName);
+				if (bytes) return bytes;
+			}
+			return null;
+		},
+		close: async () => {
+			for (const source of sources) await source.close();
+		}
+	};
+}
+/** Reads class files out of one jar, by internal name. */
+var JarClassReader = class {
+	jarPath;
+	index = null;
+	constructor(jarPath) {
+		this.jarPath = jarPath;
+	}
+	getIndex() {
+		this.index ??= (async () => {
+			const zip = await openZip(this.jarPath);
+			return await new Promise((resolve, reject) => {
+				const entries = /* @__PURE__ */ new Map();
+				zip.on("entry", (entry) => {
+					if (isUnsafeEntryPath(entry.fileName)) {
+						zip.close();
+						reject(new UnsafeJarError(`Unsafe entry in ${this.jarPath}: ${entry.fileName}`));
+						return;
+					}
+					if (entry.fileName.endsWith(".class")) entries.set(entry.fileName.slice(0, -6), entry);
+					zip.readEntry();
+				});
+				zip.on("end", () => resolve({
+					zip,
+					entries
+				}));
+				zip.on("error", reject);
+				zip.readEntry();
+			});
+		})();
+		return this.index;
+	}
+	/** Every class in the jar, for a sweep that does not know what it is looking for. */
+	async list() {
+		return (await this.getIndex()).entries.keys().toArray();
+	}
+	async read(internalName) {
+		const index = await this.getIndex();
+		const entry = index.entries.get(internalName.replaceAll(".", "/"));
+		if (!entry) return null;
+		return await new Promise((resolve, reject) => {
+			index.zip.openReadStream(entry, (err, stream) => {
+				if (err) {
+					reject(err);
+					return;
+				}
+				const chunks = [];
+				stream.on("data", (chunk) => {
+					chunks.push(chunk);
+				});
+				stream.on("end", () => resolve(new Uint8Array(Buffer.concat(chunks))));
+				stream.on("error", reject);
+			});
+		});
+	}
+	async close() {
+		if (this.index) (await this.index).zip.close();
+	}
+};
+//#endregion
+export { layeredClasses as n, JarClassReader as t };