@nodecraft/rendermite 1.5.0 → 1.6.0

package/dist/entities/link.d.ts

@@ -0,0 +1,71 @@
+import { t as ClassFile } from "../classfile-BwaQjnUM.js";
+import { t as Mappings } from "../mappings-DxX4KoZl.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
+ * for; several may be listed because the game renamed the holder between versions — 1.21.4 folded
+ * `ChestedHorseRenderer` into `DonkeyRenderer`, and a pack is exported for both eras.
+ */
+declare const RENDERER_ALIASES: Readonly<Record<string, string | readonly string[]>>;
+/**
+ * Entity types the game draws without a `ModelPart` hierarchy at all, so having no geometry for them
+ * is the right answer rather than a gap.
+ *
+ * Three kinds: things that draw a *block* or an *item* instead (a dropped stack, a falling block, a
+ * thrown egg), things the renderer draws with hand-built quads (an arrow, a painting, the end
+ * crystal's beam), and things that are deliberately invisible (a marker, the display entities).
+ *
+ * Listed rather than inferred so that a version adding a mob cannot slip through as "no model": the
+ * coverage test fails on any type that is neither linked nor named here.
+ */
+declare const NO_MODEL: ReadonlySet<string>;
+interface LinkContext {
+  mappings: Mappings;
+  /** Reads a class by its obfuscated name, or `null` when the jar has no such class. */
+  read: (obfuscated: string) => Promise<ClassFile | null>;
+  /** Whether this class actually yields geometry, used to skip abstract bases. */
+  hasGeometry: (obfuscated: string) => Promise<boolean>;
+  /**
+   * `buildModelNameIndex` over the jar being exported, for a mod whose classes follow none of
+   * vanilla's naming. Absent for a vanilla-only link, where the named routes are exact and a fuzzy
+   * one would only ever be wrong.
+   */
+  nameIndex?: Map<string, string[]>;
+}
+interface EntityModelLink {
+  /** Deobfuscated class name, for diagnostics and for the pack's model id. */
+  className: string;
+  /** The class to actually read the bytecode of. */
+  obfuscated: string;
+  /** How it was found, so a report can say how much rests on the curated table. */
+  route: 'model-name' | 'renderer' | 'alias' | 'mod-name';
+}
+/**
+ * A class's simple name reduced to the entity it is about.
+ *
+ * `Lionfish_Model`, `ModelLionfish`, `LionfishEntityModel` and `lionfish` all come out `lionfish`.
+ * Mods put the marker word at either end and sometimes both — `Modelcutter` is the old MCP style,
+ * `Lionfish_Model` the modern one — so the strip repeats until nothing more comes off. Separators go
+ * too, because a mod's class is `Deepling_Brute_Model` where its entity is `deepling_brute`.
+ */
+declare function normaliseModelName(name: string): string;
+/**
+ * Normalised name → the classes that could be it, for a jar whose classes are not named the way
+ * vanilla's are.
+ *
+ * Built once per jar because the alternative is scanning three thousand classes per entity. Nested
+ * classes are indexed under the part after the `$` as well: occultism files a familiar's head as
+ * `HeadlessFamiliarRenderer$CthulhuHeadModel`, and only the tail of that names the mob.
+ */
+declare function buildModelNameIndex(internalNames: Iterable<string>): Map<string, string[]>;
+/**
+ * The class holding one entity's geometry, or `null` when nothing links.
+ *
+ * A candidate is only accepted if it *yields geometry*: a renderer chain can land on an abstract base
+ * that names no boxes, and returning that would report coverage the pack does not have.
+ */
+declare function linkEntityModel(entityId: string, context: LinkContext): Promise<EntityModelLink | null>;
+/** Reads and caches classes out of an extracted jar directory or a jar reader. */
+declare function classReader(load: (obfuscated: string) => Promise<Uint8Array | null>): LinkContext['read'];
+//#endregion
+export { EntityModelLink, LinkContext, NO_MODEL, RENDERER_ALIASES, buildModelNameIndex, classReader, linkEntityModel, normaliseModelName };

