@nodecraft/rendermite 1.6.0 → 1.6.2

package/dist/{block-entities-xv3bQpEX.js → block-entities-XAynAVUE.js}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
-import { a as findChestTexture, c as findFluidStill, i as findBedTexture, l as findMobTexture, n as HEAD_LAYOUTS, o as findEntityTexture, r as coversSheet, s as findFluidSibling, t as DYE_COLORS } from "./entity-textures-DFRIVdF1.js";
+import { a as findBedTexture, c as findFluidSibling, i as coversSheet, l as findFluidStill, n as HEAD_LAYOUTS, o as findChestTexture, s as findEntityTexture, t as DYE_COLORS, u as findMobTexture } from "./entity-textures-4XXT8jVI.js";
 //#region src/blocks/block-entities.ts
 /**
 * Geometry for blocks the game draws from Java rather than from a model.

package/dist/blocks/block-entities.js

@@ -1,2 +1,2 @@
-import { n as blockEntityGeometry, r as synthesizeVariants, t as INVISIBLE_BLOCKS } from "../block-entities-xv3bQpEX.js";
+import { n as blockEntityGeometry, r as synthesizeVariants, t as INVISIBLE_BLOCKS } from "../block-entities-XAynAVUE.js";
 export { INVISIBLE_BLOCKS, blockEntityGeometry, synthesizeVariants };

package/dist/blocks/cli.js

@@ -1,2 +1,2 @@
-import { t as runBlocksCli } from "../cli-BSKnXBPr.js";
+import { t as runBlocksCli } from "../cli-Br0mY0LV.js";
 export { runBlocksCli };

package/dist/blocks/entities.js

@@ -1,2 +1,2 @@
-import { n as entityTypesOf, t as collectEntities } from "../entities-DvmA9fEV.js";
+import { n as entityTypesOf, t as collectEntities } from "../entities-DubtdM11.js";
 export { collectEntities, entityTypesOf };

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

@@ -1,2 +1,45 @@
-import { i as collectEntityGeometry, n as CollectEntityGeometryOptions, r as EntityGeometryResult, t as ClassSource } from "../entity-models-c2HpfdWV.js";
-export { ClassSource, CollectEntityGeometryOptions, EntityGeometryResult, collectEntityGeometry };
+import { a as ResourceManager } from "../manager-exOIcdyx.js";
+import { S as EntityPackModel } from "../pack-format-QcVFxG_b.js";
+import { t as ClassSource } from "../jar-classes-CSRrPAUy.js";
+//#region src/blocks/entity-models.d.ts
+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 { CollectEntityGeometryOptions, EntityGeometryResult, collectEntityGeometry };

package/dist/blocks/entity-models.js

@@ -1,2 +1,2 @@
-import { t as collectEntityGeometry } from "../entity-models-B6-0r2gR.js";
+import { t as collectEntityGeometry } from "../entity-models-D_QGok9j.js";
 export { collectEntityGeometry };

package/dist/blocks/export.d.ts

@@ -1,2 +1,2 @@
-import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "../export-D8fLC1wS.js";
+import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "../export-B8tPsf4K.js";
 export { BlockPackFailure, BlockPackResult, ExportBlockPackOptions, exportBlockPack };

package/dist/blocks/export.js

@@ -1,2 +1,2 @@
-import { t as exportBlockPack } from "../export-DT_drDoI.js";
+import { t as exportBlockPack } from "../export-CTKEwro6.js";
 export { exportBlockPack };

package/dist/{classfile-BwaQjnUM.d.ts → classfile-BdLIk4Pe.d.ts}

@@ -22,6 +22,10 @@ interface Constant {
   nameAndTypeIndex?: number;
   descriptorIndex?: number;
   stringIndex?: number;
+  /** A `methodHandle`'s target: an index of a `methodref`, not of a `nameAndType`. */
+  referenceIndex?: number;
+  /** An `invokeDynamic`'s row in the `BootstrapMethods` attribute. */
+  bootstrapIndex?: number;
 }
 interface MethodInfo {
   name: string;
@@ -45,6 +49,18 @@ interface ClassFile {
   } | null;
   /** The value an `ldc` of this index pushes: a number for numeric constants, a string for `string`. */
   literal: (index: number) => string | number | bigint | null;
+  /**
+   * The method a lambda actually runs, for an `invokedynamic`'s pool index.
+   *
+   * A lambda compiles to a call through `LambdaMetafactory` with the real body in a synthetic method,
+   * so this is two hops: the pool entry names a row of the `BootstrapMethods` attribute, and that
+   * row's second argument is a method handle pointing at the body.
+   */
+  lambdaTarget: (index: number) => {
+    owner: string;
+    name: string;
+    descriptor: string;
+  } | null;
 }
 declare function parseClassFile(bytes: Uint8Array): ClassFile;
 //#endregion

