@nodecraft/rendermite 1.0.4 → 1.0.6

package/README.md

@@ -75,6 +75,11 @@ Benchmarked against PHP renderchest v5.1.0 on the same machine, rendering the sa
 | renderchest (docker, 8 workers) | 210s | 1,573 | 33 | ~449/min |
 | rendermite (one Node process, pool 8) | 22.9s | 2,065 | 0 | ~5,410/min |
 
+That comparison is a fixed point in time; rendermite has since roughly halved its own wall
+time again (worker threads, a faster compositor, bounded animations). Run `npm run bench` for
+current numbers on your machine — CI runs the same suite and comments the delta on pull
+requests.
+
 ## Testing
 
 ```sh

package/assets/README.md

@@ -15,3 +15,6 @@ generators).
 
 Layout is `<namespace>/<models|textures|items|atlases>/…` (no `assets/` nesting) — mount with
 `FolderResourceManager` above the version's own assets.
+
+`mod-tints/` is ours rather than vendored: curated item definitions for mod items that
+register their tint colors in client code. See `mod-tints/README.md`.

package/assets/mod-tints/README.md

@@ -0,0 +1,38 @@
+# Curated mod tint overrides
+
+Item definitions for mod items whose tint colors are registered in client Java code and
+therefore appear in no release's asset JSON. Layout is `<namespace>/items/<id>.json`, the
+vanilla 1.21.4+ item-definition format, mounted with `FolderResourceManager` (see
+`src/mods/tints.ts`). Nothing in the renderer special-cases these files.
+
+## Precedence
+
+This pack layers **above** the mod jars, unlike harvested overrides (which layer below so a
+mod's own data always wins). Curated entries exist because the mod ships no usable data in
+any release, and in the modern era the mod's own definition is typically an unrenderable
+code-driven model type that would shadow the override. Delete an entry once the mod ships a
+release that states the tint as data: the harvester will then source it authoritatively.
+
+## Adding an entry
+
+Every entry needs its provenance recorded below, because these values are the only ones in
+the project that cannot be traced to a jar. Hold a slot open with
+`{"type": "minecraft:constant", "value": -1}` when a layer takes no tint. Values are signed
+ARGB ints, matching vanilla's own definition files.
+
+## Entries
+
+### `advanced_ae` quantum armor (helmet, chestplate, leggings, boots)
+
+`#7110a5` on layer 1, sourced by eye and **not** verifiable against any jar. Checked:
+
+- 1.21.1 models are `layer0: <piece>_base` + `layer1: <piece>_tint`, and both textures are
+  fully grayscale, so nothing renders colored without an external value.
+- The 26.1.x definitions use `"type": "advanced_ae:quantum_armor"` with no `tints` at all.
+- `0x7110A5` appears in no class constant pool in AdvancedAE 1.21.1, AdvancedAE 26.1.7, or
+  AE2 1.21.1.
+
+The mod's own `quantum_crafter_terminal_part` tints with `ae2:color` (`color: fluix`), so
+these pieces are very likely AE2's fluix purple. Teaching `resolveTint` the `ae2:color`
+palette would replace these four files with a sourced value and cover ~116 other AE2-family
+items that currently resolve no tint at all.

package/assets/mod-tints/advanced_ae/items/quantum_boots.json

@@ -0,0 +1,16 @@
+{
+	"model": {
+		"type": "minecraft:model",
+		"model": "advanced_ae:item/quantum_boots",
+		"tints": [
+			{
+				"type": "minecraft:constant",
+				"value": -1
+			},
+			{
+				"type": "minecraft:constant",
+				"value": -9367387
+			}
+		]
+	}
+}

package/assets/mod-tints/advanced_ae/items/quantum_chestplate.json

@@ -0,0 +1,16 @@
+{
+	"model": {
+		"type": "minecraft:model",
+		"model": "advanced_ae:item/quantum_chestplate",
+		"tints": [
+			{
+				"type": "minecraft:constant",
+				"value": -1
+			},
+			{
+				"type": "minecraft:constant",
+				"value": -9367387
+			}
+		]
+	}
+}

package/assets/mod-tints/advanced_ae/items/quantum_helmet.json