package/dist/entities/link.js

@@ -0,0 +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-Bm5oQYh6.js";
+export { NO_MODEL, RENDERER_ALIASES, buildModelNameIndex, classReader, linkEntityModel, normaliseModelName };

package/dist/entities/mappings.d.ts

@@ -0,0 +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 };

package/dist/entities/mappings.js

@@ -0,0 +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 };

package/dist/entities/merge.d.ts

@@ -0,0 +1,18 @@
+import { i as Part, r as ExtractedModel } from "../model-PnQ4gV0-.js";
+//#region src/entities/merge.d.ts
+/**
+ * Where a piece's parts sit: at the top, or inside the one anonymous root a `MeshDefinition` makes.
+ * Both merge into the same list of named slots and only one of them is nested.
+ */
+declare function slotsOf(parts: Part[]): {
+  container: Part | null;
+  slots: Part[];
+};
+/** True when this piece built its own mesh rather than adding to one it was handed. */
+declare function buildsOwnMesh(model: ExtractedModel): boolean;
+/** `base` plus the parts of `extra` that `base` does not name. */
+declare function mergeModels(base: ExtractedModel, extra: ExtractedModel): ExtractedModel;
+declare function countCubes(part: Part): number;
+declare function cubesOf(model: ExtractedModel): number;
+//#endregion
+export { buildsOwnMesh, countCubes, cubesOf, mergeModels, slotsOf };

package/dist/entities/merge.js

@@ -0,0 +1,2 @@
+import { a as slotsOf, i as mergeModels, n as countCubes, r as cubesOf, t as buildsOwnMesh } from "../merge-3HkeQ_6A.js";
+export { buildsOwnMesh, countCubes, cubesOf, mergeModels, slotsOf };

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

@@ -0,0 +1,31 @@
+import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
+import { t as ClassFile } from "../classfile-BwaQjnUM.js";
+//#region src/entities/model-bytecode.d.ts
+/**
+ * Extracts whatever geometry a class's methods build.
+ *
+ * Every method is tried, because where the model is built differs by era: 1.17+ vanilla uses a static
+ * factory, older vanilla and most mods use the constructor. The one that built the fullest *mesh* is
+ * the model, and the methods that only add to a mesh handed to them are merged into it:
+ * `QuadrupedModel` puts its head and body in `createBodyMesh` and its four legs in `createLegs`, so
+ * picking a single winner silently drops whichever it did not pick.
+ *
+ * Only those helpers merge, never two methods that each built their own mesh. Those are variants of the
+ * same model, a boat and a chest boat, and folding them together puts a chest on every boat.
+ */
+/** What a call may be followed into, and whether this class is the sort that makes such calls. */
+interface Following {
+  /** The class a call names, or null for the builder API and everything else off limits. */
+  resolve: (internalName: string) => ClassFile | null;
+  /**
+   * Whether the class being extracted is model code. A renderer is not: it constructs the models it
+   * draws, so following those calls makes it look like it holds their geometry, and a pufferfish
+   * renderer that builds all three sizes comes out as one model with three sets of spines.
+   *
+   * Defaults to true, which is right when the caller has no way to tell the two apart.
+   */
+  isModelCode?: boolean;
+}
+declare function extractModel(bytes: Uint8Array, following?: Following): ExtractedModel;
+//#endregion
+export { Following, extractModel };

package/dist/entities/model-bytecode.js

@@ -0,0 +1,2 @@
+import { t as extractModel } from "../model-bytecode-C1nw2G8O.js";
+export { extractModel };

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

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

package/dist/entities/model-code.js

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

package/dist/entities/model.d.ts

