@nodecraft/rendermite 1.5.0 → 1.6.1

package/dist/link-5GmBLTzk.js

@@ -0,0 +1,355 @@
+import { t as parseClassFile } from "./classfile-Bo7FUrrD.js";
+//#region src/entities/link.ts
+/**
+* Which class holds a given entity's geometry.
+*
+* Three routes, cheapest first, because the game itself only states this in code:
+*
+* 1. `<Type>Model` — 67 of vanilla 1.21.1's types, and the reason it works is that Mojang names the
+*    class after the mob.
+* 2. `<Type>Renderer`, following its **superclass chain**. A renderer that subclasses another never
+*    mentions the model at all — `CaveSpiderRenderer` hands a layer to `SpiderRenderer`, which is
+*    where `new SpiderModel` lives — so stopping at the class itself loses every shared model in the
+*    game: cave spider, husk, stray, wither skeleton, magma cube, zoglin, all of the illagers.
+* 3. `RENDERER_ALIASES` — the mobs whose renderer is simply not named after them. A mooshroom is a
+*    `MushroomCowRenderer`, a wither is a `WitherBossRenderer`, a skeleton horse is an
+*    `UndeadHorseRenderer`. There is nothing in the assets or the class names to derive that from, so
+*    it is written down, and `NO_MODEL` below is what stops the list quietly rotting.
+*
+* The authoritative source would be `EntityRenderers.createEntityRenderers`, which registers every
+* type against its renderer — but it does so through `::new` method references, so reading it means
+* interpreting `invokedynamic` bootstrap arguments. A fifteen-line table that a test can prove
+* complete is the better trade.
+*/
+/**
+* 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.
+*/
+const RENDERER_ALIASES = {
+	mooshroom: "MushroomCowRenderer",
+	skeleton_horse: "UndeadHorseRenderer",
+	zombie_horse: "UndeadHorseRenderer",
+	donkey: ["DonkeyRenderer", "ChestedHorseRenderer"],
+	mule: ["DonkeyRenderer", "ChestedHorseRenderer"],
+	trader_llama: "LlamaRenderer",
+	zombified_piglin: "PiglinRenderer",
+	piglin_brute: "PiglinRenderer",
+	wither: "WitherBossRenderer",
+	ender_dragon: "EnderDragonRenderer",
+	giant: "GiantMobRenderer",
+	killer_bunny: "RabbitRenderer",
+	glow_squid: "SquidModel",
+	magma_cube: ["LavaSlimeRenderer", "LavaSlimeModel"],
+	zombie_pigman: "PigZombieRenderer",
+	mannequin: "PlayerModel",
+	chest_minecart: "MinecartRenderer",
+	furnace_minecart: "MinecartRenderer",
+	hopper_minecart: "MinecartRenderer",
+	spawner_minecart: "MinecartRenderer",
+	command_block_minecart: "MinecartRenderer",
+	tnt_minecart: "MinecartRenderer"
+};
+/**
+* Families whose members all draw one model, matched by suffix.
+*
+* 1.21.2 split every boat into one entity type per wood — `acacia_boat`, `birch_chest_boat`, twenty of
+* them — all still drawn by the one `BoatModel` with a different texture. A pattern is the honest way
+* to say that; twenty alias entries would say the same thing twenty times and still miss the next wood
+* Mojang adds.
+*/
+const FAMILY_PATTERNS = [
+	{
+		suffix: "_chest_raft",
+		classes: ["ChestRaftModel", "RaftModel"]
+	},
+	{
+		suffix: "_raft",
+		classes: ["RaftModel"]
+	},
+	{
+		suffix: "_chest_boat",
+		classes: ["ChestBoatModel", "BoatModel"]
+	},
+	{
+		suffix: "_boat",
+		classes: ["BoatModel"]
+	}
+];
+/**
+* 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.
+*/
+const NO_MODEL = /* @__PURE__ */ new Set([
+	"item",
+	"falling_block",
+	"falling_block_type",
+	"tnt",
+	"item_frame",
+	"glow_item_frame",
+	"ominous_item_spawner",
+	"egg",
+	"splash_potion",
+	"lingering_potion",
+	"wind_charge",
+	"breeze_wind_charge",
+	"arrow",
+	"spectral_arrow",
+	"trident",
+	"lightning_bolt",
+	"end_crystal",
+	"wither_skull",
+	"shulker_bullet",
+	"leash_knot",
+	"llama_spit",
+	"snowball",
+	"potion",
+	"ender_pearl",
+	"experience_bottle",
+	"eye_of_ender",
+	"firework_rocket",
+	"painting",
+	"fishing_bobber",
+	"experience_orb",
+	"small_fireball",
+	"fireball",
+	"dragon_fireball",
+	"area_effect_cloud",
+	"creaking_transient",
+	"marker",
+	"interaction",
+	"block_display",
+	"item_display",
+	"text_display"
+]);
+/**
+* Bases that define no boxes, so landing on one from a renderer chain means finding nothing.
+*
+* Deliberately *not* `HumanoidModel` or `QuadrupedModel`, which look abstract and are anything but:
+* they are where the shared body is actually built, and every zombie, skeleton and villager in the
+* game inherits its geometry from the first. Excluding them cost six mobs.
+*/
+const ABSTRACT_MODELS = /* @__PURE__ */ new Set([
+	"EntityModel",
+	"HierarchicalModel",
+	"ListModel",
+	"AgeableListModel",
+	"AgeableHierarchicalModel",
+	"ColorableHierarchicalModel",
+	"ColorableAgeableListModel",
+	"ArmedModel",
+	"HeadedModel",
+	"SkullModelBase",
+	"VillagerHeadModel"
+]);
+/**
+* Mapped classes called `<Name>Model`, wherever they live.
+*
+* Not a fixed package, because 1.21.11 reorganised every model into a sub-package — `CowModel` moved
+* to `client.model.animal.cow` and `TridentModel` to `client.model.object.projectile`. Matching on the
+* simple name under any `client.model` package survives that, and would have survived it in advance.
+*/
+function modelClassesNamed(simple, mappings) {
+	return mappings.obfuscatedOf.keys().filter((className) => className.endsWith(`.${simple}Model`) && className.includes(".client.model")).toArray();
+}
+function pascal(name) {
+	return name.split("_").filter(Boolean).map((word) => word[0].toUpperCase() + word.slice(1)).join("");
+}
+/** Every `*Model` class a class's constant pool names, deobfuscated. */
+function modelsNamedBy(file, mappings) {
+	const found = /* @__PURE__ */ new Set();
+	for (const [index, constant] of file.constants.entries()) {
+		if (constant?.tag !== "class") continue;
+		const original = mappings.originalOf.get(file.utf8(index).replaceAll("/", "."));
+		if (original && /Model[A-Z]?$/.test(original) && /\.client\.(?:model|renderer)[.$]/.test(original)) {
+			const simple = original.split(/[.$]/).pop() ?? "";
+			if (!ABSTRACT_MODELS.has(simple)) found.add(original);
+		}
+	}
+	return [...found];
+}
+/**
+* Walks a model class's own superclass chain for the first ancestor that defines boxes.
+*
+* `ZombieModel` extends `AbstractZombieModel` extends `HumanoidModel`, and only the last of those
+* builds anything — so a zombie's geometry is two hops above the class named after it.
+*/
+async function inheritedModel(className, context, depth = 0) {
+	if (depth > 4) return null;
+	const obfuscated = context.mappings.obfuscatedOf.get(className);
+	if (!obfuscated) return null;
+	const parent = (await context.read(obfuscated))?.superClass?.replaceAll("/", ".");
+	if (!parent || parent === "java.lang.Object") return null;
+	const original = context.mappings.originalOf.get(parent) ?? parent;
+	const simple = original.split(/[.$]/).pop() ?? "";
+	if (!ABSTRACT_MODELS.has(simple)) {
+		const parentObfuscated = context.mappings.obfuscatedOf.get(original);
+		if (parentObfuscated && await context.hasGeometry(parentObfuscated)) return {
+			className: original,
+			obfuscated: parentObfuscated,
+			route: "model-name"
+		};
+	}
+	return await inheritedModel(original, context, depth + 1);
+}
+/** Follows a renderer's superclass chain until something names a model. */
+async function modelsForRenderer(obfuscated, context, depth = 0) {
+	if (depth > 4) return [];
+	const file = await context.read(obfuscated);
+	if (!file) return [];
+	const named = modelsNamedBy(file, context.mappings);
+	if (named.length > 0) return named;
+	const parent = file.superClass?.replaceAll("/", ".");
+	return parent && parent !== "java.lang.Object" ? await modelsForRenderer(parent, context, depth + 1) : [];
+}
+/**
+* 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`.
+*/
+function normaliseModelName(name) {
+	let value = name.replaceAll(/[^a-z\d]/gi, "").toLowerCase();
+	let previous = "";
+	while (value !== previous) {
+		previous = value;
+		value = value.replace(/^(?:model|entity|render(?:er)?)/, "").replace(/(?:model|entity|render(?:er)?)$/, "");
+	}
+	return value;
+}
+/**
+* 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.
+*/
+function buildModelNameIndex(internalNames) {
+	const index = /* @__PURE__ */ new Map();
+	for (const internal of internalNames) {
+		const simple = internal.split("/").pop() ?? "";
+		if (!/model/i.test(simple)) continue;
+		for (const candidate of [simple, ...simple.split("$").slice(1)]) {
+			const key = normaliseModelName(candidate);
+			if (key.length < 3) continue;
+			const held = index.get(key);
+			if (held) held.push(internal);
+			else index.set(key, [internal]);
+		}
+	}
+	return index;
+}
+/**
+* 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.
+*/
+async function linkEntityModel(entityId, context) {
+	const name = entityId.includes(":") ? entityId.slice(entityId.indexOf(":") + 1) : entityId;
+	const modded = entityId.includes(":") && !entityId.startsWith("minecraft:");
+	const { mappings } = context;
+	const accept = async (className, route) => {
+		const obfuscated = mappings.obfuscatedOf.get(className);
+		if (!obfuscated || !await context.hasGeometry(obfuscated)) return null;
+		return {
+			className,
+			obfuscated,
+			route
+		};
+	};
+	for (const className of modelClassesNamed(pascal(name), mappings)) {
+		const direct = await accept(className, "model-name");
+		if (direct) return direct;
+		const inherited = await inheritedModel(className, context);
+		if (inherited) return inherited;
+	}
+	const family = FAMILY_PATTERNS.find((candidate) => name.endsWith(candidate.suffix))?.classes ?? [];
+	const aliased = RENDERER_ALIASES[name];
+	const attempts = [
+		...(typeof aliased === "string" ? [aliased] : aliased ?? []).map((simple) => [simple, "alias"]),
+		...family.map((simple) => [simple, "alias"]),
+		[`${pascal(name)}Renderer`, "renderer"]
+	];
+	for (const [simple, route] of attempts) {
+		if (!simple) continue;
+		const candidates = mappings.obfuscatedOf.keys().filter((className) => className.endsWith(`.${simple}`) && /\.client\.(?:model|renderer)[.$]/.test(className)).toArray();
+		candidates.sort((left, right) => right.length - left.length);
+		for (const className of candidates) {
+			const direct = await accept(className, route) ?? await inheritedModel(className, context);
+			if (direct) return {
+				...direct,
+				route
+			};
+			const obfuscated = mappings.obfuscatedOf.get(className);
+			if (!obfuscated) continue;
+			for (const model of await modelsForRenderer(obfuscated, context)) {
+				const accepted = await accept(model, route) ?? await inheritedModel(model, context);
+				if (accepted) return {
+					...accepted,
+					route
+				};
+			}
+		}
+	}
+	for (const internal of context.nameIndex?.get(normaliseModelName(name)) ?? []) {
+		const dotted = internal.replaceAll("/", ".");
+		if (await context.hasGeometry(dotted)) return {
+			className: dotted,
+			obfuscated: dotted,
+			route: "mod-name"
+		};
+	}
+	if (modded) for (const shorter of withTokensDropped(name)) {
+		const found = await linkEntityModel(shorter, context);
+		if (found) return {
+			...found,
+			route: "vanilla-name"
+		};
+	}
+	return null;
+}
+/**
+* The name with some of its tokens dropped, longest first: `summon_horse` gives `summon` and `horse`.
+*
+* Capped at five tokens, because the subsets double with each one and no id is longer than that for a
+* reason this would help with.
+*/
+function withTokensDropped(name) {
+	const tokens = name.split("_").filter((token) => token.length > 0);
+	if (tokens.length < 2 || tokens.length > 5) return [];
+	const found = [];
+	for (let size = tokens.length - 1; size >= 1; size--) for (let mask = 0; mask < 2 ** tokens.length; mask++) {
+		const kept = tokens.filter((token, index) => (mask & 1 << index) !== 0);
+		if (kept.length === size) found.push(kept.join("_"));
+	}
+	return [...new Set(found)];
+}
+/** Reads and caches classes out of an extracted jar directory or a jar reader. */
+function classReader(load) {
+	const cache = /* @__PURE__ */ new Map();
+	return async (obfuscated) => {
+		if (cache.has(obfuscated)) return cache.get(obfuscated) ?? null;
+		let parsed = null;
+		const bytes = await load(obfuscated);
+		if (bytes) try {
+			parsed = parseClassFile(bytes);
+		} catch {
+			parsed = null;
+		}
+		cache.set(obfuscated, parsed);
+		return parsed;
+	};
+}
+//#endregion
+export { linkEntityModel as a, classReader as i, RENDERER_ALIASES as n, normaliseModelName as o, buildModelNameIndex as r, NO_MODEL as t };

