@nodecraft/rendermite 1.6.8 → 1.7.0

package/assets/builtin/mobheads/models/item/base/head_64_64_hat.json

@@ -0,0 +1,31 @@
+{
+	"__comment": "A 64x64 head that also draws the skin's own hat layer, for the player head. Same box as head_64_64, but the outer element is bound to the head sheet at the hat unwrap (texOffs 32,0) rather than to an empty sprite. On a default skin that region is fully transparent, so this draws exactly what head_64_64 did; on a real player's skin it is the hat, which is the half of a head that a consumer swapping in a fetched skin would otherwise lose. East/west and up/down are swapped against the game's own box unwrap for the same reason head_64_64 swaps them: the entity renderer draws through a scale(-1, -1, 1) that a block model has no equivalent of.",
+	"parent": "mobheads:item/base/head_display",
+	"texture_size": [64, 64],
+	"elements": [
+		{
+			"from": [4, 4, 4],
+			"to": [12, 12, 12],
+			"faces": {
+				"north": {"uv": [2, 2, 4, 4], "texture": "#texture"},
+				"east": {"uv": [0, 2, 2, 4], "texture": "#texture"},
+				"south": {"uv": [6, 2, 8, 4], "texture": "#texture"},
+				"west": {"uv": [4, 2, 6, 4], "texture": "#texture"},
+				"up": {"uv": [2, 0, 4, 2], "rotation": 180, "texture": "#texture"},
+				"down": {"uv": [4, 0, 6, 2], "texture": "#texture"}
+			}
+		},
+		{
+			"from": [3.5, 3.5, 3.5],
+			"to": [12.5, 12.5, 12.5],
+			"faces": {
+				"north": {"uv": [10, 2, 12, 4], "texture": "#texture"},
+				"east": {"uv": [8, 2, 10, 4], "texture": "#texture"},
+				"south": {"uv": [14, 2, 16, 4], "texture": "#texture"},
+				"west": {"uv": [12, 2, 14, 4], "texture": "#texture"},
+				"up": {"uv": [10, 0, 12, 2], "rotation": 180, "texture": "#texture"},
+				"down": {"uv": [12, 0, 14, 2], "texture": "#texture"}
+			}
+		}
+	]
+}

package/assets/builtin/mobheads/models/item/player_skin.json

@@ -0,0 +1,7 @@
+{
+  "__comment": "The player head as a block pack wants it: the same head as mobheads:item/player, plus the skin's own hat layer. Kept apart from the item model because the icon renderer samples a hair outside a face's rect at a silhouette edge, and the extra box — transparent on a default skin — still fringes the icon with a few pixels of whatever sits next to the hat unwrap. A block pack is drawn by a GPU from the geometry rather than by that rasterizer, so it takes the hat and the icon does not.",
+  "parent": "mobheads:item/base/head_64_64_hat",
+  "textures": {
+    "texture": "minecraft:entity/player/wide/steve"
+  }
+}

package/assets/builtin/renderchest/models/block/wall_sign.json

