@nodecraft/rendermite 1.0.7 → 1.1.1

package/dist/blockstate-CdstnW2-.js

@@ -0,0 +1,104 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import { _ as translation, d as rotationY, s as multiply, u as rotationX } from "./vector-CCxLae_T.js";
+//#region src/items/blockstate.ts
+/**
+* Block models for items the game draws through a block-entity item renderer.
+*
+* A `builtin/entity` item model carries no geometry, but for a BlockItem the
+* renderer usually still draws the block first — Mekanism's `MekanismISTER`
+* calls `getBlockModelShaper().getBlockModel(block.defaultBlockState())` and
+* only then adds its own extras. That model is stated in the mod's own
+* blockstate file, so resolving it is following the data rather than guessing at
+* a name: `mekanism:basic_energy_cube` names `mekanism:block/energy_cube/basic`,
+* which no same-name lookup would ever find.
+*
+* The one thing assets cannot state is which state is the *default*, since that
+* lives in the block's Java constructor. `scoreVariant` picks the variant the
+* game would almost always start from, and prefers an unrotated one so an icon
+* is never accidentally turned away from the camera.
+*/
+/**
+* Property values a block's default state overwhelmingly uses. Blocks declare
+* their own defaults in code, so this is the one inference here — but a facing
+* block defaults to north far more often than not, and a machine defaults to
+* idle rather than running.
+*/
+const DEFAULT_VALUES = {
+	facing: "north",
+	active: "false",
+	lit: "false",
+	powered: "false",
+	open: "false",
+	half: "lower",
+	axis: "y",
+	waterlogged: "false"
+};
+/** Higher is more likely to be the state the game shows for a fresh block. */
+function scoreVariant(key, variant) {
+	let score = 0;
+	if (key === "") score += 4;
+	if (!variant.x && !variant.y) score += 2;
+	for (const pair of key.split(",")) {
+		const [name, value] = pair.split("=", 2);
+		if (name && DEFAULT_VALUES[name] === value) score++;
+	}
+	return score;
+}
+function firstOf(variant) {
+	const entry = Array.isArray(variant) ? variant[0] : variant;
+	return entry?.model ? entry : null;
+}
+/**
+* The block model an item's blockstate names for its default state, or null
+* when the item has no blockstate or it states nothing usable.
+*/
+async function defaultBlockStateModel(resources, id) {
+	const locator = ResourceLocator.tryParse(id);
+	if (!locator) return null;
+	const raw = await resources.getResource("blockstate", locator);
+	if (raw === null) return null;
+	let json;
+	try {
+		json = JSON.parse(raw.toString("utf8"));
+	} catch {
+		return null;
+	}
+	let best = null;
+	let bestScore = -1;
+	for (const [key, value] of Object.entries(json.variants ?? {})) {
+		const variant = firstOf(value);
+		if (!variant) continue;
+		const score = scoreVariant(key, variant);
+		if (score > bestScore) {
+			best = variant;
+			bestScore = score;
+		}
+	}
+	if (!best) {
+		for (const part of json.multipart ?? []) if (part.when === void 0) {
+			best = firstOf(part.apply);
+			break;
+		}
+	}
+	if (!best) return null;
+	const model = ResourceLocator.tryParse(best.model.includes(":") ? best.model : `${locator.namespace}:${best.model}`);
+	return model === null ? null : {
+		model,
+		xRotation: best.x ?? 0,
+		yRotation: best.y ?? 0
+	};
+}
+/**
+* The blockstate's own x/y rotation as an item transform. Vanilla applies these
+* about the block's centre, and the game bakes them into the model before the
+* display transform, so they compose the same way here.
+*/
+function blockStateTransform(state) {
+	const toRadians = Math.PI / 180;
+	let matrix = translation(.5, .5, .5);
+	matrix = multiply(matrix, rotationX(-state.xRotation * toRadians));
+	matrix = multiply(matrix, rotationY(-state.yRotation * toRadians));
+	return multiply(matrix, translation(-.5, -.5, -.5));
+}
+//#endregion
+export { defaultBlockStateModel as n, blockStateTransform as t };

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

