@nodecraft/rendermite 0.0.1 → 1.0.1

package/assets/builtin-legacy/renderchest/models/item/shulker_box.json

@@ -0,0 +1,103 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [64, 64],
+	"gui_light": "side",
+	"elements": [
+		{
+			"name": "base",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"faces": {
+				"north": {"uv": [0, 12, 4, 13], "texture": "#texture"},
+				"east": {"uv": [12, 12, 16, 13], "texture": "#texture"},
+				"south": {"uv": [8, 12, 12, 13], "texture": "#texture"},
+				"west": {"uv": [4, 12, 8, 13], "texture": "#texture"},
+				"down": {"uv": [8, 7, 12, 11], "texture": "#texture"}
+			}
+		},
+		{
+			"name": "top",
+			"from": [0, 8, 0],
+			"to": [16, 16, 16],
+			"faces": {
+				"north": {"uv": [0, 4, 4, 6], "texture": "#texture"},
+				"east": {"uv": [12, 4, 16, 6], "texture": "#texture"},
+				"south": {"uv": [8, 4, 12, 6], "texture": "#texture"},
+				"west": {"uv": [4, 4, 8, 6], "texture": "#texture"},
+				"up": {"uv": [4, 0, 8, 4], "texture": "#texture"}
+			}
+		},
+		{
+			"name": "middle1",
+			"from": [0, 4, 4],
+			"to": [16, 8, 12],
+			"faces": {
+				"east": {"uv": [13, 11, 15, 12], "texture": "#texture"},
+				"west": {"uv": [5, 11, 7, 12], "texture": "#texture"}
+			}
+		},
+		{
+			"name": "middle2",
+			"from": [4, 4, 0],
+			"to": [12, 8, 16],
+			"faces": {
+				"north": {"uv": [1, 11, 3, 12], "texture": "#texture"},
+				"south": {"uv": [9, 11, 11, 12], "texture": "#texture"}
+			}
+		},
+		{
+			"name": "pil1",
+			"from": [12, 4, 12],
+			"to": [16, 8, 16],
+			"faces": {
+				"east": {"uv": [12, 6, 13, 7], "texture": "#texture"},
+				"south": {"uv": [11, 6, 12, 7], "texture": "#texture"}
+			}
+		},
+		{
+			"name": "pil2",
+			"from": [0, 4, 12],
+			"to": [4, 8, 16],
+			"faces": {
+				"south": {"uv": [8, 6, 9, 7], "texture": "#texture"},
+				"west": {"uv": [7, 6, 8, 7], "texture": "#texture"}
+			}
+		},
+		{
+			"name": "pil3",
+			"from": [0, 4, 0],
+			"to": [4, 8, 4],
+			"faces": {
+				"north": {"uv": [3, 6, 4, 7], "texture": "#texture"},
+				"west": {"uv": [4, 6, 5, 7], "texture": "#texture"}
+			}
+		},
+		{
+			"name": "pil4",
+			"from": [12, 4, 0],
+			"to": [16, 8, 4],
+			"faces": {
+				"north": {"uv": [0, 6, 1, 7], "texture": "#texture"},
+				"east": {"uv": [15, 6, 16, 7], "texture": "#texture"}
+			}
+		},
+		{
+			"from": [0.1, 0.1, 0.1],
+			"to": [15.9, 15.9, 15.9],
+			"faces": {
+				"north": {"uv": [4, 0, 8, 4], "texture": "#texture"},
+				"east": {"uv": [4, 0, 8, 4], "texture": "#texture"},
+				"south": {"uv": [4, 0, 8, 4], "texture": "#texture"},
+				"west": {"uv": [4, 0, 8, 4], "texture": "#texture"},
+				"up": {"uv": [4, 0, 8, 4], "texture": "#texture"},
+				"down": {"uv": [4, 0, 8, 4], "texture": "#texture"}
+			}
+		}
+	],
+	"display": {
+		"gui": {
+			"rotation": [30, -45, 0],
+			"scale": [0.625, 0.625, 0.625]
+		}
+	}
+}

package/assets/builtin-legacy/renderchest/models/item/unknown.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "renderchest:item/unknown"
+  }
+}

package/dist/atlas/registry.d.ts