@@ -0,0 +1,16 @@
+{
+	"model": {
+		"type": "minecraft:model",
+		"model": "advanced_ae:item/quantum_helmet",
+		"tints": [
+			{
+				"type": "minecraft:constant",
+				"value": -1
+			},
+			{
+				"type": "minecraft:constant",
+				"value": -9367387
+			}
+		]
+	}
+}

package/assets/mod-tints/advanced_ae/items/quantum_leggings.json

@@ -0,0 +1,16 @@
+{
+	"model": {
+		"type": "minecraft:model",
+		"model": "advanced_ae:item/quantum_leggings",
+		"tints": [
+			{
+				"type": "minecraft:constant",
+				"value": -1
+			},
+			{
+				"type": "minecraft:constant",
+				"value": -9367387
+			}
+		]
+	}
+}

package/dist/atlas/registry.d.ts

@@ -1,7 +1,7 @@
 import { n as ResourceLocator } from "../locator-jDbdUeTd.js";
-import { a as ResourceManager } from "../manager-CoZaeQTu.js";
-import { r as Texture } from "../loader-TFFNV4Jl.js";
-import { t as AtlasResolver } from "../sources-DH9dk3KF.js";
+import { a as ResourceManager } from "../manager-Cv1NeFyF.js";
+import { r as Texture } from "../loader-Myy22TDL.js";
+import { t as AtlasResolver } from "../sources-B9X9w3qP.js";
 //#region src/atlas/registry.d.ts
 declare function loadAtlasResolver(resources: ResourceManager, loadTexture: (locator: ResourceLocator) => Promise<Texture | null>, onWarning?: (message: string) => void): Promise<AtlasResolver>;
 //#endregion

package/dist/atlas/sources.d.ts

@@ -1,2 +1,2 @@
-import { a as HasTexture, c as SingleAtlasSource, d as parseAtlasSources, i as DirectoryAtlasSource, l as UnstitchAtlasSource, n as AtlasSource, o as PalettedPermutationsSource, r as AtlasSourceError, s as ResolvedSprite, t as AtlasResolver, u as createAtlasResolver } from "../sources-DH9dk3KF.js";
+import { a as HasTexture, c as SingleAtlasSource, d as parseAtlasSources, i as DirectoryAtlasSource, l as UnstitchAtlasSource, n as AtlasSource, o as PalettedPermutationsSource, r as AtlasSourceError, s as ResolvedSprite, t as AtlasResolver, u as createAtlasResolver } from "../sources-B9X9w3qP.js";
 export { AtlasResolver, AtlasSource, AtlasSourceError, DirectoryAtlasSource, HasTexture, PalettedPermutationsSource, ResolvedSprite, SingleAtlasSource, UnstitchAtlasSource, createAtlasResolver, parseAtlasSources };

package/dist/{blend-Qvrn6YgK.d.ts → blend-CyDIxCne.d.ts}