@@ -16,5 +16,9 @@ function bedCompatPath() {
 function modTintPackPath() {
 	return path.join(assetsRoot, "mod-tints");
 }
+/** Curated geometry for mod items the game draws in code (builtin/entity). */
+function modModelPackPath() {
+	return path.join(assetsRoot, "mod-models");
+}
 //#endregion
-export { builtinPackPath as n, modTintPackPath as r, bedCompatPath as t };
+export { modTintPackPath as i, builtinPackPath as n, modModelPackPath as r, bedCompatPath as t };

package/dist/builtin.d.ts

@@ -3,5 +3,7 @@ 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;
+/** Curated geometry for mod items the game draws in code (builtin/entity). */
+declare function modModelPackPath(): string;
 //#endregion
-export { bedCompatPath, builtinPackPath, modTintPackPath };
+export { bedCompatPath, builtinPackPath, modModelPackPath, modTintPackPath };

package/dist/builtin.js

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

package/dist/cli.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import { n as builtinPackPath, t as bedCompatPath } from "./builtin-caYjESh0.js";
+import { n as builtinPackPath, t as bedCompatPath } from "./builtin-WkWjATeh.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 curatedModelOverrides } from "./models-BKxGkPS7.js";
+import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-CebmvjmP.js";
 import { t as JarResourceManager } from "./jar-D9z-X7tA.js";
-import { t as run } from "./run-B0qPw3zf.js";
+import { t as run } from "./run-D87zIGfr.js";
 import { t as downloadClientJar } from "./download-D9aARBFp.js";
 import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS } from "./prepare-Cc8QZ3j0.js";
 import path from "node:path";