@@ -0,0 +1,2 @@
+import { i as Part, n as CubeFace, r as ExtractedModel, t as Cube } from "../model-PnQ4gV0-.js";
+export { Cube, CubeFace, ExtractedModel, Part };

package/dist/entities/model.js

@@ -0,0 +1 @@
+export {};

package/dist/entities-DvmA9fEV.js

@@ -0,0 +1,175 @@
+import { n as ResourceLocator } from "./locator-COMEtEn9.js";
+import { l as findMobTexture, u as tokens } from "./entity-textures-DFRIVdF1.js";
+//#region src/blocks/entities.ts
+/**
+* The entity registry, and one colour per entity.
+*
+* A world viewer has no geometry for a mob — nothing in any jar does, at any version, because entity
+* models are Java code — so what it draws is a box the size of the hitbox. Two things make that box
+* worth looking at rather than merely present: the entity's *name*, so a reader knows what it is, and
+* the entity's *colour*, so a pen of cows does not read as the same grey mass as the shoal beside it.
+*
+* Both come out of the assets today, with no geometry decision made:
+*
+* - The registry is the lang file. `entity.<ns>.<name>` is written per registered entity type by
+*   datagen, so it is the closest thing a jar carries to the entity registry — the same trick the item
+*   sheet uses to tell a real item from a template model.
+* - The colour is the mean of the opaque pixels of the entity's own texture sheet. Crude on purpose:
+*   it is a marker's tint, not a render, and a mean is the one summary that cannot be wrong about
+*   which mob it came from.
+*
+* `texture` is carried alongside so that whatever eventually draws real entity geometry has the
+* id → sheet mapping already resolved, which is the fiddly half of the problem.
+*/
+/** `entity.<ns>.<name>`, and only the plain ones: a deeper key is a subtitle or a variant label. */
+const ENTITY_KEY_SEGMENTS = 3;
+/**
+* Texture names filed under a mob's own directory that are not the mob.
+*
+* A llama's directory holds `spit`, which is the projectile it throws; a horse's holds its armour, a
+* cat's its collar, a happy ghast's its harness. Those score exactly as well on name overlap as the
+* body sheet does — `entity/llama/spit` and `entity/llama/creamy` both name the llama and sit at the
+* same depth — so without this the tie breaks arbitrarily and a llama comes out the colour of spit.
+*
+* Overlays are here for the same reason: a blink or an eye layer is a few opaque pixels whose mean
+* says nothing about the animal.
+*/
+const NOT_THE_MOB = /* @__PURE__ */ new Set([
+	"spit",
+	"armor",
+	"saddle",
+	"collar",
+	"harness",
+	"chest",
+	"overlay",
+	"blink",
+	"eyes",
+	"markings",
+	"glow"
+]);
+/**
+* Alpha at or below which a pixel does not count toward the mean.
+*
+* Not zero: mob sheets are full of near-transparent antialiasing at the edges of a part, and letting
+* those in drags every colour toward whatever the sheet's background happens to be.
+*/
+const OPAQUE_ALPHA = 128;
+/** The mean of a texture's opaque pixels as `#rrggbb`, or `null` when it has none. */
+function meanColor(texture) {
+	let red = 0;
+	let green = 0;
+	let blue = 0;
+	let counted = 0;
+	for (let offset = 0; offset < texture.data.length; offset += 4) {
+		if (texture.data[offset + 3] <= OPAQUE_ALPHA) continue;
+		red += texture.data[offset];
+		green += texture.data[offset + 1];
+		blue += texture.data[offset + 2];
+		counted++;
+	}
+	if (counted === 0) return null;
+	return `#${[
+		red,
+		green,
+		blue
+	].map((channel) => Math.round(channel / counted).toString(16).padStart(2, "0")).join("")}`;
+}
+/**
+* Every entity type a namespace registers, by its lang keys.
+*
+* Keys with more segments than `<prefix>.<ns>.<name>` are dropped: those are a variant's own label
+* (`entity.minecraft.villager.farmer`) or a death message, never a type.
+*/
+async function entityTypesOf(resources, namespace) {
+	const raw = await resources.getResource("lang", new ResourceLocator(namespace, "en_us"));
+	if (!raw) return [];
+	let lang;
+	try {
+		lang = JSON.parse(raw.toString("utf8"));
+	} catch {
+		return [];
+	}
+	const prefix = `entity.${namespace}.`;
+	const types = [];
+	for (const [key, value] of Object.entries(lang)) {
+		if (!key.startsWith(prefix) || key.split(".").length !== ENTITY_KEY_SEGMENTS || typeof value !== "string") continue;
+		types.push({
+			id: `${namespace}:${key.slice(prefix.length)}`,
+			name: value
+		});
+	}
+	return types;
+}
+/**
+* A mob's sheet where the conventional paths do not have it.
+*
+* `findMobTexture` wants a file named exactly after the entity, which is how most of them are filed.
+* The rest are named after a *variant* — a rabbit is `entity/rabbit/brown`, a horse is
+* `entity/horse/horse_white`, an elder guardian is `entity/guardian/guardian_elder` — so this falls
+* back to the best token overlap under `entity/`, preferring a shallower path so a family's plain
+* sheet beats its armour or blink overlay.
+*
+* Restricted to `entity/` deliberately. Widening it finds a *block* texture with a matching word for
+* anything that has no sheet at all, and a lectern-coloured marker is worse than no colour.
+*
+* The name is also matched with its underscores squashed out, which is a real vanilla convention and
+* not a guess: an armour stand is filed under `entity/armorstand/` and a magma cube is
+* `entity/slime/magmacube`, and neither shares a single token with its own id.
+*/
+async function findVariantTexture(resources, namespace, name) {
+	const wanted = tokens(name);
+	const squashed = name.replaceAll("_", "");
+	let best = null;
+	let bestScore = 0;
+	for (const locator of await resources.listResources("texture", namespace)) {
+		if (!locator.path.startsWith("entity/")) continue;
+		const leaf = locator.path.split("/").at(-1) ?? "";
+		if (tokens(leaf).some((token) => NOT_THE_MOB.has(token))) continue;
+		const candidate = tokens(locator.path);
+		let score = 0;
+		for (const token of wanted) if (candidate.includes(token)) score += 2;
+		if (squashed !== name && candidate.includes(squashed)) score += wanted.length * 2;
+		if (score === 0) continue;
+		const depth = locator.path.split("/").length;
+		score = score * 10 - depth - candidate.length;
+		if (score > bestScore) {
+			best = locator;
+			bestScore = score;
+		}
+	}
+	return best;
+}
+async function collectEntities(options) {
+	const { resources, textures } = options;
+	const entities = {};
+	const failures = [];
+	const types = [];
+	for (const namespace of options.namespaces) types.push(...await entityTypesOf(resources, namespace));
+	let done = 0;
+	for (const type of types.toSorted((left, right) => left.id.localeCompare(right.id))) {
+		options.onProgress?.(++done, types.length);
+		const [namespace, name] = [type.id.slice(0, type.id.indexOf(":")), type.id.slice(type.id.indexOf(":") + 1)];
+		const entry = { name: type.name };
+		const locator = await findMobTexture(resources, namespace, name) ?? await findVariantTexture(resources, namespace, name);
+		if (locator) {
+			const texture = await textures.load(locator).catch(() => null);
+			const colour = texture ? meanColor(texture) : null;
+			entry.texture = locator.toString();
+			if (colour) entry.color = colour;
+			else failures.push({
+				id: type.id,
+				reason: `texture ${locator} has no opaque pixels; exported without a colour`
+			});
+		} else failures.push({
+			id: type.id,
+			reason: "no entity texture found; exported without a colour"
+		});
+		entities[type.id] = entry;
+	}
+	return {
+		entities,
+		failures
+	};
+}
+//#endregion
+export { entityTypesOf as n, collectEntities as t };