package/dist/mappings-BEPVaiwE.js

@@ -0,0 +1,139 @@
+import path from "node:path";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+//#region src/entities/mappings.ts
+/**
+* Mojang's official obfuscation mappings, which are what turn a jar full of `fvd.class` into named
+* entity models.
+*
+* Published per version in the same manifest the client jar comes from — `downloads.client_mappings`,
+* about 9 MB — so this is a second download from a place the pipeline already goes. Deliberately not
+* the mcversions index `download.ts` uses for jars: that index carries jars only.
+*
+* ProGuard format, which is two kinds of line:
+*
+*     net.minecraft.client.model.CowModel -> fvd:
+*         net.minecraft...LayerDefinition createBodyLayer() -> a
+*
+* Unindented lines map a class, indented ones its members. Only classes are read here; the geometry
+* extractor works on descriptor shape rather than member names, so member mappings buy nothing.
+*
+* Published from 1.14.4 through 1.21.11, and then not again — because from the 26 line Mojang stopped
+* *obfuscating* the client. A 26.2 jar ships `net/minecraft/client/model/ambient/BatModel.class` under
+* its real name, so the mapping it needs is the identity one, which `identityMappings` builds from the
+* jar's own class list.
+*
+* That leaves 1.13.x as the only gap: obfuscated, and predating published mappings. Reported rather
+* than worked around.
+*/
+const VERSION_MANIFEST = "https://launchermeta.mojang.com/mc/game/version_manifest_v2.json";
+var MappingsUnavailableError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "MappingsUnavailableError";
+	}
+};
+/**
+* Downloads a version's client mappings, caching by version beside the jars.
+*
+* Throws rather than returning null: a caller that asked for mappings cannot do its job without them,
+* and the difference between "this version publishes none" and "the network failed" is worth keeping.
+*/
+async function downloadClientMappings(version, cacheDir) {
+	const target = path.join(cacheDir, `${version}-client-mappings.txt`);
+	if (existsSync(target)) return target;
+	await mkdir(cacheDir, { recursive: true });
+	const manifestResponse = await fetch(VERSION_MANIFEST);
+	if (!manifestResponse.ok) throw new MappingsUnavailableError(`Version manifest fetch failed: ${manifestResponse.status}`);
+	const entry = (await manifestResponse.json()).versions?.find((candidate) => candidate.id === version);
+	if (!entry) throw new MappingsUnavailableError(`${version} is not in Mojang's version manifest`);
+	const metaResponse = await fetch(entry.url);
+	if (!metaResponse.ok) throw new MappingsUnavailableError(`Version metadata fetch failed for ${version}: ${metaResponse.status}`);
+	const mappings = (await metaResponse.json()).downloads?.client_mappings;
+	if (!mappings) throw new MappingsUnavailableError(`${version} publishes no client mappings; they start at 1.14.4`);
+	const download = await fetch(mappings.url);
+	if (!download.ok) throw new MappingsUnavailableError(`Mappings download failed for ${version}: ${download.status}`);
+	const partial = `${target}.partial`;
+	await writeFile(partial, Buffer.from(await download.arrayBuffer()));
+	await rename(partial, target);
+	return target;
+}
+/** Parses the class lines of a ProGuard mapping file. */
+function parseMappings(text) {
+	const obfuscatedOf = /* @__PURE__ */ new Map();
+	const originalOf = /* @__PURE__ */ new Map();
+	for (const line of text.split("\n")) {
+		if (line.length === 0 || line.startsWith(" ") || line.startsWith("	") || line.startsWith("#")) continue;
+		const divider = line.indexOf(" -> ");
+		if (divider === -1) continue;
+		const original = line.slice(0, divider).trim();
+		const obfuscated = line.slice(divider + 4).trim().replace(/:$/, "");
+		if (original.length === 0 || obfuscated.length === 0) continue;
+		obfuscatedOf.set(original, obfuscated);
+		originalOf.set(obfuscated, original);
+	}
+	return {
+		obfuscatedOf,
+		originalOf
+	};
+}
+async function loadMappings(version, cacheDir) {
+	return parseMappings(await readFile(await downloadClientMappings(version, cacheDir), "utf8"));
+}
+/**
+* Mappings for a jar that was never obfuscated: every class maps to itself.
+*
+* `internalNames` are as the archive spells them (`net/minecraft/client/model/animal/cow/CowModel`);
+* the maps use dots, because that is what a mapping file and every lookup here use.
+*/
+function identityMappings(internalNames) {
+	const obfuscatedOf = /* @__PURE__ */ new Map();
+	const originalOf = /* @__PURE__ */ new Map();
+	for (const internal of internalNames) {
+		const dotted = internal.replaceAll("/", ".");
+		obfuscatedOf.set(dotted, dotted);
+		originalOf.set(dotted, dotted);
+	}
+	return {
+		obfuscatedOf,
+		originalOf
+	};
+}
+/**
+* Whether a jar still needs a mapping at all.
+*
+* Decided on the **models package**, not on `net/minecraft/` generally: an obfuscated jar keeps a
+* couple of dozen classes in the clear — the launcher entrypoint and the brand retriever are never
+* obfuscated — so 1.21.1 has 26 `net/minecraft/` entries and zero under `client/model/`, where 26.2
+* has 358. Which is also the precise question the extractor is asking.
+*/
+function isObfuscated(internalNames) {
+	for (const name of internalNames) if (name.startsWith("net/minecraft/client/model/")) return false;
+	return true;
+}
+/**
+* The mappings for a version, however it ships them.
+*
+* **The jar decides, not the manifest.** From the 26 line the client is not obfuscated, so its own
+* class names are the real ones and no mapping is needed — asking Mojang first would mean two HTTP
+* requests per export to learn something the archive already states, and would make an offline export
+* of a current version fail for no reason.
+*/
+async function resolveMappings(version, cacheDir, listClasses) {
+	const names = await listClasses();
+	if (!isObfuscated(names)) return {
+		mappings: identityMappings(names),
+		obfuscated: false
+	};
+	try {
+		return {
+			mappings: await loadMappings(version, cacheDir),
+			obfuscated: true
+		};
+	} catch (err) {
+		if (!(err instanceof MappingsUnavailableError)) throw err;
+		throw new MappingsUnavailableError(`${version} publishes no mappings and its jar is obfuscated; entity geometry needs 1.14.4 or newer`, { cause: err });
+	}
+}
+//#endregion
+export { loadMappings as a, isObfuscated as i, downloadClientMappings as n, parseMappings as o, identityMappings as r, resolveMappings as s, MappingsUnavailableError as t };