package/dist/{classfile-CAhS5qNf.js → classfile-Bo7FUrrD.js}

@@ -150,7 +150,7 @@ function readConstantPool(reader) {
 				reader.skip(1);
 				constants.push({
 					tag,
-					nameAndTypeIndex: reader.u2()
+					referenceIndex: reader.u2()
 				});
 				break;
 			case "methodType":
@@ -160,23 +160,39 @@ function readConstantPool(reader) {
 				});
 				break;
 			case "dynamic":
-			case "invokeDynamic":
-				reader.skip(2);
-				constants.push({
-					tag,
-					nameAndTypeIndex: reader.u2()
-				});
+			case "invokeDynamic": constants.push({
+				tag,
+				bootstrapIndex: reader.u2(),
+				nameAndTypeIndex: reader.u2()
+			});
 		}
 	}
 	return constants;
 }
-/** Skips an attribute table, returning the `Code` bytes if one of them is a Code attribute. */
-function readAttributes(reader, utf8) {
+/**
+* Skips an attribute table, keeping the two that say what a method does: `Code`, and the class-level
+* `BootstrapMethods` that a lambda's real body is reachable through.
+*/
+function readAttributes(reader, utf8, bootstraps) {
 	let code;
 	const count = reader.u2();
 	for (let index = 0; index < count; index++) {
 		const name = utf8(reader.u2());
 		const length = reader.u4();
+		if (name === "BootstrapMethods" && bootstraps) {
+			const rows = reader.u2();
+			for (let row = 0; row < rows; row++) {
+				const handleIndex = reader.u2();
+				const argumentCount = reader.u2();
+				const argumentIndexes = [];
+				for (let argument = 0; argument < argumentCount; argument++) argumentIndexes.push(reader.u2());
+				bootstraps.push({
+					handleIndex,
+					argumentIndexes
+				});
+			}
+			continue;
+		}
 		if (name !== "Code") {
 			reader.skip(length);
 			continue;
@@ -224,6 +240,8 @@ function parseClassFile(bytes) {
 			code
 		});
 	}
+	const bootstraps = [];
+	readAttributes(reader, utf8, bootstraps);
 	const reference = (index) => {
 		const entry = constants[index];
 		if (!entry || entry.classIndex === void 0 || entry.nameAndTypeIndex === void 0) return null;
@@ -241,6 +259,19 @@ function parseClassFile(bytes) {
 		if (entry.tag === "string") return utf8(index);
 		return entry.value ?? null;
 	};
+	const lambdaTarget = (index) => {
+		const entry = constants[index];
+		const row = entry?.bootstrapIndex === void 0 ? void 0 : bootstraps[entry.bootstrapIndex];
+		if (!row) return null;
+		for (const argument of row.argumentIndexes) {
+			const handle = constants[argument];
+			if (handle?.tag === "methodHandle" && handle.referenceIndex !== void 0) {
+				const target = reference(handle.referenceIndex);
+				if (target) return target;
+			}
+		}
+		return null;
+	};
 	return {
 		thisClass,
 		superClass,
@@ -248,7 +279,8 @@ function parseClassFile(bytes) {
 		methods,
 		utf8,
 		reference,
-		literal
+		literal,
+		lambdaTarget
 	};
 }
 //#endregion

package/dist/{cli-BSKnXBPr.js → cli-Br0mY0LV.js}

@@ -1,7 +1,7 @@
 import { n as builtinPackPath } from "./builtin-WkWjATeh.js";
 import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
-import { t as exportBlockPack } from "./export-DT_drDoI.js";
-import { t as JarClassReader } from "./jar-classes-Bj15hjdr.js";
+import { t as exportBlockPack } from "./export-CTKEwro6.js";
+import { n as layeredClasses, t as JarClassReader } from "./jar-classes-3GVCJZT7.js";
 import { n as prepareModResources } from "./prepare-Myd_ec4v.js";
 import { t as downloadClientJar } from "./download-1wAfrGKx.js";
 import { a as prepareVersionResources, r as compareVersions } from "./prepare-D49Gu4Lv.js";
@@ -155,6 +155,10 @@ async function runBlocksCli(argv) {
 		closeMods = () => prepared.close();
 		for (const { jar, reason } of prepared.rejected) console.error(`Rejected mod jar ${jar}: ${reason}`);
 		namespaces = values.namespace?.length ? values.namespace : prepared.namespaces;
+		if (!values["no-entity-geometry"]) {
+			const modClasses = values.mod.map((jar) => new JarClassReader(jar));
+			classes = layeredClasses(classes ? [classes, ...modClasses] : modClasses);
+		}
 	}
 	try {
 		const result = await exportBlockPack({

package/dist/cli.js

@@ -6,8 +6,8 @@ import { t as curatedModelOverrides } from "./models-CZjCOjs4.js";
 import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-BspVCz2G.js";
 import { t as downloadClientJar } from "./download-1wAfrGKx.js";
 import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS } from "./prepare-D49Gu4Lv.js";
-import { t as runBlocksCli } from "./cli-BSKnXBPr.js";
-import { t as run } from "./run-BQJkqc5f.js";
+import { t as runBlocksCli } from "./cli-Br0mY0LV.js";
+import { t as run } from "./run-BXAqZ5qY.js";
 import path from "node:path";
 import os from "node:os";
 import { parseArgs } from "node:util";

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-BwaQjnUM.js";
+import { a as parseClassFile, i as MethodInfo, n as Constant, r as ConstantTag, t as ClassFile } from "../classfile-BdLIk4Pe.js";
 export { ClassFile, Constant, ConstantTag, MethodInfo, parseClassFile };

package/dist/entities/classfile.js

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

package/dist/entities/inherit.d.ts

@@ -1,6 +1,6 @@
 import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
-import { t as ClassFile } from "../classfile-BwaQjnUM.js";
-import { t as ModelCode } from "../model-code-B7jSFQqd.js";
+import { t as ClassFile } from "../classfile-BdLIk4Pe.js";
+import { t as ModelCode } from "../model-code-BY44ao27.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-KkDsM2N_.js";
+import { n as extractInheritedModel, t as ancestryOf } from "../inherit-C5Ifg3SM.js";
 export { ancestryOf, extractInheritedModel };

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

@@ -1,26 +1,2 @@
-//#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.
- */
-/** 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 };
+import { n as JarClassReader, r as layeredClasses, t as ClassSource } from "../jar-classes-CSRrPAUy.js";
+export { ClassSource, JarClassReader, layeredClasses };

package/dist/entities/jar-classes.js

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

package/dist/entities/link.d.ts

@@ -1,4 +1,4 @@
-import { t as ClassFile } from "../classfile-BwaQjnUM.js";
+import { t as ClassFile } from "../classfile-BdLIk4Pe.js";
 import { t as Mappings } from "../mappings-DxX4KoZl.js";
 //#region src/entities/link.d.ts
 /**
@@ -38,7 +38,7 @@ interface EntityModelLink {
   /** 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';
+  route: 'model-name' | 'renderer' | 'alias' | 'mod-name' | 'vanilla-name';
 }
 /**
  * A class's simple name reduced to the entity it is about.

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

package/dist/entities/merge.d.ts

@@ -12,7 +12,22 @@ declare function slotsOf(parts: Part[]): {
 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;
+/**
+ * Drops boxes that land exactly where one already is.
+ *
+ * A model builder's branches are all taken, because they turn on a constructor argument this cannot
+ * know — a `CubeDeformation`, a baby-variant flag — so a model that builds one shape *or* another
+ * emits both. Where the two arms differ, that is the honest answer and the model says so in a note.
+ * Where they agree, it is four legs drawn twice in the same place: `HorseModel` builds
+ * `left_hind_leg` and `left_hind_baby_leg` at identical coordinates, and two coplanar boxes are
+ * exactly what z-fighting is.
+ *
+ * Keyed on the accumulated pivot and rotation rather than on evaluated corners, since duplicates come
+ * from one builder running twice and land on identical frames. The first is kept: a builder states the
+ * ordinary shape before the variant.
+ */
+declare function dedupeCubes(model: ExtractedModel): ExtractedModel;
 declare function countCubes(part: Part): number;
 declare function cubesOf(model: ExtractedModel): number;
 //#endregion
-export { buildsOwnMesh, countCubes, cubesOf, mergeModels, slotsOf };
+export { buildsOwnMesh, countCubes, cubesOf, dedupeCubes, mergeModels, slotsOf };

package/dist/entities/merge.js

@@ -1,2 +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 };
+import { a as mergeModels, i as dedupeCubes, n as countCubes, o as slotsOf, r as cubesOf, t as buildsOwnMesh } from "../merge-DeHruviG.js";
+export { buildsOwnMesh, countCubes, cubesOf, dedupeCubes, mergeModels, slotsOf };

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

@@ -1,5 +1,5 @@
 import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
-import { t as ClassFile } from "../classfile-BwaQjnUM.js";
+import { t as ClassFile } from "../classfile-BdLIk4Pe.js";
 //#region src/entities/model-bytecode.d.ts
 /**
  * Extracts whatever geometry a class's methods build.

package/dist/entities/model-bytecode.js

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

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

@@ -1,2 +1,2 @@
-import { n as isModelCode, r as loadModelCode, t as ModelCode } from "../model-code-B7jSFQqd.js";
+import { n as isModelCode, r as loadModelCode, t as ModelCode } from "../model-code-BY44ao27.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-BKMEMXxF.js";
+import { n as loadModelCode, t as isModelCode } from "../model-code-1Vuk-zj_.js";
 export { isModelCode, loadModelCode };

package/dist/{entities-DvmA9fEV.js → entities-DubtdM11.js}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
-import { l as findMobTexture, u as tokens } from "./entity-textures-DFRIVdF1.js";
+import { d as isOverlayPath, f as tokens, u as findMobTexture } from "./entity-textures-4XXT8jVI.js";
 //#region src/blocks/entities.ts
 /**
 * The entity registry, and one colour per entity.
@@ -125,13 +125,17 @@ async function findVariantTexture(resources, namespace, name) {
 		if (!locator.path.startsWith("entity/")) continue;
 		const leaf = locator.path.split("/").at(-1) ?? "";
 		if (tokens(leaf).some((token) => NOT_THE_MOB.has(token))) continue;
+		if (isOverlayPath(locator.path)) 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 folder = locator.path.split("/").slice(1, -1);
+		const inFamily = folder.length > 0 && folder.flatMap((segment) => tokens(segment)).every((token) => wanted.includes(token));
+		const named = tokens(leaf).some((token) => wanted.includes(token));
 		const depth = locator.path.split("/").length;
-		score = score * 10 - depth - candidate.length;
+		score = (inFamily ? 1e3 : 0) + score * 10 + (named ? 5 : 0) - depth - candidate.length;
 		if (score > bestScore) {
 			best = locator;
 			bestScore = score;

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

@@ -1,5 +1,5 @@
 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 { a as findBedTexture, f as tokens, i as coversSheet, n as HEAD_LAYOUTS, o as findChestTexture, s as findEntityTexture, t as DYE_COLORS, u as findMobTexture } from "./entity-textures-4XXT8jVI.js";
 import { c as renderModel } from "./obj-CJHEHpki.js";
 //#region src/render/entity-fallback.ts
 /**

package/dist/{entity-models-B6-0r2gR.js → entity-models-D_QGok9j.js}

@@ -1,8 +1,8 @@
 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 { n as extractInheritedModel } from "./inherit-C5Ifg3SM.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-BKMEMXxF.js";
+import { n as loadModelCode } from "./model-code-1Vuk-zj_.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
@@ -93,10 +93,14 @@ async function collectEntityGeometry(options) {
 	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 ? {
+		const guessed = link?.route === "vanilla-name";
+		const found = link && !guessed ? {
 			id: link.className,
 			model: await geometryOf(link.obfuscated)
-		} : await geoFor(entityId);
+		} : await geoFor(entityId) ?? (link ? {
+			id: link.className,
+			model: await geometryOf(link.obfuscated)
+		} : null);
 		if (!found?.model) continue;
 		const { id: modelId, model } = found;
 		if (!models[modelId]) models[modelId] = {

package/dist/{entity-textures-DFRIVdF1.js → entity-textures-4XXT8jVI.js}

@@ -68,6 +68,29 @@ const HEAD_LAYOUTS = {
 * live at entity/<mob>.png or entity/<mob>/<mob>.png depending on the mod, and a
 * head only ever wants the base skin — never a blink or armour overlay.
 */
+/**
+* Directories that hold an *overlay* rather than a mob.
+*
+* Matched as whole path segments rather than as tokens, because a token would take `chest_boat` out
+* along with `chest`. A trader llama is the case that needed it: its sheet is filed as
+* `entity/llama/decor/trader_llama`, whose leaf is exactly the mob's name — so a search by name found
+* the carpet it wears, which is a few opaque pixels on a transparent sheet, and the llama underneath
+* came out invisible on most of its faces.
+*/
+const OVERLAY_DIRECTORIES = /* @__PURE__ */ new Set([
+	"decor",
+	"armor",
+	"markings",
+	"glow",
+	"eyes",
+	"overlay",
+	"saddle",
+	"harness"
+]);
+/** Whether a texture is filed inside one of those, whatever the file itself is called. */
+function isOverlayPath(path) {
+	return path.split("/").slice(0, -1).some((segment) => OVERLAY_DIRECTORIES.has(segment));
+}
 async function findMobTexture(resources, namespace, mob) {
 	for (const source of [namespace, "minecraft"]) {
 		for (const candidate of [`entity/${mob}`, `entity/${mob}/${mob}`]) {
@@ -77,7 +100,7 @@ async function findMobTexture(resources, namespace, mob) {
 		let best = null;
 		for (const locator of await resources.listResources("texture", source)) {
 			const leaf = locator.path.split("/").pop();
-			if (!locator.path.startsWith("entity/") || leaf !== mob) continue;
+			if (!locator.path.startsWith("entity/") || leaf !== mob || isOverlayPath(locator.path)) continue;
 			if (best === null || locator.path.length < best.path.length) best = locator;
 		}
 		if (best) return best;
@@ -206,4 +229,4 @@ async function findFluidSibling(resources, still, suffixes) {
 	return null;
 }
 //#endregion
-export { findChestTexture as a, findFluidStill as c, findBedTexture as i, findMobTexture as l, HEAD_LAYOUTS as n, findEntityTexture as o, coversSheet as r, findFluidSibling as s, DYE_COLORS as t, tokens as u };
+export { findBedTexture as a, findFluidSibling as c, isOverlayPath as d, tokens as f, coversSheet as i, findFluidStill as l, HEAD_LAYOUTS as n, findChestTexture as o, OVERLAY_DIRECTORIES as r, findEntityTexture as s, DYE_COLORS as t, findMobTexture as u };

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

@@ -1,5 +1,5 @@
 import { a as ResourceManager } from "./manager-exOIcdyx.js";
-import { t as ClassSource } from "./entity-models-c2HpfdWV.js";
+import { t as ClassSource } from "./jar-classes-CSRrPAUy.js";
 //#region src/blocks/export.d.ts
 interface ExportBlockPackOptions {
   resources: ResourceManager;

package/dist/{export-DT_drDoI.js → export-CTKEwro6.js}

@@ -1,9 +1,9 @@
 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 { n as blockEntityGeometry, r as synthesizeVariants, t as INVISIBLE_BLOCKS } from "./block-entities-XAynAVUE.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-B6-0r2gR.js";
+import { t as collectEntities } from "./entities-DubtdM11.js";
+import { t as collectEntityGeometry } from "./entity-models-D_QGok9j.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";

package/dist/index.d.ts

@@ -8,7 +8,7 @@ import { a as resolveTexture, n as ModelResolutionError, o as salvageJson, r as
 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 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-D8fLC1wS.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

@@ -14,7 +14,7 @@ import { n as buildBlockTints, t as UNREGISTERED_TINTS } from "./tints-Cl0r-Ol3.
 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-DT_drDoI.js";
+import { t as exportBlockPack } from "./export-CTKEwro6.js";
 import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "./jar-W2cV2ZVO.js";
 import { n as prepareModResources } from "./prepare-Myd_ec4v.js";
 import { a as prepareVersionResources, i as eraForVersion, r as compareVersions } from "./prepare-D49Gu4Lv.js";
@@ -22,5 +22,5 @@ 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-BQJkqc5f.js";
+import { t as run } from "./run-BXAqZ5qY.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-KkDsM2N_.js → inherit-C5Ifg3SM.js}

@@ -1,6 +1,6 @@
-import { t as parseClassFile } from "./classfile-CAhS5qNf.js";
-import { i as mergeModels } from "./merge-3HkeQ_6A.js";
-import { t as extractModel } from "./model-bytecode-C1nw2G8O.js";
+import { t as parseClassFile } from "./classfile-Bo7FUrrD.js";
+import { a as mergeModels, i as dedupeCubes } from "./merge-DeHruviG.js";
+import { t as extractModel } from "./model-bytecode-BQKCLPze.js";
 //#region src/entities/inherit.ts
 /**
 * A model class read together with its ancestors.
@@ -71,7 +71,7 @@ async function extractInheritedModel(internalName, read, code) {
 		});
 		model = mergeModels(model, inheritedModel);
 	}
-	return model;
+	return dedupeCubes(model);
 }
 //#endregion
 export { extractInheritedModel as n, ancestryOf as t };

package/dist/{jar-classes-Bj15hjdr.js → jar-classes-3GVCJZT7.js}

@@ -13,6 +13,43 @@ import { n as UnsafeJarError, r as isUnsafeEntryPath } from "./jar-W2cV2ZVO.js";
 * 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) try {
+				for (const name of await source.list()) names.add(name);
+			} catch {
+				continue;
+			}
+			return [...names];
+		},
+		read: async (internalName) => {
+			for (const source of sources) try {
+				const bytes = await source.read(internalName);
+				if (bytes) return bytes;
+			} catch {
+				continue;
+			}
+			return null;
+		},
+		close: async () => {
+			for (const source of sources) try {
+				await source.close();
+			} catch {
+				continue;
+			}
+		}
+	};
+}
 /** Reads class files out of one jar, by internal name. */
 var JarClassReader = class {
 	jarPath;
@@ -72,4 +109,4 @@ var JarClassReader = class {
 	}
 };
 //#endregion
-export { JarClassReader as t };
+export { layeredClasses as n, JarClassReader as t };