@@ -166,6 +167,7 @@ if (values.mod?.length) {
 	const base = new LayeredResourceManager([
 		resources,
 		curatedTintOverrides(),
+		curatedModelOverrides(),
 		...values.mod.map((jar) => new JarResourceManager(jar))
 	]);
 	resources = base;

package/dist/{compose-lWPrB7wh.js → compose-BGsNFR12.js}

@@ -1,4 +1,4 @@
-import { t as blendPixel } from "./blend-D0XWgVQr.js";
+import { t as blendPixel } from "./blend-KXMclcHk.js";
 //#region src/render/compose.ts
 /**
 * Per-pixel painter's compositing, mirroring upstream Model::combineFaceImages:

package/dist/{definition-3MBm8ar_.js → definition-ColsvWrH.js}

@@ -108,9 +108,28 @@ function evaluateItemModel(node, properties = defaultProperties(), parentTransfo
 				}];
 			}
 			return [];
+		case "neoforge:fluid_container":
+		case "forge:fluid_container": {
+			const fluid = typeof item.fluid === "string" ? item.fluid : void 0;
+			const base = item.textures?.base;
+			return [{
+				model: typeof base === "string" && base.includes("item/") ? base : "minecraft:item/bucket",
+				tints: [],
+				transform,
+				...fluid && !fluid.endsWith(":empty") && { fluid }
+			}];
+		}
 		case "minecraft:empty":
 		case "minecraft:bundle/selected_item": return [];
-		default: throw new InvalidItemDefinitionError(`Unknown item model type: ${String(item.type)}`);
+		default: {
+			const named = typeof item.model === "string" ? item.model : item.base_model;
+			if (typeof named === "string") return [{
+				model: named,
+				tints: Array.isArray(item.tints) ? item.tints : [],
+				transform
+			}];
+			throw new InvalidItemDefinitionError(`Unknown item model type: ${String(item.type)}`);
+		}
 	}
 }
 //#endregion

package/dist/{definition-BwX6Xxv0.d.ts → definition-ricL7Jqf.d.ts}

@@ -6,6 +6,8 @@ interface ItemRenderInstruction {
   model: string;
   tints: TintDefinition[];
   transform: Mat4;
+  /** Fluid to paint into the bucket, from a fluid_container item model. */
+  fluid?: string;
 }
 interface TintDefinition {
   type: string;

package/dist/{discovery-0SM0cTLw.js → discovery-B9aqV_Rz.js}

@@ -1,6 +1,6 @@
-import { o as identity } from "./vector-CCxLae_T.js";
-import { o as evaluateItemModel } from "./definition-3MBm8ar_.js";
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import { o as identity } from "./vector-CCxLae_T.js";
+import { n as InvalidItemDefinitionError, o as evaluateItemModel } from "./definition-ColsvWrH.js";
 //#region src/items/discovery.ts
 /**
 * Era-adaptive item discovery — the piece no single renderchest tag has:
@@ -78,7 +78,17 @@ async function resolveItem(resources, id, properties) {
 			throw new ItemResolutionError(`Item definition is not valid JSON: ${id}`);
 		}
 		if (parsed.model === void 0) throw new ItemResolutionError(`Item definition has no model node: ${id}`);
-		return evaluateItemModel(parsed.model, properties);
+		try {
+			return evaluateItemModel(parsed.model, properties);
+		} catch (err) {
+			const conventional = new ResourceLocator(locator.namespace, `item/${locator.path}`);
+			if (err instanceof InvalidItemDefinitionError && await resources.hasResource("model", conventional)) return [{
+				model: conventional.toString(),
+				tints: [],
+				transform: identity()
+			}];
+			throw err;
+		}
 	}
 	const modelLocator = new ResourceLocator(locator.namespace, `item/${locator.path}`);
 	if (await resources.hasResource("model", modelLocator)) return [{

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

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

package/dist/{encode-CaSK8-mi.d.ts → encode-DNcXXvYe.d.ts}

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

package/dist/{encode-Df_tWzkl.js → encode-LR9wxigC.js}

@@ -1,4 +1,4 @@
-import { o as toByteTexture } from "./blend-D0XWgVQr.js";
+import { c as toByteTexture } from "./blend-KXMclcHk.js";
 import sharp from "sharp";
 //#region src/output/encode.ts
 /**

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

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { i as renderModel } from "./renderer-gQW_I7YG.js";
+import { i as renderModel } from "./renderer-oi1MSF3Y.js";
 //#region src/render/entity-fallback.ts
 /**
 * Heuristic rendering for mod items that parent `builtin/entity` — chests,
@@ -64,6 +64,22 @@ async function findChestTexture(resources, namespace, itemName) {
 	}
 	return best;
 }
+/**
+* An item's English display name, slugified, or null. Mods do not always put the
+* kind in the id — lootr's Loot Chest is `lootr_inventory` — and the lang file is
+* a statement of what the thing is rather than a guess from its name.
+*/
+async function displayName(resources, locator) {
+	const raw = await resources.getResource("lang", new ResourceLocator(locator.namespace, "en_us")).catch(() => null);
+	if (!raw) return null;
+	try {
+		const lang = JSON.parse(raw.toString("utf8"));
+		const value = lang[`item.${locator.namespace}.${locator.path}`] ?? lang[`block.${locator.namespace}.${locator.path}`];
+		return typeof value === "string" ? value.toLowerCase().replaceAll(/[^a-z\d]+/g, "_") : null;
+	} catch {
+		return null;
+	}
+}
 /** Clone a resolved model with one texture variable rebound. */
 function withTexture(model, name, locator) {
 	return {
@@ -99,6 +115,33 @@ const DYE_COLORS = {
 	black: 1908001
 };
 const DYE_PREFIX = new RegExp(`^(${Object.keys(DYE_COLORS).join("|")})_(.+)$`);
+/** Skin sheet sizes the mobheads pack has base geometry for. */
+const HEAD_LAYOUTS = {
+	"64x32": "head_64_32",
+	"64x64": "head_64_64",
+	"32x32": "head_32_32"
+};
+/**
+* The entity sheet for a mob, preferring a file named exactly after it. Sheets
+* live at entity/<mob>.png or entity/<mob>/<mob>.png depending on the mod, and a
+* head only ever wants the base skin — never a blink or armour overlay.
+*/
+async function findMobTexture(resources, namespace, mob) {
+	for (const source of [namespace, "minecraft"]) {
+		for (const candidate of [`entity/${mob}`, `entity/${mob}/${mob}`]) {
+			const locator = new ResourceLocator(source, candidate);
+			if (await resources.hasResource("texture", locator)) return locator;
+		}
+		let best = null;
+		for (const locator of await resources.listResources("texture", source)) {
+			const leaf = locator.path.split("/").pop();
+			if (!locator.path.startsWith("entity/") || leaf !== mob) continue;
+			if (best === null || locator.path.length < best.path.length) best = locator;
+		}
+		if (best) return best;
+	}
+	return null;
+}
 /** Find a full modded bed entity sheet, preferring every distinguishing item-name token. */
 async function findBedTexture(resources, namespace, itemName) {
 	const wanted = tokens(itemName).filter((token) => token !== "bed");
@@ -120,6 +163,37 @@ async function findBedTexture(resources, namespace, itemName) {
 	}
 	return best;
 }
+/** The dye name a `<dye>_<thing>` mod item is prefixed with, or null. */
+function dyeVariantName(id) {
+	const locator = ResourceLocator.tryParse(id);
+	if (!locator || locator.namespace === "minecraft") return null;
+	const name = locator.path.split("/").pop() ?? locator.path;
+	return DYE_PREFIX.exec(name)?.[1] ?? null;
+}
+/**
+* The dye color a `<dye>_<thing>` item name implies, or null. Mods that name
+* variants after dyes sometimes register the matching DyeColor as the tint in
+* client code, where no asset states it (waystones' sharestones call
+* `DyeColor.getTextColor()`), so the name is the only record of it left.
+*
+* Only ever right for variants that SHARE one uncoloured sprite. A mod that
+* draws each colour its own texture is already the right colour, and tinting it
+* again multiplies the dye in — chipped's blue_paper_lantern came out near
+* black. Callers must check the model's textures; see `dyeVariantName`.
+*/
+function dyedVariantTint(id) {
+	const locator = ResourceLocator.tryParse(id);
+	if (!locator || locator.namespace === "minecraft") return null;
+	const name = locator.path.split("/").pop() ?? locator.path;
+	const match = DYE_PREFIX.exec(name);
+	if (!match) return null;
+	const color = DYE_COLORS[match[1]];
+	return {
+		r: (color >>> 16 & 255) / 255,
+		g: (color >>> 8 & 255) / 255,
+		b: (color & 255) / 255
+	};
+}
 /**
 * Dyed variants of vanilla items whose models mods generate at runtime (quark's
 * `black_frame_empty` parents a block model that exists nowhere on disk): render
@@ -242,19 +316,28 @@ async function spawnEggTints(id, resources, textures) {
 async function renderEntityFallback(id, models, textures, resources, options) {
 	const locator = ResourceLocator.parse(id);
 	const name = locator.path.split("/").pop() ?? locator.path;
+	const searchName = `${name}_${await displayName(resources, locator) ?? ""}`;
 	const headMatch = /^(.+?)_(?:head|skull)$/.exec(name);
 	if (headMatch) {
-		const parts = headMatch[1].replace(/^(?:carved|wall|floor)_/, "").split("_");
+		const mob = headMatch[1].replace(/^(?:carved|wall|floor)_/, "");
+		const parts = mob.split("_");
 		for (let keep = parts.length; keep >= 1 && keep >= parts.length - 2; keep--) try {
 			const model = await models.load(`mobheads:item/${parts.slice(0, keep).join("_")}`);
 			return await renderModel(model, textures, options);
 		} catch {
 			continue;
 		}
+		const sheet = await findMobTexture(resources, locator.namespace, mob);
+		const skin = sheet ? await textures.load(sheet).catch(() => null) : null;
+		const base = skin ? HEAD_LAYOUTS[`${skin.width}x${skin.height}`] : void 0;
+		if (sheet && base) {
+			const geometry = await models.load(`mobheads:item/base/${base}`).catch(() => null);
+			if (geometry) return renderModel(withTexture(geometry, "texture", sheet), textures, options);
+		}
 		return null;
 	}
-	if (name.includes("chest") && !name.includes("chestplate") || name.endsWith("_crate")) {
-		const variant = name.includes("ender") ? "ender" : name.includes("trapped") ? "trapped" : "normal";
+	if (searchName.includes("chest") && !searchName.includes("chestplate") || name.endsWith("_crate")) {
+		const variant = searchName.includes("ender") ? "ender" : searchName.includes("trapped") ? "trapped" : "normal";
 		const candidates = [[`renderchest:item/chest/${variant === "normal" ? "chest" : `${variant}_chest`}`, null], ["renderchest:item/chest", `minecraft:entity/chest/${variant}`]];
 		const modTexture = await findChestTexture(resources, locator.namespace, name);
 		for (const [modelPath, defaultTexture] of candidates) try {
@@ -277,11 +360,12 @@ async function renderEntityFallback(id, models, textures, resources, options) {
 			return null;
 		}
 	}
-	if (name.includes("shulker_box")) try {
-		const model = await models.load("renderchest:item/shulker_box");
-		return await renderModel(model, textures, options);
-	} catch {
-		return null;
+	if (searchName.includes("shulker") && !searchName.includes("shell")) {
+		const model = await models.load("renderchest:item/shulker_box").catch(() => null);
+		if (!model) return null;
+		const candidate = await findEntityTexture(resources, locator.namespace, name, "shulker");
+		const sheet = candidate && await coversSheet(textures, candidate) ? candidate : ResourceLocator.parse("minecraft:entity/shulker/shulker");
+		return renderModel(withTexture(model, "texture", sheet), textures, options).catch(() => null);
 	}
 	if (name.endsWith("banner")) try {
 		const model = await models.load("renderchest:item/banner");
@@ -292,7 +376,93 @@ async function renderEntityFallback(id, models, textures, resources, options) {
 	} catch {
 		return null;
 	}
+	if (name.includes("shield")) {
+		const model = await models.load("renderchest:item/shield").catch(() => null);
+		if (!model) return null;
+		const sheet = await findShieldTexture(resources, locator.namespace, name);
+		return renderModel(sheet ? withTexture(model, "texture", sheet) : model, textures, options);
+	}
+	if (name === "trident" || name.endsWith("_trident")) {
+		const model = await models.load("renderchest:item/trident").catch(() => null);
+		if (!model) return null;
+		const sheet = await findTridentTexture(resources, locator.namespace, name) ?? ResourceLocator.parse("minecraft:entity/trident");
+		return renderModel(withTexture(model, "texture", sheet), textures, {
+			...options,
+			quality: Math.max(options.quality, 4)
+		}).catch(() => null);
+	}
+	return null;
+}
+/**
+* Whether a sheet is a whole skin rather than an overlay. Vanilla's shulker
+* covers 44% of its sheet; a tier trim covers under 5%.
+*/
+async function coversSheet(textures, locator) {
+	const texture = await textures.load(locator).catch(() => null);
+	if (!texture) return false;
+	let opaque = 0;
+	for (let offset = 3; offset < texture.data.length; offset += 4) if (texture.data[offset] > 16) opaque++;
+	return opaque / (texture.width * texture.height) > .2;
+}
+/**
+* A mod's entity sheet for a kind, preferring the one its item name points at.
+* Not restricted to `entity/`: lootr files its whole-skin sheets straight under
+* `textures/` (`lootr:shulker`), and the caller gates on coverage anyway.
+*/
+async function findEntityTexture(resources, namespace, itemName, kind) {
+	const wanted = tokens(itemName).filter((token) => token !== kind && token !== "box");
+	let best = null;
+	let bestScore = -1;
+	for (const locator of await resources.listResources("texture", namespace)) {
+		if (!locator.path.includes(kind)) continue;
+		const candidate = tokens(locator.path);
+		let score = locator.path.startsWith("entity/") ? 1 : 0;
+		for (const token of wanted) if (candidate.includes(token)) score += 2;
+		if (score > bestScore) {
+			best = locator;
+			bestScore = score;
+		}
+	}
+	return best;
+}
+/**
+* A trident's entity sheet. Vanilla's is `entity/trident` (32×32) and mods
+* that reuse the vanilla model ship the same path under their own namespace;
+* a mod that names its sheet after the item instead (an `iron_trident` with
+* `entity/iron_trident`) is covered by the item-name fallback. Searches the
+* item's namespace first, then vanilla.
+*/
+async function findTridentTexture(resources, namespace, itemName) {
+	for (const source of [namespace, "minecraft"]) for (const candidate of [
+		"entity/trident",
+		"entity/trident/trident",
+		`entity/${itemName}`
+	]) {
+		const locator = new ResourceLocator(source, candidate);
+		if (await resources.hasResource("texture", locator)) return locator;
+	}
 	return null;
 }
+/**
+* A mod's shield face, scored by how much of the item name it accounts for.
+* `_blocking` is the raised pose rather than a different shield, and a
+* `_nopattern` sheet is the plain one a banner would otherwise decorate.
+*/
+async function findShieldTexture(resources, namespace, itemName) {
+	const wanted = tokens(itemName).filter((token) => token !== "shield" && token !== "blocking");
+	let best = null;
+	let bestScore = 0;
+	for (const locator of await resources.listResources("texture", namespace)) {
+		if (!locator.path.startsWith("entity/") || !locator.path.includes("shield")) continue;
+		const candidate = tokens(locator.path);
+		let score = candidate.includes("nopattern") ? 1 : 0;
+		for (const token of wanted) if (candidate.includes(token)) score += 2;
+		if (score > bestScore) {
+			best = locator;
+			bestScore = score;
+		}
+	}
+	return best;
+}
 //#endregion
-export { renderEntityFallback as n, spawnEggTints as r, renderDyedVariantFallback as t };
+export { spawnEggTints as a, renderEntityFallback as i, dyedVariantTint as n, renderDyedVariantFallback as r, dyeVariantName as t };

package/dist/{face-Cl1O4m2i.js → face-CMJ3b3Ae.js}

@@ -1,11 +1,20 @@
 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-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";
+import { a as scaleTextureAlpha, n as cloneFloatTexture, r as darkenTexture, s as tintTexture, u as uvWindow } from "./blend-KXMclcHk.js";
+import { a as drawTexturedTriangle, i as createFaceBuffer, n as clearFaceBuffer, o as phpRound, r as compactFaceBuffer, t as RowCursor } from "./rasterizer-DcVJzkxz.js";
 //#region src/render/face.ts
 /**
 * Face rendering: cull, transform, project, tint, darken, rasterize — a faithful
 * port of upstream Face::render (docs/research/renderchest-spec.md §4).
 */
+function createShadeCache() {
+	return {
+		byTexture: /* @__PURE__ */ new WeakMap(),
+		bytes: 0
+	};
+}
+/** Roughly a small sheet reused freely, or one large sheet and no more. */
+const MAX_SHADE_CACHE_BYTES = 67108864;
+const FLOAT_BYTES_PER_TEXEL = 32;
 function faceMaxZ(geometry) {
 	return Math.max(geometry.vertices[0][2], geometry.vertices[1][2], geometry.vertices[2][2], geometry.vertices[3][2]);
 }
@@ -54,19 +63,36 @@ function renderFace(face, width, height, transformation, scratch, shadeCache) {
 	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 darkness = geometry.emissive ? 0 : 1 - face.light.lightLevelForNormal(shadeDirection);
+	const [windowX1, windowY1, windowX2, windowY2] = uvWindow(face.texture, absU1, absV1, absU2, absV2);
+	let shading = {
+		tint,
+		darkness,
+		alpha: geometry.alpha,
+		windowX1,
+		windowY1,
+		windowX2,
+		windowY2
+	};
+	let texture = face.texture;
+	const shadeKey = `${tint ? `${tint.r},${tint.g},${tint.b}` : "-"}|${darkness}|${geometry.alpha}|${absU1},${absV1},${absU2},${absV2}`;
+	const byKey = shadeCache?.byTexture.get(face.texture);
+	const cached = byKey?.get(shadeKey);
+	const cloneBytes = face.texture.width * face.texture.height * FLOAT_BYTES_PER_TEXEL;
+	if (cached) {
+		texture = cached;
+		shading = null;
+	} else if (shadeCache && shadeCache.bytes + cloneBytes <= MAX_SHADE_CACHE_BYTES) {
+		const shaded = cloneFloatTexture(face.texture);
+		if (tint) tintTexture(shaded, tint.r, tint.g, tint.b);
+		darkenTexture(shaded, darkness, absU1, absV1, absU2, absV2);
+		if (geometry.alpha < 1) scaleTextureAlpha(shaded, geometry.alpha, absU1, absV1, absU2, absV2);
+		const store = byKey ?? /* @__PURE__ */ new Map();
+		store.set(shadeKey, shaded);
+		shadeCache.byTexture.set(face.texture, store);
+		shadeCache.bytes += cloneBytes;
+		texture = shaded;
+		shading = null;
 	}
 	const uvs = [
 		[geometry.uv1[0], geometry.uv1[1]],
@@ -97,9 +123,9 @@ function renderFace(face, width, height, transformation, scratch, shadeCache) {
 		};
 	};
 	const cursor = new RowCursor();
-	drawTexturedTriangle(point(0), point(2), point(3), buffer, texture, cursor);
-	drawTexturedTriangle(point(0), point(1), point(2), buffer, texture, cursor);
+	drawTexturedTriangle(point(0), point(2), point(3), buffer, texture, cursor, shading);
+	drawTexturedTriangle(point(0), point(1), point(2), buffer, texture, cursor, shading);
 	return compactFaceBuffer(buffer);
 }
 //#endregion
-export { renderFace as n, faceMaxZ as t };
+export { faceMaxZ as n, renderFace as r, createShadeCache as t };

package/dist/face-cQ-pVHoe.d.ts

@@ -0,0 +1,44 @@
+import { n as FloatTexture } from "./blend-8lnfxtLe.js";
+import { t as Mat4 } from "./vector-DRKRi4--.js";
+import { n as FaceGeometry } from "./geometry-w0yQbzDZ.js";
+import { r as LightSource } from "./lighting-3FGRC3Af.js";
+import { n as FaceBuffer } from "./rasterizer-BSQHEhJ-.js";
+//#region src/render/face.d.ts
+interface TintColor {
+  r: number;
+  g: number;
+  b: number;
+}
+interface RenderableFace {
+  geometry: FaceGeometry;
+  texture: FloatTexture;
+  light: LightSource;
+  tint: TintColor | null;
+  /** Untransformed model-space max Z — upstream's stable pre-sort key. */
+  maxZ: number;
+}
+/**
+ * Pre-shaded textures for one model render, with a byte ceiling.
+ *
+ * Shading a texel as it is sampled is always correct, but for a small sheet it
+ * is slower than shading one copy and reusing it: a block model's faces repeat
+ * the same few (window, light level) pairs, and there are far more drawn pixels
+ * than texels. The reverse holds for a detailed model on a big sheet — every
+ * face is its own key, and the copies are what once reached 20 GB for a single
+ * icon. So cache while it is cheap and fall through to per-sample shading once
+ * the budget is spent; the two produce identical output.
+ */
+interface FaceShadeCache {
+  byTexture: WeakMap<FloatTexture, Map<string, FloatTexture>>;
+  bytes: number;
+}
+declare function createShadeCache(): FaceShadeCache;
+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,
+/** Reused across a model's faces; cleared here, compacted before return. */
+scratch?: FaceBuffer,
+/** Bounded store of pre-shaded textures; omitted means always shade per sample. */
+shadeCache?: FaceShadeCache): FaceBuffer | null;
+//#endregion
+export { faceMaxZ as a, createShadeCache as i, RenderableFace as n, renderFace as o, TintColor as r, FaceShadeCache as t };

package/dist/{fluid-bucket-D-GpUQjg.js → fluid-bucket-BzoLofB_.js}

@@ -58,9 +58,14 @@ function averageColor(texture) {
 async function paintBucketFluid(bucket, fluid, textures, resources) {
 	const fluidLocator = ResourceLocator.tryParse(fluid);
 	if (!fluidLocator) return false;
+	const bare = fluidLocator.path.replace(/^fluid_/, "").replace(/_(?:still|flowing|source)$/, "");
+	const names = /* @__PURE__ */ new Set([fluidLocator.path, bare]);
 	let still = null;
-	for (const pattern of STILL_TEXTURE_PATTERNS) {
-		still = await textures.load(new ResourceLocator(fluidLocator.namespace, pattern(fluidLocator.path)));
+	for (const name of names) {
+		for (const pattern of STILL_TEXTURE_PATTERNS) {
+			still = await textures.load(new ResourceLocator(fluidLocator.namespace, pattern(name)));
+			if (still) break;
+		}
 		if (still) break;
 	}
 	still ??= resources ? await particleTexture(fluidLocator, textures, resources) : null;