package/dist/mappings-DxX4KoZl.d.ts

@@ -0,0 +1,75 @@
+//#region src/entities/mappings.d.ts
+/**
+ * Mojang's official obfuscation mappings, which are what turn a jar full of `fvd.class` into named
+ * entity models.
+ *
+ * Published per version in the same manifest the client jar comes from — `downloads.client_mappings`,
+ * about 9 MB — so this is a second download from a place the pipeline already goes. Deliberately not
+ * the mcversions index `download.ts` uses for jars: that index carries jars only.
+ *
+ * ProGuard format, which is two kinds of line:
+ *
+ *     net.minecraft.client.model.CowModel -> fvd:
+ *         net.minecraft...LayerDefinition createBodyLayer() -> a
+ *
+ * Unindented lines map a class, indented ones its members. Only classes are read here; the geometry
+ * extractor works on descriptor shape rather than member names, so member mappings buy nothing.
+ *
+ * Published from 1.14.4 through 1.21.11, and then not again — because from the 26 line Mojang stopped
+ * *obfuscating* the client. A 26.2 jar ships `net/minecraft/client/model/ambient/BatModel.class` under
+ * its real name, so the mapping it needs is the identity one, which `identityMappings` builds from the
+ * jar's own class list.
+ *
+ * That leaves 1.13.x as the only gap: obfuscated, and predating published mappings. Reported rather
+ * than worked around.
+ */
+/** Class names both ways round, which is what every lookup here needs. */
+interface Mappings {
+  /** `net.minecraft.client.model.CowModel` → `fvd`. */
+  obfuscatedOf: Map<string, string>;
+  /** `fvd` → `net.minecraft.client.model.CowModel`. */
+  originalOf: Map<string, string>;
+}
+declare class MappingsUnavailableError extends Error {
+  constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Downloads a version's client mappings, caching by version beside the jars.
+ *
+ * Throws rather than returning null: a caller that asked for mappings cannot do its job without them,
+ * and the difference between "this version publishes none" and "the network failed" is worth keeping.
+ */
+declare function downloadClientMappings(version: string, cacheDir: string): Promise<string>;
+/** Parses the class lines of a ProGuard mapping file. */
+declare function parseMappings(text: string): Mappings;
+declare function loadMappings(version: string, cacheDir: string): Promise<Mappings>;
+/**
+ * Mappings for a jar that was never obfuscated: every class maps to itself.
+ *
+ * `internalNames` are as the archive spells them (`net/minecraft/client/model/animal/cow/CowModel`);
+ * the maps use dots, because that is what a mapping file and every lookup here use.
+ */
+declare function identityMappings(internalNames: Iterable<string>): Mappings;
+/**
+ * Whether a jar still needs a mapping at all.
+ *
+ * Decided on the **models package**, not on `net/minecraft/` generally: an obfuscated jar keeps a
+ * couple of dozen classes in the clear — the launcher entrypoint and the brand retriever are never
+ * obfuscated — so 1.21.1 has 26 `net/minecraft/` entries and zero under `client/model/`, where 26.2
+ * has 358. Which is also the precise question the extractor is asking.
+ */
+declare function isObfuscated(internalNames: Iterable<string>): boolean;
+/**
+ * The mappings for a version, however it ships them.
+ *
+ * **The jar decides, not the manifest.** From the 26 line the client is not obfuscated, so its own
+ * class names are the real ones and no mapping is needed — asking Mojang first would mean two HTTP
+ * requests per export to learn something the archive already states, and would make an offline export
+ * of a current version fail for no reason.
+ */
+declare function resolveMappings(version: string, cacheDir: string, listClasses: () => Promise<string[]>): Promise<{
+  mappings: Mappings;
+  obfuscated: boolean;
+}>;
+//#endregion
+export { isObfuscated as a, resolveMappings as c, identityMappings as i, MappingsUnavailableError as n, loadMappings as o, downloadClientMappings as r, parseMappings as s, Mappings as t };

package/dist/merge-NDYxpmL8.js

@@ -0,0 +1,48 @@
+//#region src/entities/merge.ts
+/** A root the interpreter had to invent, because a `MeshDefinition`'s root part is anonymous. */
+const SYNTHETIC_ROOT = /^part\d+$/;
+/**
+* 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.
+*/
+function slotsOf(parts) {
+	const [only] = parts;
+	if (parts.length === 1 && only.cubes.length === 0 && SYNTHETIC_ROOT.test(only.name)) return {
+		container: only,
+		slots: only.children
+	};
+	return {
+		container: null,
+		slots: parts
+	};
+}
+/** True when this piece built its own mesh rather than adding to one it was handed. */
+function buildsOwnMesh(model) {
+	return slotsOf(model.parts).container !== null;
+}
+/** `base` plus the parts of `extra` that `base` does not name. */
+function mergeModels(base, extra) {
+	const target = slotsOf(base.parts);
+	const source = slotsOf(extra.parts);
+	const named = new Set(target.slots.map((part) => part.name));
+	const missing = source.slots.filter((part) => !named.has(part.name));
+	if (missing.length === 0) return base;
+	const parts = target.container ? [{
+		...target.container,
+		children: [...target.container.children, ...missing]
+	}] : [...target.slots, ...missing];
+	const notes = [.../* @__PURE__ */ new Set([...base.notes, ...extra.notes])].filter((note) => parts.length > 1 || !note.includes("disconnected roots"));
+	return {
+		textureSize: base.textureSize[0] === 64 && base.textureSize[1] === 32 ? extra.textureSize : base.textureSize,
+		parts,
+		notes
+	};
+}
+function countCubes(part) {
+	return part.cubes.length + part.children.reduce((total, child) => total + countCubes(child), 0);
+}
+function cubesOf(model) {
+	return model.parts.reduce((total, part) => total + countCubes(part), 0);
+}
+//#endregion
+export { slotsOf as a, mergeModels as i, countCubes as n, cubesOf as r, buildsOwnMesh as t };

package/dist/model-PnQ4gV0-.d.ts

@@ -0,0 +1,49 @@
+//#region src/entities/model.d.ts
+/**
+ * The shape an entity model comes out as, whichever source produced it.
+ *
+ * Two do: `model-bytecode.ts` interprets the Java that vanilla and most mods build their models in,
+ * and `geo-model.ts` converts the bedrock `.geo.json` a GeckoLib mod ships instead. Both land here, in
+ * **Java entity model space** — pixels, y measured *downwards* from 1.5 blocks above the mob's feet, a
+ * part's pivot relative to its parent's — because that is the space a consumer has to draw in anyway.
+ */
+/** The six faces a box can carry its own texture rect on. */
+type CubeFace = 'north' | 'south' | 'east' | 'west' | 'up' | 'down';
+/** One box of a part, in the model's own space. */
+interface Cube {
+  origin: [number, number, number];
+  size: [number, number, number];
+  /** Texture offset in pixels, as `texOffs`/`setTextureOffset` set it. */
+  uv: [number, number];
+  /** `CubeDeformation`/`delta`: grows the box on every side. */
+  inflate: number;
+  mirror: boolean;
+  /**
+   * Per-face texture rects, which replace the box unwrap `uv` implies when present.
+   *
+   * Java has no such thing: `addBox` always unwraps the same way. Bedrock geometry does, and uses it
+   * heavily — 56% of the cubes in a corpus of GeckoLib mods — so a consumer that ignores this draws
+   * over half of every modded mob with the wrong part of its sheet.
+   */
+  faces?: Partial<Record<CubeFace, {
+    uv: [number, number];
+    size: [number, number];
+  }>>;
+}
+interface Part {
+  name: string;
+  /** Where the part pivots, relative to its parent. */
+  pivot: [number, number, number];
+  /** Radians, as `PartPose.offsetAndRotation` states them. */
+  rotation: [number, number, number];
+  cubes: Cube[];
+  children: Part[];
+}
+interface ExtractedModel {
+  textureSize: [number, number];
+  parts: Part[];
+  /** Why nothing came out, or what was skipped. */
+  notes: string[];
+}
+//#endregion
+export { Part as i, CubeFace as n, ExtractedModel as r, Cube as t };