@@ -1,4 +1,4 @@
-import { r as Texture } from "./loader-TFFNV4Jl.js";
+import { r as Texture } from "./loader-Myy22TDL.js";
 //#region src/render/blend.d.ts
 /** RGBA float pixels for render-time work; converted back to 8-bit at encode. */
 interface FloatTexture {

package/dist/{builtin-C8GZEN40.js → builtin-caYjESh0.js}

@@ -12,5 +12,9 @@ function builtinPackPath(era) {
 function bedCompatPath() {
 	return path.join(assetsRoot, "builtin-bed-compat");
 }
+/** Curated tint overrides for mod items that register their colors in code. */
+function modTintPackPath() {
+	return path.join(assetsRoot, "mod-tints");
+}
 //#endregion
-export { builtinPackPath as n, bedCompatPath as t };
+export { builtinPackPath as n, modTintPackPath as r, bedCompatPath as t };

package/dist/builtin.d.ts

@@ -1,5 +1,7 @@
 //#region src/builtin.d.ts
 declare function builtinPackPath(era: 'modern' | 'legacy'): string;
 declare function bedCompatPath(): string;
+/** Curated tint overrides for mod items that register their colors in code. */
+declare function modTintPackPath(): string;
 //#endregion
-export { bedCompatPath, builtinPackPath };
+export { bedCompatPath, builtinPackPath, modTintPackPath };

package/dist/builtin.js

@@ -1,2 +1,2 @@
-import { n as builtinPackPath, t as bedCompatPath } from "./builtin-C8GZEN40.js";
-export { bedCompatPath, builtinPackPath };
+import { n as builtinPackPath, r as modTintPackPath, t as bedCompatPath } from "./builtin-caYjESh0.js";
+export { bedCompatPath, builtinPackPath, modTintPackPath };

package/dist/cache-Cr2ON3RQ.js

@@ -0,0 +1,66 @@
+//#region src/resources/cache.ts
+/**
+* Least-recently-used map used by the model and texture loaders. Their caches
+* were unbounded, which is fine for one namespace and not fine for a run that
+* walks thousands of them in a single process — resident memory only ever grew.
+*/
+var LruCache = class {
+	entries = /* @__PURE__ */ new Map();
+	maxEntries;
+	weigh;
+	maxWeight;
+	weights = /* @__PURE__ */ new Map();
+	weight = 0;
+	constructor(maxEntries, options = {}) {
+		this.maxEntries = Math.max(1, maxEntries);
+		this.maxWeight = options.maxWeight ?? Infinity;
+		this.weigh = options.weigh ?? (() => 0);
+	}
+	evict() {
+		while (this.entries.size > this.maxEntries || this.weight > this.maxWeight && this.entries.size > 1) {
+			const oldest = this.entries.keys().next();
+			if (oldest.done) return;
+			this.weight -= this.weights.get(oldest.value) ?? 0;
+			this.weights.delete(oldest.value);
+			this.entries.delete(oldest.value);
+		}
+	}
+	get size() {
+		return this.entries.size;
+	}
+	get(key) {
+		const value = this.entries.get(key);
+		if (value !== void 0) {
+			this.entries.delete(key);
+			this.entries.set(key, value);
+		}
+		return value;
+	}
+	set(key, value) {
+		if (this.entries.has(key)) {
+			this.weight -= this.weights.get(key) ?? 0;
+			this.entries.delete(key);
+		}
+		this.entries.set(key, value);
+		this.weights.set(key, 0);
+		this.evict();
+	}
+	/**
+	* Record a value's real cost once it is known. Loaders cache promises, so the
+	* weight of a decoded texture only exists after it resolves.
+	*/
+	settle(key, value) {
+		if (!this.entries.has(key)) return;
+		const size = this.weigh(value);
+		this.weight += size - (this.weights.get(key) ?? 0);
+		this.weights.set(key, size);
+		this.evict();
+	}
+	clear() {
+		this.entries.clear();
+		this.weights.clear();
+		this.weight = 0;
+	}
+};
+//#endregion
+export { LruCache as t };

package/dist/cli.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
-import { n as builtinPackPath, t as bedCompatPath } from "./builtin-C8GZEN40.js";
-import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-dfI7b9N4.js";
-import { t as JarResourceManager } from "./jar-Bt3i0ls4.js";
-import { t as run } from "./run-DI-cB38y.js";
+import { n as builtinPackPath, t as bedCompatPath } from "./builtin-caYjESh0.js";
+import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-CkletR5K.js";
+import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-B8UJmZMu.js";
+import { t as JarResourceManager } from "./jar-D9z-X7tA.js";
+import { t as run } from "./run-BnICOF4I.js";
 import { t as downloadClientJar } from "./download-D9aARBFp.js";
-import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS } from "./prepare-DROxBZp1.js";
+import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS } from "./prepare-Cc8QZ3j0.js";
 import path from "node:path";
 import os from "node:os";
 import { parseArgs } from "node:util";