package/dist/{entity-fallback-DutR9Hdz.js → entity-fallback-Bth0fa7m.js}

@@ -1,6 +1,6 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
 import { a as findChestTexture, i as findBedTexture, l as findMobTexture, n as HEAD_LAYOUTS, o as findEntityTexture, r as coversSheet, t as DYE_COLORS, u as tokens } from "./entity-textures-DFRIVdF1.js";
-import { c as renderModel } from "./obj-BaGvPUbb.js";
+import { c as renderModel } from "./obj-CJHEHpki.js";
 //#region src/render/entity-fallback.ts
 /**
 * Heuristic rendering for mod items that parent `builtin/entity` — chests,

package/dist/entity-geo-B2CkuMWx.js

@@ -0,0 +1,100 @@
+import { n as ResourceLocator } from "./locator-COMEtEn9.js";
+import { t as geoToModel } from "./geo-model-Bo1gpEwX.js";
+import { i as parseGeo, r as nameTokens } from "./geo-Desq-gRC.js";
+//#region src/blocks/entity-geo.ts
+/**
+* Finding the `.geo.json` a GeckoLib entity is drawn from.
+*
+* The registration is in Java — `GeoModel.getModelResource` returns a resource location — so there is
+* no data to read it out of, and this is a search by name. The same problem `findGeoForItem` solves for
+* items, with the directories a *mob* is filed under instead: `geo/entity/` if the mod is tidy, a flat
+* `geo/` if not (Creeper Overhaul, Ars Nouveau and Aquatic Frontiers all are).
+*
+* The search never leaves a `geo` directory, and every rule below is a name test rather than a
+* similarity score, so the worst case is finding nothing rather than drawing a mob as another one.
+*/
+/** Where a mod keeps entity geometry, in the order worth trying. */
+const GEO_DIRECTORIES = [
+	"geo/entity",
+	"geo",
+	"geckolib/geo/entity",
+	"geckolib/geo",
+	"geo/entities"
+];
+/** A geo path under some `geo` directory, for the scan that runs when the conventional spots miss. */
+const UNDER_GEO = /(?:^|\/)(?:geo|geckolib\/geo)\//;
+/**
+* The geometry for one entity, or null when the mod does not ship any under that name.
+*
+* `namespace` and `name` come from the entity id, so `occultism:afrit` looks for
+* `assets/occultism/geo/entity/afrit.geo.json` and its neighbours. Nothing is inferred from the
+* *class* here: a GeckoLib mob has no model class to inspect.
+*/
+async function findGeoForEntity(resources, namespace, name) {
+	const paths = GEO_DIRECTORIES.map((directory) => `${directory}/${name}.geo.json`);
+	for (const path of paths) {
+		const found = await load(resources, namespace, path);
+		if (found) return found;
+	}
+	const files = (await resources.listResources("raw", namespace)).map((candidate) => candidate.path).filter((path) => path.endsWith(".geo.json") && UNDER_GEO.test(path)).toSorted((left, right) => left.length - right.length);
+	for (const path of ranked(files, name)) {
+		const found = await load(resources, namespace, path);
+		if (found) return found;
+	}
+	return null;
+}
+const baseName = (path) => path.split("/").pop()?.replace(/\.geo\.json$/, "") ?? "";
+/**
+* The geo files that could be this entity's, best first.
+*
+* A mod's entity id and its geometry's filename agree less often than you would hope, and they
+* disagree in three shapes, each of which is here because a real mod does it:
+*
+* 1. **The same name spelled differently.** Ars Nouveau registers `bookwyrm` and ships
+*    `book_wyrm.geo.json`.
+* 2. **A decorated entity, the plain model.** `familiar_drygmy` is drawn by `drygmy`, and
+*    `marid_unbound` by `marid`. So a geo whose every token appears in the entity's name qualifies,
+*    most specific first — a subset test rather than a similarity score, so an unrelated model can
+*    never win.
+* 3. **A plain entity, a decorated model.** Occultism registers `foliot` and ships only its jobs:
+*    `foliot_worker`, `foliot_crusher`, `foliot_lumberjack`. Any of them is a foliot, so the shortest
+*    wins. Last, because this is the one direction that is a guess.
+*/
+function ranked(files, name) {
+	const flattened = name.replaceAll("_", "");
+	const wanted = new Set(nameTokens(name));
+	const exact = files.filter((path) => baseName(path) === name);
+	const spelling = files.filter((path) => baseName(path).replaceAll("_", "") === flattened);
+	const decorated = files.filter((path) => {
+		const tokens = nameTokens(baseName(path));
+		return tokens.length > 0 && tokens.every((token) => wanted.has(token));
+	}).toSorted((left, right) => nameTokens(baseName(right)).length - nameTokens(baseName(left)).length);
+	const variants = files.filter((path) => {
+		const tokens = new Set(nameTokens(baseName(path)));
+		return [...wanted].every((token) => tokens.has(token));
+	});
+	return [.../* @__PURE__ */ new Set([
+		...exact,
+		...spelling,
+		...decorated,
+		...variants
+	])];
+}
+async function load(resources, namespace, path) {
+	const raw = await resources.getResource("raw", new ResourceLocator(namespace, path));
+	if (!raw) return null;
+	let model;
+	try {
+		const geo = parseGeo(JSON.parse(raw.toString("utf8")));
+		if (!geo) return null;
+		model = geoToModel(geo);
+	} catch {
+		return null;
+	}
+	return model.parts.length > 0 ? {
+		id: `${namespace}:${path}`,
+		model
+	} : null;
+}
+//#endregion
+export { findGeoForEntity as t };