@@ -0,0 +1,8 @@
+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";
+//#region src/atlas/registry.d.ts
+declare function loadAtlasResolver(resources: ResourceManager, loadTexture: (locator: ResourceLocator) => Promise<Texture | null>, onWarning?: (message: string) => void): Promise<AtlasResolver>;
+//#endregion
+export { loadAtlasResolver };

package/dist/atlas/registry.js

@@ -0,0 +1,2 @@
+import { t as loadAtlasResolver } from "../registry-C9E7jyzG.js";
+export { loadAtlasResolver };

package/dist/atlas/sources.d.ts

@@ -0,0 +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";
+export { AtlasResolver, AtlasSource, AtlasSourceError, DirectoryAtlasSource, HasTexture, PalettedPermutationsSource, ResolvedSprite, SingleAtlasSource, UnstitchAtlasSource, createAtlasResolver, parseAtlasSources };

package/dist/atlas/sources.js

@@ -0,0 +1,2 @@
+import { a as UnstitchAtlasSource, i as SingleAtlasSource, n as DirectoryAtlasSource, o as createAtlasResolver, r as PalettedPermutationsSource, s as parseAtlasSources, t as AtlasSourceError } from "../sources-Bxk-WOzH.js";
+export { AtlasSourceError, DirectoryAtlasSource, PalettedPermutationsSource, SingleAtlasSource, UnstitchAtlasSource, createAtlasResolver, parseAtlasSources };

package/dist/blend-CHP2-j9U.js

@@ -0,0 +1,90 @@
+//#region src/render/blend.ts
+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;
+	return {
+		width: texture.width,
+		height: texture.height,
+		data
+	};
+}
+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);
+	}
+	return {
+		width: texture.width,
+		height: texture.height,
+		data
+	};
+}
+function cloneFloatTexture(texture) {
+	return {
+		width: texture.width,
+		height: texture.height,
+		data: new Float64Array(texture.data)
+	};
+}
+/**
+* Imagick stores every pixel write as a Q16 quantum; values re-read for the
+* next operation carry that quantization. Matching it is what turns
+* off-by-one downscale rounding into exact parity.
+*/
+function q16(value) {
+	return Math.round((value < 0 ? 0 : Math.min(value, 1)) * 65535) / 65535;
+}
+/**
+* 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.
+*/
+function blendPixel(dst, offset, sr, sg, sb, sa) {
+	const da = dst[offset + 3];
+	const ra = 1 - (1 - sa) * (1 - da);
+	if (ra === 0) {
+		dst[offset] = 0;
+		dst[offset + 1] = 0;
+		dst[offset + 2] = 0;
+		dst[offset + 3] = 0;
+		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);
+}
+/**
+* Upstream tintImage: uses ONLY the red channel as luminance — per pixel,
+* source-over blend of {tint.rgb * pixel.r, alpha: pixel.a} onto the pixel.
+*/
+function tintTexture(texture, tintR, tintG, tintB) {
+	const { data } = texture;
+	for (let offset = 0; offset < data.length; offset += 4) {
+		const value = data[offset];
+		blendPixel(data, offset, tintR * value, tintG * value, tintB * value, data[offset + 3]);
+	}
+}
+/**
+* Upstream darkenTexture: blend pure black with alpha = amount * pixel.alpha,
+* restricted to the UV bounding box expanded by 1px on each side.
+*/
+function darkenTexture(texture, amount, u1, v1, u2, v2) {
+	let startX = Math.floor(Math.min(u1, u2));
+	let endX = Math.ceil(Math.max(u1, u2));
+	let startY = Math.floor(Math.min(v1, v2));
+	let endY = Math.ceil(Math.max(v1, v2));
+	startX = Math.max(0, startX - 1);
+	startY = Math.max(0, startY - 1);
+	endX = Math.min(texture.width - 1, endX + 1);
+	endY = Math.min(texture.height - 1, endY + 1);
+	const { data } = texture;
+	for (let y = startY; y <= endY; y++) for (let x = startX; x <= endX; x++) {
+		const offset = (y * texture.width + x) * 4;
+		blendPixel(data, offset, 0, 0, 0, amount * data[offset + 3]);
+	}
+}
+//#endregion
+export { tintTexture as a, q16 as i, cloneFloatTexture as n, toByteTexture as o, darkenTexture as r, toFloatTexture as s, blendPixel as t };