@@ -30,6 +31,10 @@ const { values } = parseArgs({ options: {
 		short: "m",
 		multiple: true
 	},
+	"tint-donor": {
+		type: "string",
+		multiple: true
+	},
 	"namespace": {
 		type: "string",
 		short: "n",
@@ -83,6 +88,10 @@ const { values } = parseArgs({ options: {
 	"builtin": { type: "string" },
 	"cache-dir": { type: "string" },
 	"concurrency": { type: "string" },
+	"workers": {
+		type: "string",
+		short: "w"
+	},
 	"help": {
 		type: "boolean",
 		short: "h",
@@ -101,6 +110,7 @@ Input:
   -v, --version <ver>      download + prepare a vanilla version (1.2.5 … latest)
   -a, --assets <dir>       asset root (repeatable, first wins), <namespace>/ children
   -m, --mod <jar>          mod jar layered under vanilla (repeatable)
+      --tint-donor <jar>   1.21.4+ jar of a loaded mod, read for its tints (repeatable)
 
 Options:
   -n, --namespace <ns>     namespace to render (repeatable, default: minecraft)
@@ -116,7 +126,8 @@ Options:
       --lighting-profile   modern (default) | legacy (matches published corpus)
       --builtin <dir>      override the builtin pack (defaults per era)
       --cache-dir <dir>    jar download cache (default ~/.rendermite)
-      --concurrency <n>    in-flight items (default 8)
+      --concurrency <n>    in-flight items per thread (default 8)
+  -w, --workers <n>        render threads (default: one per core, less one)
 `);
 	process.exit(values.help ? 0 : 1);
 }
@@ -147,7 +158,28 @@ if (values.version) {
 	resources = managers.length === 1 ? managers[0] : new LayeredResourceManager(managers);
 	builtin ??= builtinPackPath("modern");
 }
-if (values.mod?.length) resources = new LayeredResourceManager([resources, ...values.mod.map((jar) => new JarResourceManager(jar))]);
+if (values["tint-donor"]?.length && !values.mod?.length) {
+	console.error("--tint-donor needs --mod: donors are read for the tints of loaded mods.");
+	process.exit(1);
+}
+if (values.mod?.length) {
+	const base = new LayeredResourceManager([
+		resources,
+		curatedTintOverrides(),
+		...values.mod.map((jar) => new JarResourceManager(jar))
+	]);
+	resources = base;
+	if (values["tint-donor"]?.length) {
+		const donorJars = values["tint-donor"].map((jar) => new JarResourceManager(jar));
+		const harvest = await harvestTintOverrides({
+			donors: new LayeredResourceManager(donorJars),
+			target: base
+		});
+		await Promise.all(donorJars.map((jar) => jar.close().catch(() => {})));
+		console.log(`Harvested tints for ${harvest.harvested} items from ${donorJars.length} donor jars`);
+		if (harvest.harvested > 0) resources = new LayeredResourceManager([base, harvest.overrides]);
+	}
+}
 const result = await run({
 	resources,
 	builtin,
@@ -161,6 +193,7 @@ const result = await run({
 	gif: values.gif,
 	avif: values.avif,
 	concurrency: values.concurrency ? Number(values.concurrency) : void 0,
+	workers: values.workers ? Number(values.workers) : void 0,
 	lightingProfile: values["lighting-profile"] === "legacy" ? "legacy" : "modern",
 	itemList: values["item-list"],
 	onProgress: (done, total, id, error) => {

package/dist/compose-CQCb2LVv.js

@@ -0,0 +1,104 @@
+import { t as blendPixel } from "./blend-CHP2-j9U.js";
+//#region src/render/compose.ts
+/**
+* Per-pixel painter's compositing, mirroring upstream Model::combineFaceImages:
+* at each pixel, faces sorted ascending by that pixel's depth value (0 where the
+* rasterizer never wrote depth — the overdraw band relies on sorting beneath),
+* then source-over blended in that order when alpha > 0.
+*
+* Upstream re-sorts one persistent array, so each pixel's sort is really a
+* stable partition: faces the pixel misses keep their order, faces with depth
+* move to the end in depth order. That reordering is invariant under taking
+* subsets, so instead of touching every face at every pixel we keep a rank per
+* face (a moved face gets a fresh, higher rank) and visit only the faces whose
+* bounding box contains the pixel. Same order, same pixels, sublinear in faces.
+*/
+function combineFaceBuffers(width, height, faces) {
+	const out = new Float64Array(width * height * 4);
+	const count = faces.length;
+	if (count === 0) return {
+		width,
+		height,
+		data: out
+	};
+	const rowCounts = new Int32Array(height + 1);
+	for (const face of faces) {
+		const endY = Math.min(face.y + face.height, height);
+		for (let y = Math.max(face.y, 0); y < endY; y++) rowCounts[y]++;
+	}
+	const rowStart = new Int32Array(height + 1);
+	for (let y = 0; y < height; y++) rowStart[y + 1] = rowStart[y] + rowCounts[y];
+	const cursor = [...rowStart];
+	const rowFaces = new Int32Array(rowStart[height]);
+	for (let index = 0; index < count; index++) {
+		const face = faces[index];
+		const endY = Math.min(face.y + face.height, height);
+		for (let y = Math.max(face.y, 0); y < endY; y++) rowFaces[cursor[y]++] = index;
+	}
+	const rank = new Float64Array(count);
+	for (let index = 0; index < count; index++) rank[index] = index;
+	let nextRank = count;
+	const flat = new Int32Array(count);
+	const flatRank = new Float64Array(count);
+	const deep = new Int32Array(count);
+	const deepDepth = new Float64Array(count);
+	const deepRank = new Float64Array(count);
+	for (let y = 0; y < height; y++) {
+		const start = rowStart[y];
+		const end = rowStart[y + 1];
+		if (start === end) continue;
+		for (let x = 0; x < width; x++) {
+			let flatCount = 0;
+			let deepCount = 0;
+			for (let slot = start; slot < end; slot++) {
+				const index = rowFaces[slot];
+				const face = faces[index];
+				const localX = x - face.x;
+				if (localX < 0 || localX >= face.width) continue;
+				const localPixel = (y - face.y) * face.width + localX;
+				const depth = face.depths[localPixel];
+				if (depth > 0) {
+					let slotIndex = deepCount++;
+					while (slotIndex > 0 && (deepDepth[slotIndex - 1] > depth || deepDepth[slotIndex - 1] === depth && deepRank[slotIndex - 1] > rank[index])) {
+						deep[slotIndex] = deep[slotIndex - 1];
+						deepDepth[slotIndex] = deepDepth[slotIndex - 1];
+						deepRank[slotIndex] = deepRank[slotIndex - 1];
+						slotIndex--;
+					}
+					deep[slotIndex] = index;
+					deepDepth[slotIndex] = depth;
+					deepRank[slotIndex] = rank[index];
+				} else {
+					let slotIndex = flatCount++;
+					while (slotIndex > 0 && flatRank[slotIndex - 1] > rank[index]) {
+						flat[slotIndex] = flat[slotIndex - 1];
+						flatRank[slotIndex] = flatRank[slotIndex - 1];
+						slotIndex--;
+					}
+					flat[slotIndex] = index;
+					flatRank[slotIndex] = rank[index];
+				}
+			}
+			if (flatCount === 0 && deepCount === 0) continue;
+			const offset = (y * width + x) * 4;
+			for (let i = 0; i < flatCount; i++) blendFace(out, offset, faces[flat[i]], x, y);
+			for (let i = 0; i < deepCount; i++) {
+				const index = deep[i];
+				blendFace(out, offset, faces[index], x, y);
+				rank[index] = nextRank++;
+			}
+		}
+	}
+	return {
+		width,
+		height,
+		data: out
+	};
+}
+function blendFace(out, offset, face, x, y) {
+	const faceOffset = ((y - face.y) * face.width + (x - face.x)) * 4;
+	const alpha = face.colors[faceOffset + 3];
+	if (alpha > 0) blendPixel(out, offset, face.colors[faceOffset], face.colors[faceOffset + 1], face.colors[faceOffset + 2], alpha);
+}
+//#endregion
+export { combineFaceBuffers as t };

package/dist/descriptor-DWebtkI1.js

@@ -0,0 +1,26 @@
+import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-CkletR5K.js";
+import { n as MapResourceManager, t as KindFilteredResourceManager } from "./synthetic-ZAUjXT7E.js";
+import { t as JarResourceManager } from "./jar-D9z-X7tA.js";
+//#region src/resources/descriptor.ts
+/**
+* Serializable descriptions of a resource tree, so the same layered tree can be
+* rebuilt inside a worker thread. Managers describe themselves; a tree
+* containing anything that cannot (a consumer's own ResourceManager) describes
+* as null, and the caller renders in-process rather than silently dropping
+* layers.
+*/
+function describeResources(manager) {
+	const describable = manager;
+	return typeof describable.describe === "function" ? describable.describe() : null;
+}
+function restoreResources(descriptor) {
+	switch (descriptor.kind) {
+		case "folder": return new FolderResourceManager(descriptor.root);
+		case "jar": return new JarResourceManager(descriptor.path);
+		case "map": return MapResourceManager.fromEntries(descriptor.entries);
+		case "layered": return new LayeredResourceManager(descriptor.layers.map((layer) => restoreResources(layer)));
+		case "kindFiltered": return new KindFilteredResourceManager(restoreResources(descriptor.inner), descriptor.kinds);
+	}
+}
+//#endregion
+export { restoreResources as n, describeResources as t };

package/dist/{discovery-D89pVVJA.d.ts → discovery-wiJBGryo.d.ts}

@@ -1,4 +1,4 @@
-import { a as ResourceManager } from "./manager-CoZaeQTu.js";
+import { a as ResourceManager } from "./manager-Cv1NeFyF.js";
 import { i as ItemRenderInstruction, r as ItemProperties } from "./definition-BwX6Xxv0.js";
 //#region src/items/discovery.d.ts
 declare class ItemResolutionError extends Error {}

package/dist/dynamic/generators.d.ts

@@ -1,2 +1,2 @@
-import { a as TRIM_DARKER_MATERIALS, i as POTTERY_SHERDS, n as DynamicItem, o as TRIM_MATERIALS, r as DynamicResources, s as builtinDynamicResources, t as ARMOR_ITEM_TYPES } from "../generators-CCB8h0mP.js";
+import { a as TRIM_DARKER_MATERIALS, i as POTTERY_SHERDS, n as DynamicItem, o as TRIM_MATERIALS, r as DynamicResources, s as builtinDynamicResources, t as ARMOR_ITEM_TYPES } from "../generators-DhRov4RB.js";
 export { ARMOR_ITEM_TYPES, DynamicItem, DynamicResources, POTTERY_SHERDS, TRIM_DARKER_MATERIALS, TRIM_MATERIALS, builtinDynamicResources };

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-CcVRG30y.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-BlG4KmtP.js";
 export { ARMOR_ITEM_TYPES, POTTERY_SHERDS, TRIM_DARKER_MATERIALS, TRIM_MATERIALS, builtinDynamicResources };

package/dist/{encode-3u49i-eD.js → encode-D6dQu2dJ.js}

@@ -6,6 +6,17 @@ import sharp from "sharp";
 * separate optimization step is needed: lossless everywhere, strictly-smaller
 * candidates only.
 */
+/**
+* Lossless WebP effort for single-frame icons. Measured across 1.12.2–1.21.8
+* vanilla, effort 2 is 0.1–1.9% SMALLER than effort 6 for static icons at 2.8×
+* the speed — libvips' higher efforts search predictors that rarely pay off on
+* 64px sprites. Animations are the opposite (up to 21% larger on one item), so
+* they keep effort 6 below.
+*/
+const STATIC_WEBP_EFFORT = 2;
+const ANIMATED_WEBP_EFFORT = 6;
+/** Frames encoded concurrently when assembling an animation's pages. */
+const PAGE_ENCODE_BATCH = 8;
 /** Losslessly transcode an existing PNG resource into the formats referenced by generated CSS. */
 async function encodeRasterAsset(source, formats) {
 	const image = sharp(source);
@@ -37,19 +48,20 @@ async function encodeRasterAsset(source, formats) {
 async function encodeAnimatedIcon(frames, delaysMs, options = {}) {
 	if (frames.length === 1) return encodeIcon(frames[0], options);
 	const { width, height } = frames[0];
-	const pages = await Promise.all(frames.map((frame) => {
+	const pages = [];
+	for (let start = 0; start < frames.length; start += PAGE_ENCODE_BATCH) pages.push(...await Promise.all(frames.slice(start, start + PAGE_ENCODE_BATCH).map((frame) => {
 		const bytes = toByteTexture(frame);
 		return sharp(Buffer.from(bytes.data.buffer, bytes.data.byteOffset, bytes.data.length), { raw: {
 			width,
 			height,
 			channels: 4
 		} }).png({ compressionLevel: 0 }).toBuffer();
-	}));
+	})));
 	const animated = () => sharp(pages, { join: { animated: true } });
 	const result = { png: (await encodeIcon(frames[0], { webp: false })).png };
 	if (options.webp !== false) result.webp = await animated().webp({
 		lossless: true,
-		effort: 6,
+		effort: ANIMATED_WEBP_EFFORT,
 		loop: 0,
 		delay: delaysMs
 	}).toBuffer();
@@ -96,7 +108,7 @@ async function encodeIcon(texture, options = {}) {
 	}).toBuffer() };
 	if (options.webp !== false) result.webp = await raw.clone().webp({
 		lossless: true,
-		effort: 6
+		effort: STATIC_WEBP_EFFORT
 	}).toBuffer();
 	if (options.avif) result.avif = await raw.clone().avif({
 		lossless: true,

package/dist/{encode-C5kdAm45.d.ts → encode-DaNQF28M.d.ts}

@@ -1,4 +1,4 @@
-import { t as FloatTexture } from "./blend-Qvrn6YgK.js";
+import { t as FloatTexture } from "./blend-CyDIxCne.js";
 //#region src/output/encode.d.ts
 interface EncodedIcon {
   png: Buffer;

package/dist/{entity-fallback-CdCVEG6X.js → entity-fallback-BRCeGKBT.js}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { i as renderModel } from "./renderer-BeOinVC8.js";
+import { i as renderModel } from "./renderer-CjT19tHd.js";
 //#region src/render/entity-fallback.ts
 /**
 * Heuristic rendering for mod items that parent `builtin/entity` — chests,

package/dist/{face-CpVdnf-w.d.ts → face-BIYg14TE.d.ts}

@@ -1,8 +1,8 @@
-import { t as FloatTexture } from "./blend-Qvrn6YgK.js";
+import { t as FloatTexture } from "./blend-CyDIxCne.js";
 import { t as Mat4 } from "./vector-DRKRi4--.js";
 import { n as FaceGeometry } from "./geometry-BSVmKx5b.js";
 import { r as LightSource } from "./lighting-3FGRC3Af.js";
-import { t as FaceBuffer } from "./rasterizer-Dh35qXbn.js";
+import { n as FaceBuffer } from "./rasterizer-yqJkicm1.js";
 //#region src/render/face.d.ts
 interface TintColor {
   r: number;
@@ -17,8 +17,14 @@ interface RenderableFace {
   /** Untransformed model-space max Z — upstream's stable pre-sort key. */
   maxZ: number;
 }
+/** Tinted + darkened textures keyed by source texture, then by shading params. */
+type FaceShadeCache = WeakMap<FloatTexture, Map<string, FloatTexture>>;
 declare function faceMaxZ(geometry: FaceGeometry): number;
 /** Returns null when the face is culled, degenerate, or has a zero-area UV. */
-declare function renderFace(face: RenderableFace, width: number, height: number, transformation: Mat4): FaceBuffer | null;
+declare function renderFace(face: RenderableFace, width: number, height: number, transformation: Mat4,
+/** Reused across a model's faces; cleared here, compacted before return. */
+scratch?: FaceBuffer,
+/** Shared tint/shade results for one model render. */
+shadeCache?: FaceShadeCache): FaceBuffer | null;
 //#endregion
-export { renderFace as i, TintColor as n, faceMaxZ as r, RenderableFace as t };
+export { renderFace as a, faceMaxZ as i, RenderableFace as n, TintColor as r, FaceShadeCache as t };

package/dist/{face-D-N1amV4.js → face-DmCiHUd5.js}

@@ -1,6 +1,6 @@
 import { c as normalize, g as transformVector, h as transformDirection, m as sub, r as dot, t as cross } from "./vector-CCxLae_T.js";
 import { a as tintTexture, n as cloneFloatTexture, r as darkenTexture } from "./blend-CHP2-j9U.js";
-import { a as phpRound, i as drawTexturedTriangle, n as compactFaceBuffer, r as createFaceBuffer, t as RowCursor } from "./rasterizer-BHWDrmGz.js";
+import { a as drawTexturedTriangle, i as createFaceBuffer, n as clearFaceBuffer, o as phpRound, r as compactFaceBuffer, t as RowCursor } from "./rasterizer-76qO8TDh.js";
 //#region src/render/face.ts
 /**
 * Face rendering: cull, transform, project, tint, darken, rasterize — a faithful
@@ -18,7 +18,7 @@ function faceNormal(v0, v1, v2) {
 	return normalize(normal);
 }
 /** Returns null when the face is culled, degenerate, or has a zero-area UV. */
-function renderFace(face, width, height, transformation) {
+function renderFace(face, width, height, transformation, scratch, shadeCache) {
 	const { geometry } = face;
 	const uvWidth = geometry.uv2[0] - geometry.uv1[0];
 	const uvHeight = geometry.uv2[1] - geometry.uv1[1];
@@ -49,13 +49,25 @@ function renderFace(face, width, height, transformation) {
 			y: phpRound(height - ((v[1] - .5) * height + height / 2))
 		};
 	});
-	const texture = cloneFloatTexture(face.texture);
-	const absU1 = geometry.uv1[0] * texture.width;
-	const absV1 = geometry.uv1[1] * texture.height;
-	const absU2 = geometry.uv2[0] * texture.width;
-	const absV2 = geometry.uv2[1] * texture.height;
-	if (geometry.tintIndex !== null && face.tint !== null) tintTexture(texture, face.tint.r, face.tint.g, face.tint.b);
-	darkenTexture(texture, 1 - face.light.lightLevelForNormal(shadeDirection), absU1, absV1, absU2, absV2);
+	const absU1 = geometry.uv1[0] * face.texture.width;
+	const absV1 = geometry.uv1[1] * face.texture.height;
+	const absU2 = geometry.uv2[0] * face.texture.width;
+	const absV2 = geometry.uv2[1] * face.texture.height;
+	const tint = geometry.tintIndex !== null ? face.tint : null;
+	const darkness = 1 - face.light.lightLevelForNormal(shadeDirection);
+	const shadeKey = `${tint ? `${tint.r},${tint.g},${tint.b}` : "-"}|${darkness}|${absU1},${absV1},${absU2},${absV2}`;
+	let byKey = shadeCache?.get(face.texture);
+	let texture = byKey?.get(shadeKey);
+	if (!texture) {
+		texture = cloneFloatTexture(face.texture);
+		if (tint) tintTexture(texture, tint.r, tint.g, tint.b);
+		darkenTexture(texture, darkness, absU1, absV1, absU2, absV2);
+		if (shadeCache) {
+			byKey ??= /* @__PURE__ */ new Map();
+			byKey.set(shadeKey, texture);
+			shadeCache.set(face.texture, byKey);
+		}
+	}
 	const uvs = [
 		[geometry.uv1[0], geometry.uv1[1]],
 		[geometry.uv1[0] + uvWidth, geometry.uv1[1]],
@@ -67,7 +79,8 @@ function renderFace(face, width, height, transformation) {
 		const last = uvs.pop();
 		if (last) uvs.unshift(last);
 	}
-	const buffer = createFaceBuffer(width, height);
+	const buffer = scratch ?? createFaceBuffer(width, height);
+	clearFaceBuffer(buffer);
 	const depths = [
 		linearDepth(v0[2]),
 		linearDepth(v1[2]),

package/dist/{generators-CcVRG30y.js → generators-BlG4KmtP.js}

@@ -1,4 +1,4 @@
-import { n as MapResourceManager } from "./synthetic-DC2bSnGe.js";
+import { n as MapResourceManager } from "./synthetic-ZAUjXT7E.js";
 //#region src/dynamic/generators.ts
 /**
 * Dynamic resources ported from renderchest's DynamicResourceGenerators, built