@nodecraft/rendermite 1.6.0 → 1.6.2

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/{link-Bm5oQYh6.js → link-5GmBLTzk.js}

@@ -1,4 +1,4 @@
-import { t as parseClassFile } from "./classfile-CAhS5qNf.js";
+import { t as parseClassFile } from "./classfile-Bo7FUrrD.js";
 //#region src/entities/link.ts
 /**
 * Which class holds a given entity's geometry.
@@ -257,6 +257,7 @@ function buildModelNameIndex(internalNames) {
 */
 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);
@@ -309,8 +310,31 @@ async function linkEntityModel(entityId, context) {
 			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();

package/dist/merge-DeHruviG.js

@@ -0,0 +1,109 @@
+//#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
+	};
+}
+/**
+* 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.
+*/
+function dedupeCubes(model) {
+	const seen = /* @__PURE__ */ new Set();
+	const round = (value) => value.toFixed(4);
+	const walk = (part, pivot, rotation) => {
+		const at = [
+			pivot[0] + part.pivot[0],
+			pivot[1] + part.pivot[1],
+			pivot[2] + part.pivot[2]
+		];
+		const spun = [
+			rotation[0] + part.rotation[0],
+			rotation[1] + part.rotation[1],
+			rotation[2] + part.rotation[2]
+		];
+		const cubes = part.cubes.filter((cube) => {
+			const key = [
+				...at.map(round),
+				...spun.map(round),
+				...cube.origin.map(round),
+				...cube.size.map(round),
+				...cube.uv.map(round),
+				round(cube.inflate)
+			].join("|");
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		});
+		const children = part.children.map((child) => walk(child, at, spun)).filter((child) => child.cubes.length > 0 || child.children.length > 0);
+		return {
+			...part,
+			cubes,
+			children
+		};
+	};
+	return {
+		...model,
+		parts: model.parts.map((part) => walk(part, [
+			0,
+			0,
+			0
+		], [
+			0,
+			0,
+			0
+		])).filter((part) => part.cubes.length > 0 || part.children.length > 0)
+	};
+}
+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 { mergeModels as a, dedupeCubes as i, countCubes as n, slotsOf as o, cubesOf as r, buildsOwnMesh as t };

package/dist/{model-bytecode-C1nw2G8O.js → model-bytecode-BQKCLPze.js}

@@ -1,5 +1,5 @@
-import { t as parseClassFile } from "./classfile-CAhS5qNf.js";
-import { i as mergeModels, r as cubesOf, t as buildsOwnMesh } from "./merge-3HkeQ_6A.js";
+import { t as parseClassFile } from "./classfile-Bo7FUrrD.js";
+import { a as mergeModels, r as cubesOf, t as buildsOwnMesh } from "./merge-DeHruviG.js";
 //#region src/entities/model-bytecode.ts
 /**
 * Abstract interpretation of a boxy-model builder, enough to recover the geometry.
@@ -43,6 +43,28 @@ const NUMERIC = /* @__PURE__ */ new Set([
 	"B",
 	"C"
 ]);