package/dist/blend-Qvrn6YgK.d.ts

@@ -0,0 +1,36 @@
+import { r as Texture } from "./loader-TFFNV4Jl.js";
+//#region src/render/blend.d.ts
+/** RGBA float pixels for render-time work; converted back to 8-bit at encode. */
+interface FloatTexture {
+  width: number;
+  height: number;
+  /** RGBA, row-major, normalized [0,1]. */
+  data: Float64Array;
+}
+declare function toFloatTexture(texture: Texture): FloatTexture;
+declare function toByteTexture(texture: FloatTexture): Texture;
+declare function cloneFloatTexture(texture: FloatTexture): FloatTexture;
+/**
+ * Imagick stores every pixel write as a Q16 quantum; values re-read for the
+ * next operation carry that quantization. Matching it is what turns
+ * off-by-one downscale rounding into exact parity.
+ */
+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.
+ */
+declare function blendPixel(dst: Float64Array, offset: number, sr: number, sg: number, sb: number, sa: number): void;
+/**
+ * Upstream tintImage: uses ONLY the red channel as luminance — per pixel,
+ * source-over blend of {tint.rgb * pixel.r, alpha: pixel.a} onto the pixel.
+ */
+declare function tintTexture(texture: FloatTexture, tintR: number, tintG: number, tintB: number): void;
+/**
+ * Upstream darkenTexture: blend pure black with alpha = amount * pixel.alpha,
+ * restricted to the UV bounding box expanded by 1px on each side.
+ */
+declare function darkenTexture(texture: FloatTexture, amount: number, u1: number, v1: number, u2: number, v2: number): void;
+//#endregion
+export { q16 as a, toFloatTexture as c, darkenTexture as i, blendPixel as n, tintTexture as o, cloneFloatTexture as r, toByteTexture as s, FloatTexture as t };

package/dist/builtin-C8GZEN40.js

@@ -0,0 +1,16 @@
+import path from "node:path";
+//#region src/builtin.ts
+/**
+* Paths to the vendored builtin packs (see assets/README.md). Resolved
+* relative to this package so library consumers and tests never hardcode
+* machine-specific locations.
+*/
+const assetsRoot = path.join(import.meta.dirname, "..", "assets");
+function builtinPackPath(era) {
+	return path.join(assetsRoot, era === "modern" ? "builtin" : "builtin-legacy");
+}
+function bedCompatPath() {
+	return path.join(assetsRoot, "builtin-bed-compat");
+}
+//#endregion
+export { builtinPackPath as n, bedCompatPath as t };

package/dist/builtin.d.ts

@@ -0,0 +1,5 @@
+//#region src/builtin.d.ts
+declare function builtinPackPath(era: 'modern' | 'legacy'): string;
+declare function bedCompatPath(): string;
+//#endregion
+export { bedCompatPath, builtinPackPath };

package/dist/builtin.js

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

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/cli.js

