@nodecraft/rendermite 1.0.5 → 1.0.7

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/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-CEHoJ7tM.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 {
@@ -19,7 +19,8 @@ declare function q16(value: number): number;
 /**
  * Source-over with straight alpha, in place on `dst` at `offset`:
  * ra = 1-(1-sa)(1-da); rc = (sc*sa + dc*da*(1-sa)) / ra; rgb = 0 when ra = 0.
- * Results are Q16-quantized like every Imagick pixel write.
+ * Results are Q16-quantized like every Imagick pixel write. q16 is inlined
+ * here because blendPixel is the single hottest function in the pipeline.
  */
 declare function blendPixel(dst: Float64Array, offset: number, sr: number, sg: number, sb: number, sa: number): void;
 /**

package/dist/{blend-CHP2-j9U.js → blend-D0XWgVQr.js}

@@ -1,4 +1,6 @@
 //#region src/render/blend.ts
+/** Lookup table for Q16 → 8-bit conversion (ImageMagick's floor(q/257)). */
+const BYTE_LUT = /* @__PURE__ */ new Uint8Array(65536);
 function toFloatTexture(texture) {
 	const data = new Float64Array(texture.data.length);
 	for (let i = 0; i < texture.data.length; i++) data[i] = texture.data[i] / 255;
@@ -10,9 +12,11 @@ function toFloatTexture(texture) {
 }
 function toByteTexture(texture) {
 	const data = new Uint8ClampedArray(texture.data.length);
-	for (let i = 0; i < texture.data.length; i++) {
-		const value = texture.data[i];
-		data[i] = Math.floor(Math.round((value < 0 ? 0 : Math.min(value, 1)) * 65535) / 257);
+	if (BYTE_LUT[65535] === 0) for (let q = 0; q < 65536; q++) BYTE_LUT[q] = Math.floor(q / 257);
+	const src = texture.data;
+	for (let i = 0; i < src.length; i++) {
+		const value = src[i];
+		data[i] = BYTE_LUT[Math.round((value < 0 ? 0 : value > 1 ? 1 : value) * 65535)];
 	}
 	return {
 		width: texture.width,
@@ -38,7 +42,8 @@ function q16(value) {
 /**
 * Source-over with straight alpha, in place on `dst` at `offset`:
 * ra = 1-(1-sa)(1-da); rc = (sc*sa + dc*da*(1-sa)) / ra; rgb = 0 when ra = 0.
-* Results are Q16-quantized like every Imagick pixel write.
+* Results are Q16-quantized like every Imagick pixel write. q16 is inlined
+* here because blendPixel is the single hottest function in the pipeline.
 */
 function blendPixel(dst, offset, sr, sg, sb, sa) {
 	const da = dst[offset + 3];
@@ -51,10 +56,17 @@ function blendPixel(dst, offset, sr, sg, sb, sa) {
 		return;
 	}
 	const dstWeight = da * (1 - sa);
-	dst[offset] = q16((sr * sa + dst[offset] * dstWeight) / ra);
-	dst[offset + 1] = q16((sg * sa + dst[offset + 1] * dstWeight) / ra);
-	dst[offset + 2] = q16((sb * sa + dst[offset + 2] * dstWeight) / ra);
-	dst[offset + 3] = q16(ra);
+	let v = (sr * sa + dst[offset] * dstWeight) / ra;
+	v = v < 0 ? 0 : v > 1 ? 1 : v;
+	dst[offset] = Math.round(v * 65535) / 65535;
+	v = (sg * sa + dst[offset + 1] * dstWeight) / ra;
+	v = v < 0 ? 0 : v > 1 ? 1 : v;
+	dst[offset + 1] = Math.round(v * 65535) / 65535;
+	v = (sb * sa + dst[offset + 2] * dstWeight) / ra;
+	v = v < 0 ? 0 : v > 1 ? 1 : v;
+	dst[offset + 2] = Math.round(v * 65535) / 65535;
+	v = ra < 0 ? 0 : ra > 1 ? 1 : ra;
+	dst[offset + 3] = Math.round(v * 65535) / 65535;
 }
 /**
 * Upstream tintImage: uses ONLY the red channel as luminance — per pixel,

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,11 +1,11 @@
 #!/usr/bin/env node
 import { n as builtinPackPath, t as bedCompatPath } from "./builtin-caYjESh0.js";
-import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-dfI7b9N4.js";
-import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-CuG6GwQJ.js";
-import { t as JarResourceManager } from "./jar-Bt3i0ls4.js";
-import { t as run } from "./run-CfnWIRY4.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-B0qPw3zf.js";
 import { t as downloadClientJar } from "./download-D9aARBFp.js";
-import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS } from "./prepare-C8wRjAXP.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";
@@ -88,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",
@@ -122,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);
 }
@@ -188,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-lWPrB7wh.js

@@ -0,0 +1,104 @@
+import { t as blendPixel } from "./blend-D0XWgVQr.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-C5kdAm45.d.ts → encode-CaSK8-mi.d.ts}

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

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

@@ -1,4 +1,4 @@
-import { o as toByteTexture } from "./blend-CHP2-j9U.js";
+import { o as toByteTexture } from "./blend-D0XWgVQr.js";
 import sharp from "sharp";
 //#region src/output/encode.ts
 /**
@@ -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,26 +48,35 @@ 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({
+	const webpPromise = options.webp !== false ? animated().webp({
 		lossless: true,
-		effort: 6,
+		effort: ANIMATED_WEBP_EFFORT,
 		loop: 0,
 		delay: delaysMs
-	}).toBuffer();
-	if (options.gif) result.gif = await animated().gif({
+	}).toBuffer() : Promise.resolve(void 0);
+	const firstFramePromise = encodeIcon(frames[0], { webp: false });
+	const gifPromise = options.gif ? animated().gif({
 		loop: 0,
 		delay: delaysMs
-	}).toBuffer();
+	}).toBuffer() : Promise.resolve(void 0);
+	const [firstFrame, webp, gif] = await Promise.all([
+		firstFramePromise,
+		webpPromise,
+		gifPromise
+	]);
+	const result = { png: firstFrame.png };
+	if (webp) result.webp = webp;
+	if (gif) result.gif = gif;
 	if (options.avif) try {
 		result.avif = await animated().avif({
 			lossless: true,
@@ -89,19 +109,27 @@ async function encodeIcon(texture, options = {}) {
 		channels: 4
 	} });
 	const paletteSafe = countColors(bytes.data, 256) <= 256;
-	const result = { png: await raw.clone().png({
+	const pngPromise = raw.clone().png({
 		compressionLevel: 9,
 		effort: 10,
 		palette: paletteSafe
-	}).toBuffer() };
-	if (options.webp !== false) result.webp = await raw.clone().webp({
-		lossless: true,
-		effort: 6
 	}).toBuffer();
-	if (options.avif) result.avif = await raw.clone().avif({
+	const webpPromise = options.webp !== false ? raw.clone().webp({
+		lossless: true,
+		effort: STATIC_WEBP_EFFORT
+	}).toBuffer() : Promise.resolve(void 0);
+	const avifPromise = options.avif ? raw.clone().avif({
 		lossless: true,
 		effort: 6
-	}).toBuffer();
+	}).toBuffer() : Promise.resolve(void 0);
+	const [png, webp, avif] = await Promise.all([
+		pngPromise,
+		webpPromise,
+		avifPromise
+	]);
+	const result = { png };
+	if (webp) result.webp = webp;
+	if (avif) result.avif = avif;
 	return result;
 }
 //#endregion

package/dist/{entity-fallback-DfL0_eyf.js → entity-fallback-D9QTGU9X.js}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { i as renderModel } from "./renderer-LDhBNHcl.js";
+import { i as renderModel } from "./renderer-gQW_I7YG.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-C49L66sQ.d.ts}

@@ -1,8 +1,8 @@
-import { t as FloatTexture } from "./blend-Qvrn6YgK.js";
+import { t as FloatTexture } from "./blend-CEHoJ7tM.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-B9ZGJI3-.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-Cl1O4m2i.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 tintTexture, n as cloneFloatTexture, r as darkenTexture } from "./blend-D0XWgVQr.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

package/dist/{generators-CCB8h0mP.d.ts → generators-DhRov4RB.d.ts}

@@ -1,4 +1,4 @@
-import { n as MapResourceManager } from "./synthetic-CDsj--li.js";
+import { n as MapResourceManager } from "./synthetic-Qk-BSUXO.js";
 //#region src/dynamic/generators.d.ts
 declare const TRIM_MATERIALS: readonly ["quartz", "iron", "gold", "diamond", "netherite", "redstone", "copper", "emerald", "lapis", "amethyst", "resin"];
 /** Materials with a darker variant used when the trim matches the armor metal. */

package/dist/{geo-Dq2zve09.js → geo-DHiWBa-C.js}

@@ -1,8 +1,9 @@
 import { n as displayMatrix } from "./vector-CCxLae_T.js";
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { s as toFloatTexture } from "./blend-CHP2-j9U.js";
-import { t as combineFaceBuffers } from "./compose-qjhyBvnS.js";
-import { n as renderFace, t as faceMaxZ } from "./face-D-N1amV4.js";
+import { s as toFloatTexture } from "./blend-D0XWgVQr.js";
+import { t as combineFaceBuffers } from "./compose-lWPrB7wh.js";
+import { i as createFaceBuffer } from "./rasterizer-76qO8TDh.js";
+import { n as renderFace, t as faceMaxZ } from "./face-Cl1O4m2i.js";
 import { c as lightsForProfile } from "./lighting--5myudVu.js";
 //#region src/render/geo.ts
 /**
@@ -322,8 +323,10 @@ async function renderGeo(geo, texture, textures, options) {
 	});
 	renderable.sort((a, b) => a.maxZ - b.maxZ);
 	const buffers = [];
+	const scratch = createFaceBuffer(renderSize, renderSize);
+	const shadeCache = /* @__PURE__ */ new WeakMap();
 	for (const face of renderable) {
-		const buffer = renderFace(face, renderSize, renderSize, transformation);
+		const buffer = renderFace(face, renderSize, renderSize, transformation, scratch, shadeCache);
 		if (buffer) buffers.push(buffer);
 	}
 	if (buffers.length === 0) return null;