+/**
+* Whether a conditional jump is taken, for the opcodes that compare numbers.
+*
+* The single-operand forms (`ifeq` … `ifle`) test against zero and the two-operand forms (`if_icmpeq`
+* …) against each other, so both reduce to the sign of `left - right`.
+*/
+function compare(op, left, right) {
+	const difference = left - right;
+	switch (op) {
+		case 153:
+		case 159: return difference === 0;
+		case 154:
+		case 160: return difference !== 0;
+		case 155:
+		case 161: return difference < 0;
+		case 156:
+		case 162: return difference >= 0;
+		case 157:
+		case 163: return difference > 0;
+		default: return difference <= 0;
+	}
+}
 /** Every entity sheet is a power of two, at least 16 in each direction. A texture offset rarely is. */
 function isSheetSize(width, height) {
 	const power = (value) => value >= 16 && (value & value - 1) === 0;
@@ -109,6 +131,18 @@ const TEXTURE_HEIGHT_FIELDS = /* @__PURE__ */ new Set(["texHeight", "textureHeig
 const MAX_INLINE_DEPTH = 5;
 /** Frames per method. A model spends a handful; the cap is there so a strange jar cannot spend all day. */
 const INLINE_BUDGET = 96;
+/**
+* Instructions per extraction, shared across every frame.
+*
+* A model builder is a few hundred instructions and the longest vanilla loop runs a few thousand, so
+* this is two orders of magnitude of headroom — and it is what makes following a backward goto safe: a
+* loop whose bound cannot be worked out stops here instead of spinning.
+*/
+const STEP_BUDGET = 2e5;
+/** Elements tracked per array. A table of segment sizes is a handful; nothing here needs thousands. */
+const MAX_ARRAY = 1024;
+/** Times round a loop. Vanilla's longest builds sixteen segments, so this is generous by four times. */
+const MAX_ITERATIONS = 64;
 /** How far up a hierarchy to look for an inherited method, which is as deep as a model hierarchy goes. */
 const MAX_METHOD_HOPS = 6;
 function newShared(resolve) {
@@ -120,7 +154,10 @@ function newShared(resolve) {
 		branched: false,
 		nextHandle: 1,
 		resolve,
-		budget: INLINE_BUDGET
+		budget: INLINE_BUDGET,
+		statics: /* @__PURE__ */ new Map(),
+		initialised: /* @__PURE__ */ new Set(),
+		steps: STEP_BUDGET
 	};
 }
 /** The method a call names, looked up where the JVM would look: the owner, then up its ancestors. */
@@ -143,6 +180,8 @@ var Interpreter = class Interpreter {
 	locals = /* @__PURE__ */ new Map();
 	shared;
 	depth;
+	/** How many times each backward jump has been taken, so an undecidable loop cannot spin. */
+	loops = /* @__PURE__ */ new Map();
 	/** What this frame returned, for the caller that inlined it. */
 	returned = null;
 	constructor(shared, depth = 0) {
@@ -171,6 +210,19 @@ var Interpreter = class Interpreter {
 		}
 	}
 	/**
+	* Runs a class's `<clinit>` once, so its static tables can be read.
+	*
+	* Only for model code, and only once per class per extraction: the point is a table of numbers, and
+	* anything else a static initialiser does is of no interest here.
+	*/
+	initialise(owner) {
+		if (this.shared.initialised.has(owner) || this.depth >= MAX_INLINE_DEPTH) return;
+		this.shared.initialised.add(owner);
+		const target = findMethod(this.shared.resolve, owner, "<clinit>", "()V");
+		if (!target) return;
+		new Interpreter(this.shared, this.depth + 1).run(target.code, target.classFile);
+	}
+	/**
 	* Interprets a call into the model's own code, with the arguments it was actually given.
 	*
 	* This is what makes an inherited part come out right. `CowModel` calls `super(12, 0)` and the legs
@@ -189,6 +241,10 @@ var Interpreter = class Interpreter {
 		frame.seed(receiver, descriptor, args);
 		return frame.run(target.code, target.classFile) ? frame.returned : null;
 	}
+	/** Records a note once, since every candidate method would otherwise repeat it. */
+	note(message) {
+		if (!this.shared.notes.includes(message)) this.shared.notes.push(message);
+	}
 	pop() {
 		return this.stack.pop() ?? { kind: "unknown" };
 	}
@@ -218,6 +274,11 @@ var Interpreter = class Interpreter {
 		const first = named ? 1 : 0;
 		if (target && (named || floats >= 6 && args.length >= 6 && NUMERIC.has(args[0]) && NUMERIC.has(args[5]))) {
 			const extra = args.slice(first + 6);
+			const floatAt = extra.findIndex((arg) => arg === "F" || arg === "D");
+			const deformed = taken.find((value) => value.kind === "object" && value.handle.deformation !== void 0);
+			let inflate = target.pendingInflate;
+			if (floatAt !== -1) inflate = this.number(taken[first + 6 + floatAt]);
+			else if (deformed?.kind === "object") inflate = deformed.handle.deformation ?? 0;
 			target.cubes.push({
 				origin: [
 					numbers[first],
@@ -230,7 +291,7 @@ var Interpreter = class Interpreter {
 					numbers[first + 5]
 				],
 				uv: [...target.pendingUv],
-				inflate: extra.some((arg) => NUMERIC.has(arg)) ? this.number(taken[first + 6]) : target.pendingInflate,
+				inflate,
 				mirror: target.pendingMirror || extra.includes("Z") && this.number(taken[args.length - 1]) === 1
 			});
 			this.push(returns === "V" ? null : receiver);
@@ -308,6 +369,12 @@ var Interpreter = class Interpreter {
 			});
 			return;
 		}
+		const lambda = taken.find((value) => value.kind === "lambda");
+		if (lambda?.kind === "lambda" && receiver?.kind === "object" && taken.length === 1) {
+			const applied = this.inline(lambda.owner, lambda.name, lambda.descriptor, null, [receiver]);
+			this.push(returns === "V" ? null : applied ?? receiver);
+			return;
+		}
 		if (args.length === 1 && args[0] === "Ljava/lang/String;" && returns.startsWith("L") && target) {
 			const name_ = taken[0].kind === "string" ? taken[0].value : "";
 			const found = target.children.find((child) => child.name === name_);
@@ -342,6 +409,11 @@ var Interpreter = class Interpreter {
 			this.push(returns === "V" ? null : receiver);
 			return;
 		}
+		if (args.length === 0 && target && returns === `L${owner};`) {
+			target.pendingMirror = true;
+			this.push(receiver);
+			return;
+		}
 		if (args.length === 0 && returns.startsWith("L")) {
 			if (target) {
 				target.isRoot = true;
@@ -365,6 +437,10 @@ var Interpreter = class Interpreter {
 	run(code, constants) {
 		let at = 0;
 		while (at < code.length) {
+			if (this.shared.steps-- <= 0) {
+				this.note("ran past the step budget, so the shape is only as far as it got");
+				return false;
+			}
 			const op = code[at++];
 			switch (true) {
 				case op === 1:
@@ -437,9 +513,10 @@ var Interpreter = class Interpreter {
 					this.locals.set((op - 59) % 4, this.pop());
 					break;
 				case ARRAY_LOADS.has(op): {
-					this.pop();
+					const index = this.pop();
 					const array = this.pop();
-					this.push(array.kind === "array" ? array.items[0] ?? { kind: "unknown" } : { kind: "unknown" });
+					const at = index.kind === "number" ? index.value : 0;
+					this.push(array.kind === "array" ? array.items[at] ?? { kind: "unknown" } : { kind: "unknown" });
 					break;
 				}
 				case op >= 120 && op <= 131:
@@ -459,18 +536,19 @@ var Interpreter = class Interpreter {
 					});
 					break;
 				case op === 191: return true;
-				case op === 190:
-					this.pop();
-					this.push({
+				case op === 190: {
+					const array = this.pop();
+					this.push(array.kind === "array" ? {
 						kind: "number",
-						value: 0
-					});
+						value: array.items.length
+					} : { kind: "unknown" });
 					break;
+				}
 				case ARRAY_STORES.has(op): {
 					const value = this.pop();
-					this.pop();
+					const index = this.pop();
 					const array = this.pop();
-					if (array.kind === "array") array.items.push(value);
+					if (array.kind === "array") array.items[index.kind === "number" ? index.value : array.items.length] = value;
 					break;
 				}
 				case op === 87:
@@ -525,20 +603,36 @@ var Interpreter = class Interpreter {
 					});
 					break;
 				case op >= 133 && op <= 147: break;
-				case op === 132:
+				case op === 132: {
+					const slot = code[at];
+					const step = code[at + 1] << 24 >> 24;
 					at += 2;
+					this.locals.set(slot, {
+						kind: "number",
+						value: this.number(this.locals.get(slot) ?? { kind: "unknown" }) + step
+					});
 					break;
+				}
 				case RETURNS.has(op):
 					if (op !== 177) this.returned = this.pop();
 					return true;
-				case op === 178:
+				case op === 178: {
+					const index = code[at] << 8 | code[at + 1];
 					at += 2;
-					this.push({ kind: "unknown" });
+					const reference = constants.reference(index);
+					const key = reference ? `${reference.owner}.${reference.name}` : "";
+					if (reference && !this.shared.statics.has(key)) this.initialise(reference.owner);
+					this.push(this.shared.statics.get(key) ?? { kind: "unknown" });
 					break;
-				case op === 179:
+				}
+				case op === 179: {
+					const index = code[at] << 8 | code[at + 1];
 					at += 2;
-					this.pop();
+					const value = this.pop();
+					const reference = constants.reference(index);
+					if (reference) this.shared.statics.set(`${reference.owner}.${reference.name}`, value);
 					break;
+				}
 				case op === 180: {
 					const index = code[at] << 8 | code[at + 1];
 					at += 2;
@@ -574,6 +668,7 @@ var Interpreter = class Interpreter {
 						const taken = [];
 						for (let count = 0; count < args.length; count++) taken.unshift(this.pop());
 						const objectRef = this.pop();
+						if (objectRef.kind === "object" && args.length > 0 && args.length <= 3 && args.every((arg) => arg === "F")) objectRef.handle.deformation = Math.max(...taken.map((value) => this.number(value)));
 						if (objectRef.kind === "object" && args.length >= 2 && args.at(-1) === "I" && args.at(-2) === "I") {
 							objectRef.handle.pendingUv = [this.number(taken[args.length - 2]), this.number(taken[args.length - 1])];
 							objectRef.handle.uvFromConstructor = true;
@@ -591,22 +686,18 @@ var Interpreter = class Interpreter {
 						handle: this.handle()
 					});
 					break;
-				case op === 188:
-					at += 1;
-					this.pop();
+				case op === 188 || op === 189: {
+					at += op === 188 ? 1 : 2;
+					const length = this.pop();
+					const size = length.kind === "number" ? Math.min(Math.max(length.value, 0), MAX_ARRAY) : 0;
 					this.push({
 						kind: "array",
-						items: []
-					});
-					break;
-				case op === 189:
-					at += 2;
-					this.pop();
-					this.push({
-						kind: "array",
-						items: []
+						items: Array.from({ length: size }, () => {
+							return { kind: "unknown" };
+						})
 					});
 					break;
+				}
 				case op === 192:
 					at += 2;
 					break;
@@ -619,14 +710,28 @@ var Interpreter = class Interpreter {
 						returns: "V"
 					};
 					for (let count = 0; count < args.length; count++) this.pop();
-					this.push(returns === "V" ? null : { kind: "unknown" });
+					const target = constants.lambdaTarget(index);
+					this.push(returns === "V" ? null : target ? {
+						kind: "lambda",
+						...target
+					} : { kind: "unknown" });
 					break;
 				}
 				case op >= 153 && op <= 166: {
-					const comparisons = op >= 159 ? 2 : 1;
-					for (let count = 0; count < comparisons; count++) this.pop();
+					const twoOperands = op >= 159;
+					const right = this.pop();
+					const left = twoOperands ? this.pop() : {
+						kind: "number",
+						value: 0
+					};
+					const offset = (code[at] << 8 | code[at + 1]) << 16 >> 16;
 					at += 2;
-					this.shared.branched = true;
+					const decided = left.kind === "number" && right.kind === "number" && op <= 164 ? compare(op, twoOperands ? left.value : right.value, twoOperands ? right.value : 0) : null;
+					if (decided === null) {
+						this.shared.branched = true;
+						break;
+					}
+					if (decided) at += offset - 3;
 					break;
 				}
 				case op === 198 || op === 199:
@@ -636,12 +741,19 @@ var Interpreter = class Interpreter {
 					break;
 				case op === 167: {
 					const offset = (code[at] << 8 | code[at + 1]) << 16 >> 16;
-					if (offset <= 0) {
-						this.shared.notes.push("backward goto: the builder loops, so its geometry is not recoverable");
-						return false;
+					at += 2;
+					if (offset > 0) {
+						at += offset - 3;
+						break;
 					}
-					at += offset - 1;
-					this.shared.branched = true;
+					const site = at - 3;
+					const round = (this.loops.get(site) ?? 0) + 1;
+					this.loops.set(site, round);
+					if (round > MAX_ITERATIONS) {
+						this.note(`a loop at ${site} went round more than ${MAX_ITERATIONS} times, so the shape is only as far as it got`);
+						break;
+					}
+					at += offset - 3;
 					break;
 				}
 				case op >= 148 && op <= 152:

package/dist/{model-code-BKMEMXxF.js → model-code-1Vuk-zj_.js}

@@ -1,4 +1,4 @@
-import { t as parseClassFile } from "./classfile-CAhS5qNf.js";
+import { t as parseClassFile } from "./classfile-Bo7FUrrD.js";
 //#region src/entities/model-code.ts
 /**
 * Which classes in a jar count as model code, and their parsed form.

package/dist/{model-code-B7jSFQqd.d.ts → model-code-BY44ao27.d.ts}

@@ -1,4 +1,4 @@
-import { t as ClassFile } from "./classfile-BwaQjnUM.js";
+import { t as ClassFile } from "./classfile-BdLIk4Pe.js";
 //#region src/entities/model-code.d.ts
 interface ModelCode {
   /** The parsed class, when it is model code a call may be followed into. */

package/dist/{pipeline-BUIMzMzg.js → pipeline-7rvL6vx1.js}

@@ -11,7 +11,7 @@ import { n as LayeredResourceManager, t as FolderResourceManager } from "./manag
 import { n as TextureLoader } from "./loader-C18GpurU.js";
 import { t as encodeAnimatedIcon } from "./encode-LR9wxigC.js";
 import { a as builtinDynamicResources } from "./generators-BCZVlWig.js";
-import { a as spawnEggTints, i as renderEntityFallback, n as dyedVariantTint, r as renderDyedVariantFallback, t as dyeVariantName } from "./entity-fallback-Bth0fa7m.js";
+import { a as spawnEggTints, i as renderEntityFallback, n as dyedVariantTint, r as renderDyedVariantFallback, t as dyeVariantName } from "./entity-fallback-BcJWh91-.js";
 import { t as legacyTintsForChain } from "./legacy-tints-l-541wgI.js";
 import { n as defaultBlockStateModel, t as blockStateTransform } from "./blockstate-DVb8Mhxc.js";
 import path from "node:path";

package/dist/render/entity-fallback.js

@@ -1,2 +1,2 @@
-import { a as spawnEggTints, i as renderEntityFallback, n as dyedVariantTint, r as renderDyedVariantFallback, t as dyeVariantName } from "../entity-fallback-Bth0fa7m.js";
+import { a as spawnEggTints, i as renderEntityFallback, n as dyedVariantTint, r as renderDyedVariantFallback, t as dyeVariantName } from "../entity-fallback-BcJWh91-.js";
 export { dyeVariantName, dyedVariantTint, renderDyedVariantFallback, renderEntityFallback, spawnEggTints };

package/dist/render/pipeline.js

@@ -1,2 +1,2 @@
-import { t as ItemPipeline } from "../pipeline-BUIMzMzg.js";
+import { t as ItemPipeline } from "../pipeline-7rvL6vx1.js";
 export { ItemPipeline };

package/dist/resources/entity-textures.d.ts

@@ -12,6 +12,18 @@ declare const HEAD_LAYOUTS: Record<string, string>;
  * 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.
+ */
+declare const OVERLAY_DIRECTORIES: Set<string>;
+/** Whether a texture is filed inside one of those, whatever the file itself is called. */
+declare function isOverlayPath(path: string): boolean;
 declare function findMobTexture(resources: ResourceManager, namespace: string, mob: string): Promise<ResourceLocator | null>;
 /**
  * Find the mod's own chest sheet for a chest-like item by token overlap over
@@ -48,4 +60,4 @@ declare function findFluidStill(resources: ResourceManager, namespace: string, b
  */
 declare function findFluidSibling(resources: ResourceManager, still: ResourceLocator, suffixes: string[]): Promise<ResourceLocator | null>;
 //#endregion
-export { DYE_COLORS, HEAD_LAYOUTS, coversSheet, findBedTexture, findChestTexture, findEntityTexture, findFluidSibling, findFluidStill, findMobTexture, tokens };
+export { DYE_COLORS, HEAD_LAYOUTS, OVERLAY_DIRECTORIES, coversSheet, findBedTexture, findChestTexture, findEntityTexture, findFluidSibling, findFluidStill, findMobTexture, isOverlayPath, tokens };

package/dist/resources/entity-textures.js

@@ -1,2 +1,2 @@
-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, u as tokens } from "../entity-textures-DFRIVdF1.js";
-export { DYE_COLORS, HEAD_LAYOUTS, coversSheet, findBedTexture, findChestTexture, findEntityTexture, findFluidSibling, findFluidStill, findMobTexture, tokens };
+import { a as findBedTexture, c as findFluidSibling, d as isOverlayPath, f as tokens, i as coversSheet, l as findFluidStill, n as HEAD_LAYOUTS, o as findChestTexture, r as OVERLAY_DIRECTORIES, s as findEntityTexture, t as DYE_COLORS, u as findMobTexture } from "../entity-textures-4XXT8jVI.js";
+export { DYE_COLORS, HEAD_LAYOUTS, OVERLAY_DIRECTORIES, coversSheet, findBedTexture, findChestTexture, findEntityTexture, findFluidSibling, findFluidStill, findMobTexture, isOverlayPath, tokens };

package/dist/{run-BQJkqc5f.js → run-BXAqZ5qY.js}

@@ -6,7 +6,7 @@ import { r as encodeRasterAsset } from "./encode-LR9wxigC.js";
 import { t as classifyItemStyle } from "./item-styles-DjYRdyHi.js";
 import { t as minifyStylesheet } from "./minify-bjMRmr5J.js";
 import { t as generateStylesheet } from "./stylesheet-CovT3B2S.js";
-import { t as ItemPipeline } from "./pipeline-BUIMzMzg.js";
+import { t as ItemPipeline } from "./pipeline-7rvL6vx1.js";
 import { t as describeResources } from "./descriptor-JyXhfd-c.js";
 import { t as WorkerRenderPool } from "./pool-CKGp1qup.js";
 import path from "node:path";

package/dist/run.js

@@ -1,3 +1,3 @@
 import { o as evaluateItemModel } from "./definition-ColsvWrH.js";
-import { t as run } from "./run-BQJkqc5f.js";
+import { t as run } from "./run-BXAqZ5qY.js";
 export { evaluateItemModel, run };

package/dist/workers/render-worker.js

@@ -1,4 +1,4 @@
-import { t as ItemPipeline } from "../pipeline-BUIMzMzg.js";
+import { t as ItemPipeline } from "../pipeline-7rvL6vx1.js";
 import { n as restoreResources } from "../descriptor-JyXhfd-c.js";
 import sharp from "sharp";
 import { parentPort, workerData } from "node:worker_threads";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nodecraft/rendermite",
-	"version": "1.6.0",
+	"version": "1.6.2",
 	"description": "Minecraft item icon renderer: renders inventory-identical item icons from vanilla and modded assets across game versions, outputting optimized PNG/WebP/AVIF plus CSS and a JSON item library.",
 	"type": "module",
 	"license": "MIT",