package/dist/entity-models-B6-0r2gR.js

@@ -0,0 +1,123 @@
+import { t as findGeoForEntity } from "./entity-geo-B2CkuMWx.js";
+import { n as extractInheritedModel } from "./inherit-KkDsM2N_.js";
+import { a as linkEntityModel, i as classReader, r as buildModelNameIndex } from "./link-Bm5oQYh6.js";
+import { s as resolveMappings, t as MappingsUnavailableError } from "./mappings-BEPVaiwE.js";
+import { n as loadModelCode } from "./model-code-BKMEMXxF.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
+* bytecode, and stitch the sheets those models are drawn with.
+*
+* The pieces all live in `src/entities/` — this is the part that knows what a *pack* wants. Which is
+* mostly two things the extractor does not care about: several entities share one model (every zombie
+* in the game is a `HumanoidModel`), so models are keyed by class and pointed at rather than copied;
+* and the `uv` values in a model address the entity's own sheet, so those sheets have to be in an
+* atlas the consumer can sample.
+*
+* Needs the *code*, not just the assets. An `--assets` folder has none, and a pack exported from one
+* carries no entity geometry — which is the honest answer rather than a silent gap.
+*/
+function countCubes(part) {
+	return part.cubes.length + part.children.reduce((sum, child) => sum + countCubes(child), 0);
+}
+/** Drops the internal shape into the pack's, omitting what is at its default. */
+function toPackPart(part) {
+	return {
+		name: part.name,
+		pivot: [...part.pivot],
+		rotation: [...part.rotation],
+		cubes: part.cubes.map((cube) => {
+			return {
+				origin: [...cube.origin],
+				size: [...cube.size],
+				uv: [...cube.uv],
+				...cube.inflate !== 0 && { inflate: cube.inflate },
+				...cube.mirror && { mirror: true },
+				...cube.faces && { faces: cube.faces }
+			};
+		}),
+		children: part.children.map((child) => toPackPart(child))
+	};
+}
+/**
+* Recovers geometry for as many of `entityIds` as the code describes.
+*
+* Mappings are resolved once: downloaded for an obfuscated jar, and the identity for one that is not
+* (from the 26 line the client ships in the clear, and a mod jar never was obfuscated). A version that
+* is obfuscated *and* unmapped — 1.13.x — yields nothing, with the reason recorded once rather than
+* per entity.
+*/
+async function collectEntityGeometry(options) {
+	const { classes, entityIds } = options;
+	const models = {};
+	const modelOf = /* @__PURE__ */ new Map();
+	const spriteIds = /* @__PURE__ */ new Set();
+	const failures = [];
+	const names = await classes.list();
+	let mappings;
+	try {
+		({mappings} = await resolveMappings(options.version, options.cacheDir, async () => names));
+	} catch (err) {
+		failures.push({
+			id: options.version,
+			reason: err instanceof MappingsUnavailableError ? `no entity geometry: ${err.message}` : `no entity geometry: mappings could not be loaded (${err.message})`
+		});
+		return {
+			models,
+			modelOf,
+			spriteIds,
+			failures
+		};
+	}
+	const code = await loadModelCode(names, async (internal) => await classes.read(internal), (internal) => mappings.originalOf.get(internal) ?? internal);
+	const extracted = /* @__PURE__ */ new Map();
+	const geometryOf = async (internal) => {
+		if (!extracted.has(internal)) extracted.set(internal, await extractInheritedModel(internal, async (name) => await classes.read(name), code));
+		return extracted.get(internal) ?? null;
+	};
+	const context = {
+		mappings,
+		read: classReader(async (internal) => await classes.read(internal)),
+		hasGeometry: async (internal) => {
+			const model = await geometryOf(internal);
+			return model !== null && model.parts.reduce((sum, part) => sum + countCubes(part), 0) > 0;
+		},
+		nameIndex: buildModelNameIndex(names)
+	};
+	const geoFor = async (entityId) => {
+		if (!options.resources) return null;
+		const [namespace, name] = entityId.includes(":") ? entityId.split(":") : ["minecraft", entityId];
+		return await findGeoForEntity(options.resources, namespace, name);
+	};
+	let done = 0;
+	for (const entityId of [...entityIds].toSorted((left, right) => left.localeCompare(right))) {
+		options.onProgress?.(++done, entityIds.length);
+		const link = await linkEntityModel(entityId, context);
+		const found = link ? {
+			id: link.className,
+			model: await geometryOf(link.obfuscated)
+		} : await geoFor(entityId);
+		if (!found?.model) continue;
+		const { id: modelId, model } = found;
+		if (!models[modelId]) models[modelId] = {
+			textureSize: [...model.textureSize],
+			parts: model.parts.map((part) => toPackPart(part)),
+			...model.notes.length > 0 && { notes: [...model.notes] }
+		};
+		modelOf.set(entityId, modelId);
+		const texture = options.textureOf.get(entityId);
+		if (texture) spriteIds.add(texture);
+		else failures.push({
+			id: entityId,
+			reason: `geometry recovered from ${modelId} but no entity texture resolved`
+		});
+	}
+	return {
+		models,
+		modelOf,
+		spriteIds,
+		failures
+	};
+}
+//#endregion
+export { collectEntityGeometry as t };