@@ -0,0 +1,174 @@
+#!/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-Dr6BfyN9.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 path from "node:path";
+import os from "node:os";
+import { parseArgs } from "node:util";
+//#region src/cli.ts
+/**
+* CLI mirroring renderchest's flag surface, plus what the PHP tool never had:
+* `--version 1.21.8` downloads the client jar, prepares era-appropriate layers
+* (donor geometry, legacy reshaping, bed compat), and picks the right builtin
+* pack — one command from nothing to icons for any version back to 1.2.5.
+*/
+const { values } = parseArgs({ options: {
+	"assets": {
+		type: "string",
+		short: "a",
+		multiple: true
+	},
+	"version": {
+		type: "string",
+		short: "v"
+	},
+	"mod": {
+		type: "string",
+		short: "m",
+		multiple: true
+	},
+	"namespace": {
+		type: "string",
+		short: "n",
+		multiple: true
+	},
+	"output": {
+		type: "string",
+		short: "o"
+	},
+	"size": {
+		type: "string",
+		short: "s",
+		default: "64"
+	},
+	"quality": {
+		type: "string",
+		short: "q",
+		default: "2"
+	},
+	"prefix": {
+		type: "string",
+		short: "p",
+		default: "rc-"
+	},
+	"format": {
+		type: "string",
+		short: "f",
+		default: "webp"
+	},
+	"fallback": {
+		type: "boolean",
+		default: false
+	},
+	"gif": {
+		type: "boolean",
+		default: false
+	},
+	"avif": {
+		type: "boolean",
+		default: false
+	},
+	"item-list": {
+		type: "boolean",
+		short: "i",
+		default: false
+	},
+	"lighting-profile": {
+		type: "string",
+		default: "modern"
+	},
+	"builtin": { type: "string" },
+	"cache-dir": { type: "string" },
+	"concurrency": { type: "string" },
+	"help": {
+		type: "boolean",
+		short: "h",
+		default: false
+	}
+} });
+const hasInput = Boolean(values.assets?.length || values.version);
+if (values.help || !hasInput || !values.output) {
+	console.log(`rendermite — Minecraft item icon renderer
+
+Usage:
+  rendermite --version <mc version> --output <dir> [options]
+  rendermite --assets <dir> [--assets <dir> ...] --output <dir> [options]
+
+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)
+
+Options:
+  -n, --namespace <ns>     namespace to render (repeatable, default: minecraft)
+  -o, --output <dir>       output directory
+  -s, --size <px>          icon size (default 64)
+  -q, --quality <n>        supersample factor (default 2)
+  -p, --prefix <prefix>    CSS class/file prefix (default rc-)
+  -f, --format <fmt>       primary image format: webp|avif (default webp)
+      --fallback           emit PNG base rules + @media upgrade block
+      --gif                also emit animated GIFs for legacy browsers
+      --avif               also emit AVIF
+  -i, --item-list          write the rendered item id list JSON
+      --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)
+`);
+	process.exit(values.help ? 0 : 1);
+}
+const cacheDir = values["cache-dir"] ?? path.join(os.homedir(), ".rendermite");
+let resources;
+let builtin = values.builtin;
+if (values.version) {
+	const era = eraForVersion(values.version);
+	console.log(`Fetching client jar for ${values.version}…`);
+	const jar = await downloadClientJar(values.version, cacheDir);
+	const donors = {};
+	if ([
+		"preModels",
+		"legacyFiles",
+		"legacySheets"
+	].includes(era)) for (const donor of GEOMETRY_DONOR_VERSIONS) donors[donor] = await downloadClientJar(donor, cacheDir);
+	const referenceJar = era === "legacyFiles" || era === "legacySheets" ? await downloadClientJar("1.6.4", cacheDir) : void 0;
+	resources = await prepareVersionResources({
+		version: values.version,
+		jar,
+		donors,
+		referenceJar,
+		bedCompat: bedCompatPath()
+	});
+	builtin ??= builtinPackPath(era === "modern" ? "modern" : "legacy");
+} else {
+	const managers = (values.assets ?? []).map((root) => new FolderResourceManager(root));
+	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))]);
+const result = await run({
+	resources,
+	builtin,
+	output: values.output,
+	namespaces: values.namespace?.length ? values.namespace : void 0,
+	size: Number(values.size),
+	quality: Number(values.quality),
+	prefix: values.prefix,
+	format: values.format === "avif" ? "avif" : "webp",
+	fallback: values.fallback,
+	gif: values.gif,
+	avif: values.avif,
+	concurrency: values.concurrency ? Number(values.concurrency) : void 0,
+	lightingProfile: values["lighting-profile"] === "legacy" ? "legacy" : "modern",
+	itemList: values["item-list"],
+	onProgress: (done, total, id, error) => {
+		if (error) console.error(`Failed ${done}/${total}: ${id} (${error})`);
+		else if (done % 200 === 0 || done === total) console.log(`Rendered ${done}/${total}`);
+	}
+});
+console.log(`\nRendered ${result.rendered.length} items (${result.spriteFallbacks.length} sprite fallbacks), ${result.failed.length} failed, ${result.writtenFiles} files written.`);
+if (result.failed.length > 0) process.exitCode = 2;
+//#endregion
+export {};

package/dist/compose-cph4bfdr.js