@@ -1,11 +1,11 @@
 {
-	"__comment": "Wall sign: the same board as the standing sign with no post, sitting against the block behind it. Authored facing north, so the blockstate's facing rotates it from there.",
+	"__comment": "Wall sign: the same board as the standing sign with no post, sitting against the block behind it. Authored facing north, so the blockstate's facing rotates it from there. The block it hangs on is the one it faces AWAY from, so the board is at the far z: authored north, it sits against the south neighbour. Putting it at z 0 instead drew every wall sign in a world a full block clear of its wall.",
 	"texture_size": [64, 32],
 	"elements": [
 		{
 			"name": "board",
-			"from": [0, 4.5, 0],
-			"to": [16, 12.5, 1.5],
+			"from": [0, 4.5, 14.5],
+			"to": [16, 12.5, 16],
 			"faces": {
 				"north": { "uv": [0.5, 1, 6.5, 7], "texture": "#texture" },
 				"east": { "uv": [6.5, 1, 7, 7], "texture": "#texture" },

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

@@ -288,7 +288,7 @@ async function skullGeometry(blockId, context) {
 			} : { kind: "rotation16" }
 		};
 	};
-	const parts = mob.split("_");
+	const parts = (mob === "player" ? "player_skin" : mob).split("_");
 	for (let keep = parts.length; keep >= 1 && keep >= parts.length - 2; keep--) {
 		const model = `mobheads:item/${parts.slice(0, keep).join("_")}`;
 		const resolved = await context.models.load(model).catch(() => null);

package/dist/blocks/block-entities.js

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

package/dist/blocks/cli.js

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

package/dist/blocks/ender-storage.d.ts

@@ -1,5 +1,5 @@
 import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { f as BlockPackModel } from "../pack-format-QcVFxG_b.js";
+import { f as BlockPackModel } from "../pack-format-D5IgQjcD.js";
 //#region src/blocks/ender-storage.d.ts
 /**
  * Ender Storage feeds this OBJ through CodeChickenLib's `swapYZ`, translates it almost exactly onto

package/dist/blocks/entities.d.ts

@@ -1,6 +1,6 @@
 import { a as ResourceManager } from "../manager-exOIcdyx.js";
 import { i as TextureLoader } from "../loader-DUlx29PC.js";
-import { x as EntityPackEntry } from "../pack-format-QcVFxG_b.js";
+import { S as EntityPackEntry } from "../pack-format-D5IgQjcD.js";
 //#region src/blocks/entities.d.ts
 interface EntityPackResult {
   entities: Record<string, EntityPackEntry>;

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

@@ -1,6 +1,8 @@
 import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { S as EntityPackModel } from "../pack-format-QcVFxG_b.js";
+import { C as EntityPackModel, T as EquipmentPack } from "../pack-format-D5IgQjcD.js";
 import { t as ClassSource } from "../jar-classes-CSRrPAUy.js";
+import { t as Mappings } from "../mappings-DxX4KoZl.js";
+import { t as ModelCode } from "../model-code-BY44ao27.js";
 //#region src/blocks/entity-models.d.ts
 interface EntityGeometryResult {
   /** Model id (the class it came from) → geometry. */
@@ -9,6 +11,8 @@ interface EntityGeometryResult {
   modelOf: Map<string, string>;
   /** Entity sheets the models address, to be stitched into the pack's own atlas. */
   spriteIds: Set<string>;
+  /** Worn armour, where the version's classes described any. */
+  equipment: EquipmentPack | null;
   failures: Array<{
     id: string;
     reason: string;
@@ -41,5 +45,23 @@ interface CollectEntityGeometryOptions {
  * per entity.
  */
 declare function collectEntityGeometry(options: CollectEntityGeometryOptions): Promise<EntityGeometryResult>;
+/**
+ * Reads the authored armour-trim atlas and names every generated worn sheet.
+ *
+ * The texture loader already resolves `paletted_permutations`; this only records the generated
+ * sprite ids so the normal entity-atlas stitcher asks it for those pixels. Copies are visited from
+ * lowest to highest precedence, matching atlas source resolution when packs extend the vanilla file.
+ */
+declare function collectArmourTrims(resources: ResourceManager, spriteIds: Set<string>): Promise<EquipmentPack['trims']>;
+/**
+ * Worn armour for the pack: one humanoid mesh, the sheets each material is drawn with, and which
+ * item is which.
+ *
+ * Materials are discovered from the sheets the version actually ships rather than listed, so a
+ * version that adds one — copper, in the 26 line — needs no edit here. The item ids are the one part
+ * the assets cannot answer, since nothing in them maps `iron_helmet` to `iron`: they follow the
+ * game's own naming, and each is confirmed against a real item model before being claimed.
+ */
+declare function collectEquipment(names: readonly string[], mappings: Mappings, read: (internal: string) => Promise<Uint8Array | null>, code: ModelCode, resources: ResourceManager | undefined, models: Record<string, EntityPackModel>, spriteIds: Set<string>): Promise<EquipmentPack | null>;
 //#endregion
-export { CollectEntityGeometryOptions, EntityGeometryResult, collectEntityGeometry };
+export { CollectEntityGeometryOptions, EntityGeometryResult, collectArmourTrims, collectEntityGeometry, collectEquipment };

package/dist/blocks/entity-models.js

@@ -1,2 +1,2 @@
-import { t as collectEntityGeometry } from "../entity-models-DSZHxCx1.js";
-export { collectEntityGeometry };
+import { n as collectEntityGeometry, r as collectEquipment, t as collectArmourTrims } from "../entity-models-DUKiHpn1.js";
+export { collectArmourTrims, collectEntityGeometry, collectEquipment };

package/dist/blocks/export.js

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

package/dist/blocks/geo-blocks.d.ts

@@ -1,5 +1,5 @@
 import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { f as BlockPackModel } from "../pack-format-QcVFxG_b.js";
+import { f as BlockPackModel } from "../pack-format-D5IgQjcD.js";
 //#region src/blocks/geo-blocks.d.ts
 interface GeoBlockOverride {
   model: BlockPackModel;

package/dist/blocks/item-sprites.d.ts

@@ -1,7 +1,7 @@
 import { a as ResourceManager } from "../manager-exOIcdyx.js";
 import { i as TextureLoader } from "../loader-DUlx29PC.js";
 import { t as ModelLoader } from "../loader-DSir1-P0.js";
-import { w as ItemPackEntry } from "../pack-format-QcVFxG_b.js";
+import { D as ItemPackEntry } from "../pack-format-D5IgQjcD.js";
 //#region src/blocks/item-sprites.d.ts
 interface ItemSpriteFailure {
   id: string;

package/dist/blocks/pack-format.d.ts

@@ -1,2 +1,2 @@
-import { C as EntityPackPart, S as EntityPackModel, T as ItemPackLayer, _ as BlockPackTintsFile, a as BlockPackBlockStatesFile, b as EntityPackCubeFace, c as BlockPackEntityModelsFile, d as BlockPackMetaFile, f as BlockPackModel, g as BlockPackSpriteFrame, h as BlockPackSprite, i as BlockPackBlockState, l as BlockPackFace, m as BlockPackRenderLayer, n as BlockPackAtlasPage, o as BlockPackElement, p as BlockPackModelsFile, r as BlockPackBiomesFile, s as BlockPackEntitiesFile, t as BlockPackAtlasFile, u as BlockPackItemsFile, v as BlockPackVariant, w as ItemPackEntry, x as EntityPackEntry, y as EntityPackCube } from "../pack-format-QcVFxG_b.js";
-export { BlockPackAtlasFile, BlockPackAtlasPage, BlockPackBiomesFile, BlockPackBlockState, BlockPackBlockStatesFile, BlockPackElement, BlockPackEntitiesFile, BlockPackEntityModelsFile, BlockPackFace, BlockPackItemsFile, BlockPackMetaFile, BlockPackModel, BlockPackModelsFile, BlockPackRenderLayer, BlockPackSprite, BlockPackSpriteFrame, BlockPackTintsFile, BlockPackVariant, EntityPackCube, EntityPackCubeFace, EntityPackEntry, EntityPackModel, EntityPackPart, ItemPackEntry, ItemPackLayer };
+import { C as EntityPackModel, D as ItemPackEntry, E as EquipmentSlot, O as ItemPackLayer, S as EntityPackEntry, T as EquipmentPack, _ as BlockPackTintsFile, a as BlockPackBlockStatesFile, b as EntityPackCube, c as BlockPackEntityModelsFile, d as BlockPackMetaFile, f as BlockPackModel, g as BlockPackSpriteFrame, h as BlockPackSprite, i as BlockPackBlockState, l as BlockPackFace, m as BlockPackRenderLayer, n as BlockPackAtlasPage, o as BlockPackElement, p as BlockPackModelsFile, r as BlockPackBiomesFile, s as BlockPackEntitiesFile, t as BlockPackAtlasFile, u as BlockPackItemsFile, v as BlockPackVariant, w as EntityPackPart, x as EntityPackCubeFace, y as EQUIPMENT_SLOTS } from "../pack-format-D5IgQjcD.js";
+export { BlockPackAtlasFile, BlockPackAtlasPage, BlockPackBiomesFile, BlockPackBlockState, BlockPackBlockStatesFile, BlockPackElement, BlockPackEntitiesFile, BlockPackEntityModelsFile, BlockPackFace, BlockPackItemsFile, BlockPackMetaFile, BlockPackModel, BlockPackModelsFile, BlockPackRenderLayer, BlockPackSprite, BlockPackSpriteFrame, BlockPackTintsFile, BlockPackVariant, EQUIPMENT_SLOTS, EntityPackCube, EntityPackCubeFace, EntityPackEntry, EntityPackModel, EntityPackPart, EquipmentPack, EquipmentSlot, ItemPackEntry, ItemPackLayer };

package/dist/blocks/pack-format.js

@@ -1 +1,2 @@
-export {};
+import { t as EQUIPMENT_SLOTS } from "../pack-format-BP5dJMYY.js";
+export { EQUIPMENT_SLOTS };

package/dist/blocks/sprite-sheet.d.ts

@@ -1,6 +1,6 @@
 import { i as TextureLoader, r as Texture } from "../loader-DUlx29PC.js";
 import { i as PackedPage } from "../atlas-pack-D8745_wo.js";
-import { h as BlockPackSprite, m as BlockPackRenderLayer } from "../pack-format-QcVFxG_b.js";
+import { h as BlockPackSprite, m as BlockPackRenderLayer } from "../pack-format-D5IgQjcD.js";
 //#region src/blocks/sprite-sheet.d.ts
 /**
  * Vanilla's own id for the missing-texture sprite. A face whose texture does

package/dist/{cli-DLQHtzP3.js → cli-DFIB9i9c.js}

@@ -1,6 +1,6 @@
 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-BZLBF1hS.js";
+import { t as exportBlockPack } from "./export-DlXOK8_D.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";

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-DLQHtzP3.js";
-import { t as run } from "./run-CGcHj_qq.js";
+import { t as runBlocksCli } from "./cli-DFIB9i9c.js";
+import { t as run } from "./run-CQXJCo8u.js";
 import path from "node:path";
 import os from "node:os";
 import { parseArgs } from "node:util";

package/dist/dynamic/generators.js

@@ -1,2 +1,2 @@
-import { a as builtinDynamicResources, i as TRIM_MATERIALS, n as POTTERY_SHERDS, r as TRIM_DARKER_MATERIALS, t as ARMOR_ITEM_TYPES } from "../generators-BCZVlWig.js";
+import { a as builtinDynamicResources, i as TRIM_MATERIALS, n as POTTERY_SHERDS, r as TRIM_DARKER_MATERIALS, t as ARMOR_ITEM_TYPES } from "../generators-D6giKoab.js";
 export { ARMOR_ITEM_TYPES, POTTERY_SHERDS, TRIM_DARKER_MATERIALS, TRIM_MATERIALS, builtinDynamicResources };

package/dist/entities/inherit.js

@@ -1,2 +1,2 @@
-import { n as extractInheritedModel, t as ancestryOf } from "../inherit-C5Ifg3SM.js";
+import { n as extractInheritedModel, t as ancestryOf } from "../inherit-BYLi3Q28.js";
 export { ancestryOf, extractInheritedModel };

package/dist/entities/link.d.ts

@@ -1,5 +1,5 @@
-import { t as ClassFile } from "../classfile-BdLIk4Pe.js";
 import { t as Mappings } from "../mappings-DxX4KoZl.js";
+import { t as ClassFile } from "../classfile-BdLIk4Pe.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

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

@@ -25,7 +25,22 @@ interface Following {
    * Defaults to true, which is right when the caller has no way to tell the two apart.
    */
   isModelCode?: boolean;
+  /**
+   * Which of the class's methods may build the model. Defaults to everything but the armour meshes,
+   * which build the armour *worn on* this model rather than the model — see `ARMOUR_MESH`.
+   *
+   * `extractArmourMesh` passes the opposite, since that is exactly what it is after.
+   */
+  methods?: (name: string) => boolean;
 }
+/**
+ * The armour a humanoid wears, as its own mesh. Empty where the class builds none.
+ *
+ * The baby form is skipped rather than competing: it has more boxes than the adult's — a separate
+ * head and body where the adult reuses the humanoid's — so the fullest-mesh rule would always pick
+ * it, and every suit of armour in the world would come out child-sized.
+ */
+declare function extractArmourMesh(bytes: Uint8Array, following: Following): ExtractedModel;
 declare function extractModel(bytes: Uint8Array, following?: Following): ExtractedModel;
 //#endregion
-export { Following, extractModel };
+export { Following, extractArmourMesh, extractModel };

package/dist/entities/model-bytecode.js

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

package/dist/entity-models-DUKiHpn1.js

@@ -0,0 +1,406 @@
+import { n as ResourceLocator } from "./locator-COMEtEn9.js";
+import { t as findGeoForEntity } from "./entity-geo-DbTtMlPL.js";
+import { t as EQUIPMENT_SLOTS } from "./pack-format-BP5dJMYY.js";
+import { n as extractModel, t as extractArmourMesh } from "./model-bytecode-B43uSqet.js";
+import { n as extractInheritedModel, t as ancestryOf } from "./inherit-BYLi3Q28.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-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
+* 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,
+			equipment: null,
+			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 guessed = link?.route === "vanilla-name";
+		const found = link && !guessed ? {
+			id: link.className,
+			model: await geometryOf(link.obfuscated)
+		} : 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] = {
+			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,
+		equipment: await collectEquipment(names, mappings, async (internal) => await classes.read(internal), code, options.resources, models, spriteIds),
+		failures
+	};
+}
+/**
+* How much each armour layer grows the wearer's boxes by, in pixels.
+*
+* Not recovered from the code: the game passes these into the mesh builder from its renderers, so
+* following them means interpreting a renderer, which the extractor deliberately refuses to do. They
+* have been 1.0 and 0.5 since armour got its second layer, and getting them wrong only makes the two
+* layers fight rather than losing the shape.
+*/
+const ARMOUR_INFLATE = {
+	outer: 1,
+	inner: .5
+};
+/** Which parts a slot lights up, and which layer it is drawn on. */
+const ARMOUR_SLOTS = {
+	head: {
+		parts: ["head", "hat"],
+		layer: "outer"
+	},
+	chest: {
+		parts: [
+			"body",
+			"right_arm",
+			"left_arm"
+		],
+		layer: "outer"
+	},
+	legs: {
+		parts: [
+			"body",
+			"right_leg",
+			"left_leg"
+		],
+		layer: "inner"
+	},
+	feet: {
+		parts: ["right_leg", "left_leg"],
+		layer: "outer"
+	}
+};
+/**
+* Where each layer's sheets live, across the two layouts the game has used.
+*
+* 1.21.2 moved armour under `entity/equipment/` and dropped the `_layer_N` suffix for a folder per
+* layer. Both are matched rather than switched on a version, so a resource pack or a mod following
+* either convention is found the same way.
+*/
+const ARMOUR_SHEETS = [
+	{
+		layer: "outer",
+		prefix: "entity/equipment/humanoid/",
+		suffix: ""
+	},
+	{
+		layer: "inner",
+		prefix: "entity/equipment/humanoid_leggings/",
+		suffix: ""
+	},
+	{
+		layer: "outer",
+		prefix: "models/armor/",
+		suffix: "_layer_1"
+	},
+	{
+		layer: "inner",
+		prefix: "models/armor/",
+		suffix: "_layer_2"
+	}
+];
+/** The item name a material takes, where it is not simply the material's own. */
+const ARMOUR_ITEM_PREFIX = {
+	gold: "golden",
+	turtle_scute: "turtle"
+};
+/** Suffix per slot, as every vanilla armour item is named. */
+const ARMOUR_ITEM_PIECE = {
+	head: "helmet",
+	chest: "chestplate",
+	legs: "leggings",
+	feet: "boots"
+};
+/** The layer and world pattern id named by one of the paths in the armour-trim atlas. */
+function trimSheet(locator) {
+	const name = locator.path.split("/").at(-1)?.replace(/\.png$/, "");
+	if (!name) return null;
+	if (locator.path.includes("/humanoid_leggings/")) return {
+		layer: "inner",
+		pattern: new ResourceLocator(locator.namespace, name).toString()
+	};
+	if (locator.path.includes("/humanoid/")) return {
+		layer: "outer",
+		pattern: new ResourceLocator(locator.namespace, name).toString()
+	};
+	if (locator.path.includes("trims/models/armor/")) {
+		const leggings = name.endsWith("_leggings");
+		const pattern = leggings ? name.slice(0, -9) : name;
+		return {
+			layer: leggings ? "inner" : "outer",
+			pattern: new ResourceLocator(locator.namespace, pattern).toString()
+		};
+	}
+	return null;
+}
+/** The registry id represented by a palette or pattern texture. */
+function trimId(locator) {
+	const name = locator.path.split("/").at(-1)?.replace(/\.png$/, "");
+	return name ? new ResourceLocator(locator.namespace, name).toString() : null;
+}
+/**
+* Reads the authored armour-trim atlas and names every generated worn sheet.
+*
+* The texture loader already resolves `paletted_permutations`; this only records the generated
+* sprite ids so the normal entity-atlas stitcher asks it for those pixels. Copies are visited from
+* lowest to highest precedence, matching atlas source resolution when packs extend the vanilla file.
+*/
+async function collectArmourTrims(resources, spriteIds) {
+	const patterns = {};
+	const darker = {};
+	for (const namespace of await resources.listNamespaces()) {
+		const atlas = new ResourceLocator(namespace, "armor_trims");
+		const copies = await resources.getAllResources("atlas", atlas);
+		for (const raw of copies.toReversed()) {
+			let sources;
+			try {
+				sources = JSON.parse(raw.toString("utf8")).sources ?? [];
+			} catch {
+				continue;
+			}
+			for (const source of sources) {
+				if (String(source.type ?? "").replace(/^minecraft:/, "") !== "paletted_permutations" || !Array.isArray(source.textures) || !source.permutations) continue;
+				const separator = source.separator ?? "_";
+				for (const texture of source.textures) {
+					const base = ResourceLocator.tryParse(texture.replace(/\.png$/, ""));
+					if (!base) continue;
+					const sheet = trimSheet(base);
+					if (!sheet) continue;
+					const { layer, pattern } = sheet;
+					for (const [permutation, paletteName] of Object.entries(source.permutations)) {
+						const palette = ResourceLocator.tryParse(paletteName.replace(/\.png$/, ""));
+						const material = palette && trimId(palette);
+						if (!material) continue;
+						const sprite = new ResourceLocator(base.namespace, `${base.path}${separator}${permutation}`).toString();
+						patterns[pattern] ??= {};
+						patterns[pattern][material] = {
+							...patterns[pattern][material],
+							[layer]: sprite
+						};
+						spriteIds.add(sprite);
+						if (material.endsWith("_darker")) {
+							const plain = material.slice(0, -7);
+							darker[plain] = material;
+						}
+					}
+				}
+			}
+		}
+	}
+	return {
+		patterns,
+		darker
+	};
+}
+/**
+* The class holding the humanoid armour shape, across the three places the game has kept it.
+*
+* A dedicated `HumanoidArmorModel` is armour throughout, so the whole class is read. From the 26 line
+* it folded into `HumanoidModel` as a set of `create*ArmorMesh` factories beside the humanoid's own,
+* which is what `extractArmourMesh` picks out. Failing both, the humanoid itself is the right shape —
+* armour has never been anything but the wearer, grown.
+*/
+async function armourGeometry(names, mappings, read, code) {
+	const find = (simple) => names.find((name) => (mappings.originalOf.get(name) ?? name).endsWith(`/${simple}`) || (mappings.originalOf.get(name) ?? name).endsWith(`.${simple}`));
+	for (const route of [
+		{
+			simple: "HumanoidArmorModel",
+			armourOnly: false
+		},
+		{
+			simple: "HumanoidModel",
+			armourOnly: true
+		},
+		{
+			simple: "HumanoidModel",
+			armourOnly: false
+		},
+		{
+			simple: "BipedModel",
+			armourOnly: false
+		}
+	]) {
+		const internal = find(route.simple);
+		const bytes = internal ? await read(internal) : null;
+		if (!internal || !bytes) continue;
+		const { ancestors } = await ancestryOf(internal, read);
+		const resolve = (name) => ancestors.get(name) ?? code.resolve(name);
+		const model = route.armourOnly ? extractArmourMesh(bytes, {
+			resolve,
+			isModelCode: true
+		}) : extractModel(bytes, {
+			resolve,
+			isModelCode: true
+		});
+		if (model.parts.reduce((sum, part) => sum + countCubes(part), 0) > 0) return {
+			className: mappings.originalOf.get(internal) ?? internal,
+			model
+		};
+	}
+	return null;
+}
+/**
+* Worn armour for the pack: one humanoid mesh, the sheets each material is drawn with, and which
+* item is which.
+*
+* Materials are discovered from the sheets the version actually ships rather than listed, so a
+* version that adds one — copper, in the 26 line — needs no edit here. The item ids are the one part
+* the assets cannot answer, since nothing in them maps `iron_helmet` to `iron`: they follow the
+* game's own naming, and each is confirmed against a real item model before being claimed.
+*/
+async function collectEquipment(names, mappings, read, code, resources, models, spriteIds) {
+	if (!resources) return null;
+	const found = await armourGeometry(names, mappings, read, code);
+	if (!found) return null;
+	const materials = {};
+	const dyeable = [];
+	const textures = await resources.listResources("texture", "minecraft");
+	for (const { layer, prefix, suffix } of ARMOUR_SHEETS) for (const locator of textures) {
+		if (!locator.path.startsWith(prefix)) continue;
+		const name = locator.path.slice(prefix.length);
+		const overlay = name.endsWith("_overlay");
+		const bare = overlay ? name.slice(0, -8) : name;
+		if (!bare.endsWith(suffix)) continue;
+		const material = bare.slice(0, bare.length - suffix.length);
+		if (material.length === 0 || material.includes("/")) continue;
+		const id = `minecraft:${material}`;
+		if (overlay) {
+			if (!dyeable.includes(id)) dyeable.push(id);
+			continue;
+		}
+		materials[id] = {
+			...materials[id],
+			[layer]: locator.toString()
+		};
+		spriteIds.add(locator.toString());
+	}
+	if (Object.keys(materials).length === 0) return null;
+	const items = {};
+	for (const material of Object.keys(materials)) {
+		const bare = material.slice(10);
+		const prefix = ARMOUR_ITEM_PREFIX[bare] ?? bare;
+		for (const slot of EQUIPMENT_SLOTS) {
+			const id = `minecraft:${prefix}_${ARMOUR_ITEM_PIECE[slot]}`;
+			if (await resources.hasResource("model", new ResourceLocator("minecraft", `item/${prefix}_${ARMOUR_ITEM_PIECE[slot]}`))) items[id] = {
+				material,
+				slot
+			};
+		}
+	}
+	const trims = await collectArmourTrims(resources, spriteIds);
+	const modelKey = `${found.className}#armor`;
+	models[modelKey] = {
+		textureSize: [...found.model.textureSize],
+		parts: found.model.parts.map((part) => toPackPart(part)),
+		...found.model.notes.length > 0 && { notes: [...found.model.notes] }
+	};
+	return {
+		model: modelKey,
+		inflate: { ...ARMOUR_INFLATE },
+		slots: Object.fromEntries(EQUIPMENT_SLOTS.map((slot) => [slot, [...ARMOUR_SLOTS[slot].parts]])),
+		layerOf: Object.fromEntries(EQUIPMENT_SLOTS.map((slot) => [slot, ARMOUR_SLOTS[slot].layer])),
+		materials,
+		items,
+		dyeable,
+		trims
+	};
+}
+//#endregion
+export { collectEntityGeometry as n, collectEquipment as r, collectArmourTrims as t };

package/dist/{export-BZLBF1hS.js → export-DlXOK8_D.js}

@@ -1,11 +1,11 @@
 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-XAynAVUE.js";
+import { n as blockEntityGeometry, r as synthesizeVariants, t as INVISIBLE_BLOCKS } from "./block-entities-CPQeb5dV.js";
 import { a as parseBlockState, n as collectModels } from "./blockstate-eval-CV_LwUwj.js";
 import { a as salvageJson, i as resolveTexture, t as ModelLoader } from "./loader-C-NuJaEi.js";
 import { t as enderStorageBlockModel } from "./ender-storage-C8i6Rxlq.js";
 import { t as collectEntities } from "./entities-DubtdM11.js";
-import { t as collectEntityGeometry } from "./entity-models-DSZHxCx1.js";
+import { n as collectEntityGeometry } from "./entity-models-DUKiHpn1.js";
 import { t as geoBlockModel } from "./geo-blocks-BcSEBhko.js";
 import { n as discoverItems } from "./discovery-CD0QqxSF.js";
 import { t as collectItemSprites } from "./item-sprites-CnCH8YFv.js";
@@ -822,7 +822,8 @@ async function exportBlockPack(options) {
 						};
 					}),
 					sprites: sortedByKey(sheet.sprites),
-					models: sortedByKey(geometry.models)
+					models: sortedByKey(geometry.models),
+					...geometry.equipment && { equipment: geometry.equipment }
 				};
 				for (const [id, entry] of Object.entries(collected.entities)) if (entry.texture && sheet.missing.has(entry.texture)) delete collected.entities[id].texture;
 			}

package/dist/{generators-BCZVlWig.js → generators-D6giKoab.js}

@@ -22,6 +22,7 @@ const TRIM_MATERIALS = [
 ];
 /** Materials with a darker variant used when the trim matches the armor metal. */
 const TRIM_DARKER_MATERIALS = /* @__PURE__ */ new Set([
+	"copper",
 	"iron",
 	"gold",
 	"diamond",

package/dist/index.js

@@ -14,13 +14,13 @@ 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-BZLBF1hS.js";
+import { t as exportBlockPack } from "./export-DlXOK8_D.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";
 import { n as encodeIcon, t as encodeAnimatedIcon } from "./encode-LR9wxigC.js";
-import { a as builtinDynamicResources } from "./generators-BCZVlWig.js";
+import { a as builtinDynamicResources } from "./generators-D6giKoab.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-CGcHj_qq.js";
+import { t as run } from "./run-CQXJCo8u.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-C5Ifg3SM.js → inherit-BYLi3Q28.js}

@@ -1,6 +1,6 @@
 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";
+import { n as extractModel } from "./model-bytecode-B43uSqet.js";
 //#region src/entities/inherit.ts
 /**
 * A model class read together with its ancestors.

package/dist/{item-styles-DjYRdyHi.js → item-styles-BAeneY1R.js}

@@ -1,4 +1,4 @@
-import { i as TRIM_MATERIALS, n as POTTERY_SHERDS, r as TRIM_DARKER_MATERIALS, t as ARMOR_ITEM_TYPES } from "./generators-BCZVlWig.js";
+import { i as TRIM_MATERIALS, n as POTTERY_SHERDS, r as TRIM_DARKER_MATERIALS, t as ARMOR_ITEM_TYPES } from "./generators-D6giKoab.js";
 //#region src/output/item-styles.ts
 /**
 * Per-item CSS style classification, ported from upstream's ItemStyleGenerators

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

@@ -790,17 +790,46 @@ function toPart(handle) {
 		children: handle.children.map((child) => toPart(child))
 	};
 }
+/**
+* A method that builds the *armour worn on* a model rather than the model itself.
+*
+* The 26 line moved the armour meshes onto the models that wear them, so `HumanoidModel` now offers
+* `createBaseArmorMesh` and `createBabyArmorMesh` beside its own `createMesh`. A baby's armour has
+* more boxes than the humanoid does, so the fullest-mesh rule below picked it, and every player,
+* zombie and armour stand in the pack came out as a set of leggings: a `waist` and an `inner_body`
+* at knee height where the mob should have been.
+*
+* Matched by name, which is exact on a jar Mojang no longer obfuscates and harmless on one they did,
+* where no method is named anything at all.
+*/
+const ARMOUR_MESH = /armou?r/i;
+/** The baby form of an armour mesh, which is a scaled duplicate of the one worn by an adult. */
+const BABY_MESH = /baby/i;
+/**
+* The armour a humanoid wears, as its own mesh. Empty where the class builds none.
+*
+* The baby form is skipped rather than competing: it has more boxes than the adult's — a separate
+* head and body where the adult reuses the humanoid's — so the fullest-mesh rule would always pick
+* it, and every suit of armour in the world would come out child-sized.
+*/
+function extractArmourMesh(bytes, following) {
+	return extractModel(bytes, {
+		...following,
+		methods: (name) => ARMOUR_MESH.test(name) && !BABY_MESH.test(name)
+	});
+}
 function extractModel(bytes, following) {
 	const classFile = parseClassFile(bytes);
 	const notes = [];
 	const candidates = [];
 	const outward = following?.isModelCode ?? true;
+	const wanted = following?.methods ?? ((name) => !ARMOUR_MESH.test(name));
 	const own = (internalName) => {
 		if (internalName === classFile.thisClass) return classFile;
 		return outward ? following?.resolve(internalName) ?? null : null;
 	};
 	for (const method of classFile.methods) {
-		if (!method.code) continue;
+		if (!method.code || !wanted(method.name)) continue;
 		const shared = newShared(own);
 		let ok;
 		try {
@@ -841,4 +870,4 @@ function extractModel(bytes, following) {
 	return model;
 }
 //#endregion
-export { extractModel as t };
+export { extractModel as n, extractArmourMesh as t };

package/dist/output/item-styles.js

@@ -1,2 +1,2 @@
-import { t as classifyItemStyle } from "../item-styles-DjYRdyHi.js";
+import { t as classifyItemStyle } from "../item-styles-BAeneY1R.js";
 export { classifyItemStyle };

package/dist/pack-format-BP5dJMYY.js

@@ -0,0 +1,10 @@
+//#region src/blocks/pack-format.ts
+/** The armour slots the game dresses a humanoid in, in the order it layers them. */
+const EQUIPMENT_SLOTS = [
+	"feet",
+	"legs",
+	"chest",
+	"head"
+];
+//#endregion
+export { EQUIPMENT_SLOTS as t };

package/dist/{pack-format-QcVFxG_b.d.ts → pack-format-D5IgQjcD.d.ts}

@@ -252,6 +252,54 @@ interface BlockPackEntityModelsFile {
   pages: BlockPackAtlasPage[];
   sprites: Record<string, BlockPackSprite>;
   models: Record<string, EntityPackModel>;
+  /** Worn armour, when the version's classes described any. Absent otherwise. */
+  equipment?: EquipmentPack;
+}
+/** The armour slots the game dresses a humanoid in, in the order it layers them. */
+declare const EQUIPMENT_SLOTS: readonly ["feet", "legs", "chest", "head"];
+type EquipmentSlot = typeof EQUIPMENT_SLOTS[number];
+/**
+ * Worn armour: one humanoid-shaped mesh, the two sizes it is drawn at, and a sheet per material.
+ *
+ * Armour is not geometry of its own — it is the wearer's own humanoid shape grown by a fixed amount,
+ * which is why one mesh dresses a player, a zombie and an armour stand alike. The leggings are the
+ * *inner* layer and everything else the *outer*, drawn a little larger so the two never fight.
+ *
+ * Everything a consumer needs to decide what to draw is stated here rather than derived, in keeping
+ * with the rest of the pack: which parts a slot lights up, which sheet a material uses, and which
+ * material an item is made of.
+ */
+interface EquipmentPack {
+  /** Key into `models`, holding the humanoid armour shape. */
+  model: string;
+  /** How much each layer grows the wearer's boxes by, in pixels. */
+  inflate: {
+    inner: number;
+    outer: number;
+  };
+  /** Parts each slot shows. A slot lights up some of the one mesh rather than owning geometry. */
+  slots: Record<EquipmentSlot, string[]>;
+  /** Which layer a slot is drawn on, which decides the sheet as well as the size. */
+  layerOf: Record<EquipmentSlot, 'inner' | 'outer'>;
+  /** Sprite ids per material and layer, into this file's own `sprites`. */
+  materials: Record<string, Partial<Record<'inner' | 'outer', string>>>;
+  /**
+   * The armour items themselves. Keyed by item id because that is what a world writes into an
+   * entity's `equipment` compound, and nothing in the assets maps one to the other.
+   */
+  items: Record<string, {
+    material: string;
+    slot: EquipmentSlot;
+  }>;
+  /** Materials whose sheet is greyscale and takes the item's own dye colour. */
+  dyeable: string[];
+  /** Worn armour-trim sheets generated from the version's armour-trim atlas. */
+  trims: {
+    /** Sprite ids per pattern and material, into this file's own `sprites`. */
+    patterns: Record<string, Record<string, Partial<Record<'inner' | 'outer', string>>>>;
+    /** Material a trim falls back to when it matches the armour it is on. */
+    darker: Record<string, string>;
+  };
 }
 /** `meta.json`, written last because it hashes every other file. */
 interface BlockPackMetaFile {
@@ -277,4 +325,4 @@ interface BlockPackMetaFile {
   hashes: Record<string, string>;
 }
 //#endregion
-export { EntityPackPart as C, EntityPackModel as S, ItemPackLayer as T, BlockPackTintsFile as _, BlockPackBlockStatesFile as a, EntityPackCubeFace as b, BlockPackEntityModelsFile as c, BlockPackMetaFile as d, BlockPackModel as f, BlockPackSpriteFrame as g, BlockPackSprite as h, BlockPackBlockState as i, BlockPackFace as l, BlockPackRenderLayer as m, BlockPackAtlasPage as n, BlockPackElement as o, BlockPackModelsFile as p, BlockPackBiomesFile as r, BlockPackEntitiesFile as s, BlockPackAtlasFile as t, BlockPackItemsFile as u, BlockPackVariant as v, ItemPackEntry as w, EntityPackEntry as x, EntityPackCube as y };
+export { EntityPackModel as C, ItemPackEntry as D, EquipmentSlot as E, ItemPackLayer as O, EntityPackEntry as S, EquipmentPack as T, BlockPackTintsFile as _, BlockPackBlockStatesFile as a, EntityPackCube as b, BlockPackEntityModelsFile as c, BlockPackMetaFile as d, BlockPackModel as f, BlockPackSpriteFrame as g, BlockPackSprite as h, BlockPackBlockState as i, BlockPackFace as l, BlockPackRenderLayer as m, BlockPackAtlasPage as n, BlockPackElement as o, BlockPackModelsFile as p, BlockPackBiomesFile as r, BlockPackEntitiesFile as s, BlockPackAtlasFile as t, BlockPackItemsFile as u, BlockPackVariant as v, EntityPackPart as w, EntityPackCubeFace as x, EQUIPMENT_SLOTS as y };

package/dist/pack.d.ts

@@ -2,5 +2,5 @@ import { n as BiomeClimatePack, t as BiomeClimate } from "./biomes-CJDJQqJb.js";
 import { a as BlockStateMultipartCase, d as matchesCondition, 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 { n as ObjMesh, t as MeshGroup } from "./obj-mesh-ydhVfLKs.js";
 import { n as BlockTintPack, t as BlockTint } from "./tints-DoBv5S9v.js";
-import { _ as BlockPackTintsFile, a as BlockPackBlockStatesFile, d as BlockPackMetaFile, f as BlockPackModel, g as BlockPackSpriteFrame, h as BlockPackSprite, i as BlockPackBlockState, l as BlockPackFace, m as BlockPackRenderLayer, n as BlockPackAtlasPage, o as BlockPackElement, p as BlockPackModelsFile, r as BlockPackBiomesFile, t as BlockPackAtlasFile, v as BlockPackVariant } from "./pack-format-QcVFxG_b.js";
+import { _ as BlockPackTintsFile, a as BlockPackBlockStatesFile, d as BlockPackMetaFile, f as BlockPackModel, g as BlockPackSpriteFrame, h as BlockPackSprite, i as BlockPackBlockState, l as BlockPackFace, m as BlockPackRenderLayer, n as BlockPackAtlasPage, o as BlockPackElement, p as BlockPackModelsFile, r as BlockPackBiomesFile, t as BlockPackAtlasFile, v as BlockPackVariant } from "./pack-format-D5IgQjcD.js";
 export { type BiomeClimate, type BiomeClimatePack, type BlockModelVariant, type BlockPackAtlasFile, type BlockPackAtlasPage, type BlockPackBiomesFile, type BlockPackBlockState, type BlockPackBlockStatesFile, type BlockPackElement, type BlockPackFace, type BlockPackMetaFile, type BlockPackModel, type BlockPackModelsFile, type BlockPackRenderLayer, type BlockPackSprite, type BlockPackSpriteFrame, type BlockPackTintsFile, type BlockPackVariant, type BlockProperties, type BlockStateDefinition, type BlockStateMultipartCase, type BlockStateVariantCase, type BlockTint, type BlockTintPack, type MeshGroup, type MultipartCondition, type ObjMesh, evaluateBlockState, matchesCondition, weightedVariantIndex };

package/dist/{pipeline-CjRcZB63.js → pipeline-CWRQQ9DM.js}

@@ -10,7 +10,7 @@ import { t as loadAtlasResolver } from "./registry-DlduyjtM.js";
 import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
 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 builtinDynamicResources } from "./generators-D6giKoab.js";
 import { a as spawnEggTints, i as renderEntityFallback, n as dyedVariantTint, r as renderDyedVariantFallback, t as dyeVariantName } from "./entity-fallback-BRMFKPlM.js";
 import { t as legacyTintsForChain } from "./legacy-tints-l-541wgI.js";
 import { n as defaultBlockStateModel, t as blockStateTransform } from "./blockstate-DVb8Mhxc.js";

package/dist/render/pipeline.js

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

package/dist/{run-CGcHj_qq.js → run-CQXJCo8u.js}

@@ -3,10 +3,10 @@ import { n as discoverItems } from "./discovery-CD0QqxSF.js";
 import { n as LayeredResourceManager } from "./manager-BNibYkmI.js";
 import { t as curatedModelOverrides } from "./models-CZjCOjs4.js";
 import { r as encodeRasterAsset } from "./encode-LR9wxigC.js";
-import { t as classifyItemStyle } from "./item-styles-DjYRdyHi.js";
+import { t as classifyItemStyle } from "./item-styles-BAeneY1R.js";
 import { t as minifyStylesheet } from "./minify-bjMRmr5J.js";
 import { t as generateStylesheet } from "./stylesheet-CovT3B2S.js";
-import { t as ItemPipeline } from "./pipeline-CjRcZB63.js";
+import { t as ItemPipeline } from "./pipeline-CWRQQ9DM.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-CGcHj_qq.js";
+import { t as run } from "./run-CQXJCo8u.js";
 export { evaluateItemModel, run };

package/dist/workers/render-worker.js

@@ -1,4 +1,4 @@
-import { t as ItemPipeline } from "../pipeline-CjRcZB63.js";
+import { t as ItemPipeline } from "../pipeline-CWRQQ9DM.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.8",
+	"version": "1.7.0",
 	"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",

package/dist/entity-models-DSZHxCx1.js

@@ -1,127 +0,0 @@
-import { t as findGeoForEntity } from "./entity-geo-DbTtMlPL.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-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
-* 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 guessed = link?.route === "vanilla-name";
-		const found = link && !guessed ? {
-			id: link.className,
-			model: await geometryOf(link.obfuscated)
-		} : 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] = {
-			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 };