package/dist/entity-models-c2HpfdWV.d.ts

@@ -0,0 +1,49 @@
+import { a as ResourceManager } from "./manager-exOIcdyx.js";
+import { S as EntityPackModel } from "./pack-format-QcVFxG_b.js";
+//#region src/blocks/entity-models.d.ts
+/** What the exporter needs to read code out of; a jar, in practice. */
+interface ClassSource {
+  list: () => Promise<string[]>;
+  read: (internalName: string) => Promise<Uint8Array | null>;
+}
+interface EntityGeometryResult {
+  /** Model id (the class it came from) → geometry. */
+  models: Record<string, EntityPackModel>;
+  /** Entity id → model id, for the entity table to point with. */
+  modelOf: Map<string, string>;
+  /** Entity sheets the models address, to be stitched into the pack's own atlas. */
+  spriteIds: Set<string>;
+  failures: Array<{
+    id: string;
+    reason: string;
+  }>;
+}
+interface CollectEntityGeometryOptions {
+  version: string;
+  /** Where mappings cache; the same directory the jars do. */
+  cacheDir: string;
+  classes: ClassSource;
+  /** Entity ids to look for, as the registry named them. */
+  entityIds: readonly string[];
+  /** The sheet each entity resolved to, from the entity registry, keyed by entity id. */
+  textureOf: ReadonlyMap<string, string>;
+  /**
+   * The assets, for the mods whose geometry is not in code at all.
+   *
+   * A GeckoLib mob ships Blockbench's bedrock format and registers it by resource location, so there
+   * is nothing for the interpreter to read; `entity-geo.ts` finds and converts it instead.
+   */
+  resources?: ResourceManager;
+  onProgress?: (done: number, total: number) => void;
+}
+/**
+ * Recovers geometry for as many of `entityIds` as the code describes.
+ *
+ * Mappings are resolved once: downloaded for an obfuscated jar, and the identity for one that is not
+ * (from the 26 line the client ships in the clear, and a mod jar never was obfuscated). A version that
+ * is obfuscated *and* unmapped — 1.13.x — yields nothing, with the reason recorded once rather than
+ * per entity.
+ */
+declare function collectEntityGeometry(options: CollectEntityGeometryOptions): Promise<EntityGeometryResult>;
+//#endregion
+export { collectEntityGeometry as i, CollectEntityGeometryOptions as n, EntityGeometryResult as r, ClassSource as t };