@@ -0,0 +1,27 @@
+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.
+*/
+function combineFaceBuffers(width, height, faces) {
+	const out = new Float64Array(width * height * 4);
+	const order = [...faces];
+	for (let pixel = 0; pixel < width * height; pixel++) {
+		order.sort((a, b) => a.depths[pixel] - b.depths[pixel]);
+		const offset = pixel * 4;
+		for (const face of order) {
+			const alpha = face.colors[offset + 3];
+			if (alpha > 0) blendPixel(out, offset, face.colors[offset], face.colors[offset + 1], face.colors[offset + 2], alpha);
+		}
+	}
+	return {
+		width,
+		height,
+		data: out
+	};
+}
+//#endregion
+export { combineFaceBuffers as t };

package/dist/definition-3MBm8ar_.js

@@ -0,0 +1,117 @@
+import { i as fromItemTransform, o as identity, s as multiply } from "./vector-CCxLae_T.js";
+//#region src/items/definition.ts
+/**
+* 1.21.4+ item-definition (`assets/<ns>/items/*.json`) evaluation for a static
+* GUI icon, mirroring upstream's Item classes and property defaults
+* (docs/research/renderchest-spec.md §3).
+*/
+var InvalidItemDefinitionError = class extends Error {};
+/**
+* Property values renderchest assumes when rendering a static gui icon.
+* Conditions are false except view_entity; numbers 0; strings per table.
+*/
+const CONDITION_DEFAULTS = { "minecraft:view_entity": true };
+const STRING_DEFAULTS = {
+	"minecraft:main_hand": "right",
+	"minecraft:charge_type": "none",
+	"minecraft:trim_material": "none",
+	"minecraft:block_state": "",
+	"minecraft:display_context": "gui",
+	"minecraft:local_time": "",
+	"minecraft:context_dimension": "minecraft:overworld",
+	"minecraft:context_entity_type": "minecraft:player"
+};
+function defaultProperties() {
+	return {
+		conditions: /* @__PURE__ */ new Map(),
+		strings: /* @__PURE__ */ new Map(),
+		numbers: /* @__PURE__ */ new Map()
+	};
+}
+function normalizeKey(property) {
+	return property.includes(":") ? property : `minecraft:${property}`;
+}
+function conditionValue(properties, property) {
+	const key = normalizeKey(property);
+	return properties.conditions.get(key) ?? CONDITION_DEFAULTS[key] ?? false;
+}
+function stringValue(properties, property) {
+	const key = normalizeKey(property);
+	return properties.strings.get(key) ?? STRING_DEFAULTS[key] ?? "";
+}
+function numberValue(properties, property) {
+	const key = normalizeKey(property);
+	return properties.numbers.get(key) ?? 0;
+}
+/** Model locator upstream falls back to when select/range_dispatch have no fallback. */
+const UNKNOWN_MODEL = "renderchest:item/unknown";
+function selectPropertyValue(properties, property) {
+	const key = normalizeKey(property);
+	if (properties.numbers.has(key)) return properties.numbers.get(key) ?? 0;
+	if (properties.conditions.has(key)) return properties.conditions.get(key) ?? false;
+	return stringValue(properties, property);
+}
+/**
+* Evaluate a definition's `model` node into the flat list of models to render,
+* in composite order. An empty list means a fully transparent icon.
+*/
+function evaluateItemModel(node, properties = defaultProperties(), parentTransform = identity()) {
+	if (typeof node !== "object" || node === null) throw new InvalidItemDefinitionError("Item model node is not an object");
+	const item = node;
+	const transform = item.transformation === void 0 ? parentTransform : multiply(parentTransform, fromItemTransform(item.transformation));
+	switch (normalizeKey(typeof item.type === "string" ? item.type : "")) {
+		case "minecraft:model": {
+			if (typeof item.model !== "string") throw new InvalidItemDefinitionError("minecraft:model without a model locator");
+			const tints = Array.isArray(item.tints) ? item.tints : [];
+			return [{
+				model: item.model,
+				tints,
+				transform
+			}];
+		}
+		case "minecraft:composite": return (Array.isArray(item.models) ? item.models : []).flatMap((child) => evaluateItemModel(child, properties, transform));
+		case "minecraft:condition":
+			if (typeof item.property !== "string" || item.on_true === void 0 || item.on_false === void 0) throw new InvalidItemDefinitionError("minecraft:condition missing property/on_true/on_false");
+			return evaluateItemModel(conditionValue(properties, item.property) ? item.on_true : item.on_false, properties, transform);
+		case "minecraft:select": {
+			if (typeof item.property !== "string") throw new InvalidItemDefinitionError("minecraft:select missing property");
+			const value = selectPropertyValue(properties, item.property);
+			const cases = Array.isArray(item.cases) ? item.cases : [];
+			for (const entry of cases) if ((Array.isArray(entry.when) ? entry.when : [entry.when]).some((candidate) => candidate == value)) return evaluateItemModel(entry.model, properties, transform);
+			if (item.fallback !== void 0) return evaluateItemModel(item.fallback, properties, transform);
+			return [{
+				model: UNKNOWN_MODEL,
+				tints: [],
+				transform
+			}];
+		}
+		case "minecraft:range_dispatch": {
+			if (typeof item.property !== "string") throw new InvalidItemDefinitionError("minecraft:range_dispatch missing property");
+			const scale = typeof item.scale === "number" ? item.scale : 1;
+			const value = numberValue(properties, item.property) * scale;
+			const entries = Array.isArray(item.entries) ? item.entries : [];
+			for (const entry of entries) if (value >= (entry.threshold ?? 0)) return evaluateItemModel(entry.model, properties, transform);
+			if (item.fallback !== void 0) return evaluateItemModel(item.fallback, properties, transform);
+			return [{
+				model: UNKNOWN_MODEL,
+				tints: [],
+				transform
+			}];
+		}
+		case "minecraft:special":
+			if (typeof item.base === "string") {
+				const tints = Array.isArray(item.tints) ? item.tints : [];
+				return [{
+					model: item.base,
+					tints,
+					transform
+				}];
+			}
+			return [];
+		case "minecraft:empty":
+		case "minecraft:bundle/selected_item": return [];
+		default: throw new InvalidItemDefinitionError(`Unknown item model type: ${String(item.type)}`);
+	}
+}
+//#endregion
+export { defaultProperties as a, UNKNOWN_MODEL as i, InvalidItemDefinitionError as n, evaluateItemModel as o, STRING_DEFAULTS as r, CONDITION_DEFAULTS as t };