package/dist/{export-wvt0Fryo.d.ts → export-D8fLC1wS.d.ts}

@@ -1,4 +1,5 @@
 import { a as ResourceManager } from "./manager-exOIcdyx.js";
+import { t as ClassSource } from "./entity-models-c2HpfdWV.js";
 //#region src/blocks/export.d.ts
 interface ExportBlockPackOptions {
   resources: ResourceManager;
@@ -25,6 +26,22 @@ interface ExportBlockPackOptions {
    * or a handful of charcoal from. On by default.
    */
   items?: boolean;
+  /**
+   * Export `entities.json`: every entity type the namespaces register, with a display name and the
+   * mean colour of its sheet. On by default. No geometry — no jar has any — but it is what lets a
+   * consumer name and tint the stand-in box it draws for a mob.
+   */
+  entities?: boolean;
+  /**
+   * Reads class files, for recovering entity geometry from the client's own code.
+   *
+   * Entity models are Java at every version, so without this a pack carries entity names and marker
+   * colours but no shapes. Absent for an `--assets` run, which has no code to read — the honest
+   * answer there is no geometry rather than a silent gap.
+   */
+  classes?: ClassSource;
+  /** Where mappings cache; the jar cache directory. */
+  cacheDir?: string;
   onProgress?: (stage: string, done: number, total: number) => void;
 }
 interface BlockPackFailure {
@@ -33,7 +50,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' | 'intentional';
+  kind: 'blockstate' | 'model' | 'texture' | 'sprite' | 'geometry' | 'tint' | 'biome' | 'item' | 'entity' | 'intentional';
   reason: string;
 }
 interface BlockPackResult {
@@ -45,6 +62,10 @@ interface BlockPackResult {
   biomes: number;
   /** Flat items described in `items.json`; `0` means the file was not written. */
   items: number;
+  /** Entity types described in `entities.json`; `0` means the file was not written. */
+  entities: number;
+  /** Distinct entity models in `entity-models.json`; `0` means the file was not written. */
+  entityModels: number;
   /** Files actually written — the only trustworthy success signal. */
   writtenFiles: number;
   failures: BlockPackFailure[];