package/dist/definition-BwX6Xxv0.d.ts

@@ -0,0 +1,34 @@
+import { t as Mat4 } from "./vector-DRKRi4--.js";
+//#region src/items/definition.d.ts
+declare class InvalidItemDefinitionError extends Error {}
+/** One model to render; a definition may yield several (composite), blended in order. */
+interface ItemRenderInstruction {
+  model: string;
+  tints: TintDefinition[];
+  transform: Mat4;
+}
+interface TintDefinition {
+  type: string;
+  [key: string]: unknown;
+}
+/**
+ * Property values renderchest assumes when rendering a static gui icon.
+ * Conditions are false except view_entity; numbers 0; strings per table.
+ */
+declare const CONDITION_DEFAULTS: Record<string, boolean>;
+declare const STRING_DEFAULTS: Record<string, string>;
+interface ItemProperties {
+  conditions: Map<string, boolean>;
+  strings: Map<string, string>;
+  numbers: Map<string, number>;
+}
+declare function defaultProperties(): ItemProperties;
+/** Model locator upstream falls back to when select/range_dispatch have no fallback. */
+declare const UNKNOWN_MODEL = "renderchest:item/unknown";
+/**
+ * Evaluate a definition's `model` node into the flat list of models to render,
+ * in composite order. An empty list means a fully transparent icon.
+ */
+declare function evaluateItemModel(node: unknown, properties?: ItemProperties, parentTransform?: Mat4): ItemRenderInstruction[];
+//#endregion
+export { STRING_DEFAULTS as a, defaultProperties as c, ItemRenderInstruction as i, evaluateItemModel as l, InvalidItemDefinitionError as n, TintDefinition as o, ItemProperties as r, UNKNOWN_MODEL as s, CONDITION_DEFAULTS as t };