@nodecraft/rendermite 0.0.1 → 1.0.1

package/dist/discovery-BzaOti7l.js

@@ -0,0 +1,91 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import { o as identity } from "./vector-CCxLae_T.js";
+import { o as evaluateItemModel } from "./definition-3MBm8ar_.js";
+//#region src/items/discovery.ts
+/**
+* Era-adaptive item discovery — the piece no single renderchest tag has:
+* 1.21.4+ `items/*.json` definitions when a namespace ships them, otherwise the
+* classic `models/item/*.json` scan (v2.5.2 behavior). Both yield item ids of
+* the form `<ns>:<name>`.
+*/
+var ItemResolutionError = class extends Error {};
+async function discoverItems(resources, namespace) {
+	const seen = /* @__PURE__ */ new Set();
+	const items = [];
+	for (const locator of await resources.listResources("itemDefinition", namespace)) {
+		const id = locator.toString();
+		if (!seen.has(id)) {
+			seen.add(id);
+			items.push({
+				id,
+				source: "definition"
+			});
+		}
+	}
+	const registered = namespace === "minecraft" ? null : await langRegistry(resources, namespace);
+	for (const locator of await resources.listResources("model", namespace)) {
+		if (!locator.path.startsWith("item/")) continue;
+		const name = locator.path.slice(5);
+		if (registered && !registered.has(name.replaceAll("/", ".")) && !name.endsWith("_trim")) continue;
+		const id = new ResourceLocator(locator.namespace, name).toString();
+		if (!seen.has(id)) {
+			seen.add(id);
+			items.push({
+				id,
+				source: "model"
+			});
+		}
+	}
+	return items;
+}
+/**
+* Item/block names with a translation key in the namespace's en_us.json — the
+* closest thing to the game's item registry a jar contains (datagen writes a
+* key per registered item). Null (no gating) when the namespace has no modern
+* lang file or no item/block keys: 1.7.10-era mods use unkeyed .lang files.
+*/
+async function langRegistry(resources, namespace) {
+	const raw = await resources.getResource("lang", new ResourceLocator(namespace, "en_us"));
+	if (!raw) return null;
+	let lang;
+	try {
+		lang = JSON.parse(raw.toString("utf8"));
+	} catch {
+		return null;
+	}
+	const names = /* @__PURE__ */ new Set();
+	const prefixes = [`item.${namespace}.`, `block.${namespace}.`];
+	for (const key of Object.keys(lang)) for (const prefix of prefixes) if (key.startsWith(prefix)) {
+		names.add(key.slice(prefix.length));
+		break;
+	}
+	return names.size > 0 ? names : null;
+}
+/**
+* Resolve an item id to the models to render. Definitions are evaluated with
+* static-icon properties; plain model items render the model with no tints
+* (legacy hard-coded tint tables are layered on by the caller for old eras).
+*/
+async function resolveItem(resources, id, properties) {
+	const locator = ResourceLocator.parse(id);
+	const definition = await resources.getResource("itemDefinition", locator);
+	if (definition !== null) {
+		let parsed;
+		try {
+			parsed = JSON.parse(definition.toString("utf8"));
+		} catch {
+			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);
+	}
+	const modelLocator = new ResourceLocator(locator.namespace, `item/${locator.path}`);
+	if (await resources.hasResource("model", modelLocator)) return [{
+		model: modelLocator.toString(),
+		tints: [],
+		transform: identity()
+	}];
+	throw new ItemResolutionError(`No item definition or item model for ${id}`);
+}
+//#endregion
+export { discoverItems as n, resolveItem as r, ItemResolutionError as t };

package/dist/discovery-CmNYzKPr.d.ts

@@ -0,0 +1,18 @@
+import { a as ResourceManager } from "./manager-CoZaeQTu.js";
+import { i as ItemRenderInstruction, r as ItemProperties } from "./definition-BwX6Xxv0.js";
+//#region src/items/discovery.d.ts
+declare class ItemResolutionError extends Error {}
+interface DiscoveredItem {
+  /** Output id, e.g. `minecraft:stone`. */
+  id: string;
+  source: 'definition' | 'model';
+}
+declare function discoverItems(resources: ResourceManager, namespace: string): Promise<DiscoveredItem[]>;
+/**
+ * Resolve an item id to the models to render. Definitions are evaluated with
+ * static-icon properties; plain model items render the model with no tints
+ * (legacy hard-coded tint tables are layered on by the caller for old eras).
+ */
+declare function resolveItem(resources: ResourceManager, id: string, properties?: ItemProperties): Promise<ItemRenderInstruction[]>;
+//#endregion
+export { resolveItem as i, ItemResolutionError as n, discoverItems as r, DiscoveredItem as t };

package/dist/download-D9aARBFp.js

@@ -0,0 +1,34 @@
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+//#region src/versions/download.ts
+/**
+* Client jar acquisition: resolves versions through mcversions.net's index
+* (stable + snapshot channels) and downloads from Mojang, caching by version.
+* Shared by the CLI's --version flag and the test fixtures.
+*/
+async function downloadClientJar(version, cacheDir) {
+	const jarPath = path.join(cacheDir, `${version}-client.jar`);
+	if (existsSync(jarPath)) return jarPath;
+	await mkdir(cacheDir, { recursive: true });
+	const indexPath = path.join(cacheDir, "mcversions.json");
+	let index;
+	if (existsSync(indexPath)) index = JSON.parse(await readFile(indexPath, "utf8"));
+	else {
+		const response = await fetch("https://mcversions.net/mcversions.json");
+		if (!response.ok) throw new Error(`mcversions.net index fetch failed: ${response.status}`);
+		const body = Buffer.from(await response.arrayBuffer());
+		await writeFile(indexPath, body);
+		index = JSON.parse(body.toString("utf8"));
+	}
+	const entry = index.stable[version] ?? index.snapshot[version];
+	if (!entry) throw new Error(`Version ${version} not found in the mcversions index`);
+	const download = await fetch(entry.client);
+	if (!download.ok) throw new Error(`Client jar download failed for ${version}: ${download.status}`);
+	const partial = `${jarPath}.partial`;
+	await writeFile(partial, Buffer.from(await download.arrayBuffer()));
+	await rename(partial, jarPath);
+	return jarPath;
+}
+//#endregion
+export { downloadClientJar as t };

package/dist/dynamic/generators.d.ts

@@ -0,0 +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";
+export { ARMOR_ITEM_TYPES, DynamicItem, DynamicResources, POTTERY_SHERDS, TRIM_DARKER_MATERIALS, TRIM_MATERIALS, builtinDynamicResources };

package/dist/dynamic/generators.js

@@ -0,0 +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";
+export { ARMOR_ITEM_TYPES, POTTERY_SHERDS, TRIM_DARKER_MATERIALS, TRIM_MATERIALS, builtinDynamicResources };

package/dist/encode-3u49i-eD.js

@@ -0,0 +1,108 @@
+import { o as toByteTexture } from "./blend-CHP2-j9U.js";
+import sharp from "sharp";
+//#region src/output/encode.ts
+/**
+* Icon encoding via sharp. Defaults reproduce the ui pipeline's post-pass so no
+* separate optimization step is needed: lossless everywhere, strictly-smaller
+* candidates only.
+*/
+/** Losslessly transcode an existing PNG resource into the formats referenced by generated CSS. */
+async function encodeRasterAsset(source, formats) {
+	const image = sharp(source);
+	const unique = [...new Set(formats)];
+	const encoded = await Promise.all(unique.map(async (format) => {
+		switch (format) {
+			case "png": return [format, await image.clone().png({
+				compressionLevel: 9,
+				effort: 10
+			}).toBuffer()];
+			case "webp": return [format, await image.clone().webp({
+				lossless: true,
+				effort: 6
+			}).toBuffer()];
+			case "avif": return [format, await image.clone().avif({
+				lossless: true,
+				effort: 6
+			}).toBuffer()];
+		}
+	}));
+	return new Map(encoded);
+}
+/**
+* Encode a multi-frame icon: animated WebP (universal), optional GIF for
+* legacy browsers, PNG as the static first frame (matching upstream's
+* fallback), and AVIF animated where the local libvips supports it —
+* otherwise a static first frame.
+*/
+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 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,
+		loop: 0,
+		delay: delaysMs
+	}).toBuffer();
+	if (options.gif) result.gif = await animated().gif({
+		loop: 0,
+		delay: delaysMs
+	}).toBuffer();
+	if (options.avif) try {
+		result.avif = await animated().avif({
+			lossless: true,
+			effort: 6
+		}).toBuffer();
+		result.avifAnimated = true;
+	} catch {
+		result.avif = (await encodeIcon(frames[0], {
+			webp: false,
+			avif: true
+		})).avif;
+		result.avifAnimated = false;
+	}
+	return result;
+}
+/** Distinct RGBA colors, up to a cap (palette PNGs hold at most 256). */
+function countColors(data, cap) {
+	const seen = /* @__PURE__ */ new Set();
+	for (let offset = 0; offset < data.length; offset += 4) {
+		seen.add(((data[offset] * 256 + data[offset + 1]) * 256 + data[offset + 2]) * 256 + data[offset + 3]);
+		if (seen.size > cap) return seen.size;
+	}
+	return seen.size;
+}
+async function encodeIcon(texture, options = {}) {
+	const bytes = toByteTexture(texture);
+	const raw = sharp(Buffer.from(bytes.data.buffer, bytes.data.byteOffset, bytes.data.length), { raw: {
+		width: bytes.width,
+		height: bytes.height,
+		channels: 4
+	} });
+	const paletteSafe = countColors(bytes.data, 256) <= 256;
+	const result = { png: await 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({
+		lossless: true,
+		effort: 6
+	}).toBuffer();
+	return result;
+}
+//#endregion
+export { encodeIcon as n, encodeRasterAsset as r, encodeAnimatedIcon as t };

package/dist/encode-C5kdAm45.d.ts

@@ -0,0 +1,34 @@
+import { t as FloatTexture } from "./blend-Qvrn6YgK.js";
+//#region src/output/encode.d.ts
+interface EncodedIcon {
+  png: Buffer;
+  webp?: Buffer;
+  avif?: Buffer;
+}
+interface EncodeOptions {
+  webp?: boolean;
+  /** Off by default: measure size/time before enabling — 64px icons rarely benefit. */
+  avif?: boolean;
+}
+interface EncodedAnimatedIcon extends EncodedIcon {
+  /** GIF for legacy browsers, only produced for animated icons. */
+  gif?: Buffer;
+  /** Whether the avif buffer carries the animation or fell back to frame 0. */
+  avifAnimated?: boolean;
+}
+interface AnimatedEncodeOptions extends EncodeOptions {
+  gif?: boolean;
+}
+type RasterAssetFormat = 'png' | 'webp' | 'avif';
+/** Losslessly transcode an existing PNG resource into the formats referenced by generated CSS. */
+declare function encodeRasterAsset(source: Buffer, formats: readonly RasterAssetFormat[]): Promise<Map<RasterAssetFormat, Buffer>>;
+/**
+ * Encode a multi-frame icon: animated WebP (universal), optional GIF for
+ * legacy browsers, PNG as the static first frame (matching upstream's
+ * fallback), and AVIF animated where the local libvips supports it —
+ * otherwise a static first frame.
+ */
+declare function encodeAnimatedIcon(frames: FloatTexture[], delaysMs: number[], options?: AnimatedEncodeOptions): Promise<EncodedAnimatedIcon>;
+declare function encodeIcon(texture: FloatTexture, options?: EncodeOptions): Promise<EncodedIcon>;
+//#endregion
+export { RasterAssetFormat as a, encodeRasterAsset as c, EncodedIcon as i, EncodeOptions as n, encodeAnimatedIcon as o, EncodedAnimatedIcon as r, encodeIcon as s, AnimatedEncodeOptions as t };

package/dist/entity-fallback-CodtI6v8.js

@@ -0,0 +1,265 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import { i as renderModel } from "./renderer-CmOz6WI9.js";
+//#region src/render/entity-fallback.ts
+/**
+* Heuristic rendering for mod items that parent `builtin/entity` — chests,
+* mob heads, banners, shulker boxes drawn by Java code in-game. The sweep
+* found 351 of these across the top mods (quark's lootr chests, spectrum's
+* mob heads, deeperdarker's chests). We map them onto the builtin geometry by
+* name, preferring the mod's own entity texture when one matches; a generic
+* chest icon for a chest item beats no icon, but nothing here ever guesses
+* across item kinds.
+*/
+/** Tokens too generic to identify a texture on their own. */
+const FILLER_TOKENS = /* @__PURE__ */ new Set([
+	"chest",
+	"chests",
+	"trapped",
+	"big",
+	"small",
+	"the",
+	"of"
+]);
+/** Double-chest halves, lid states, boat sheets, seasonal skins — never icon textures. */
+const SKIP_TOKENS = /* @__PURE__ */ new Set([
+	"left",
+	"right",
+	"open",
+	"opened",
+	"christmas",
+	"boat",
+	"raft",
+	"minecart"
+]);
+function tokens(name) {
+	return name.split(/[./_]/).filter((token) => token.length > 1);
+}
+/**
+* Find the mod's own chest sheet for a chest-like item by token overlap over
+* the FULL texture path — mods keep variant sheets in per-wood directories
+* (quark's `quark_variant_chests/acacia/normal.png`), not just under entity/.
+*/
+async function findChestTexture(resources, namespace, itemName) {
+	const wanted = tokens(itemName).filter((token) => !FILLER_TOKENS.has(token));
+	const wantTrapped = itemName.includes("trapped");
+	let best = null;
+	let bestScore = 0;
+	let bestNoise = Infinity;
+	for (const locator of await resources.listResources("texture", namespace)) {
+		if (!locator.path.includes("chest")) continue;
+		const candidate = tokens(locator.path);
+		if (candidate.some((token) => SKIP_TOKENS.has(token))) continue;
+		if (wantTrapped !== (candidate.includes("trapped") || candidate.includes("trap"))) continue;
+		let score = 0;
+		for (const token of wanted) if (candidate.includes(token)) score++;
+		if (wanted.length > 0 && score === 0) continue;
+		if (best === null || score > bestScore || score === bestScore && candidate.length < bestNoise) {
+			best = locator;
+			bestScore = score;
+			bestNoise = candidate.length;
+		}
+	}
+	return best;
+}
+/** Clone a resolved model with one texture variable rebound. */
+function withTexture(model, name, locator) {
+	return {
+		...model,
+		textures: {
+			...model.textures,
+			[name]: locator.toString()
+		}
+	};
+}
+const WHITE_BANNER = {
+	r: 246 / 255,
+	g: 252 / 255,
+	b: 251 / 255
+};
+/** Vanilla DyeColor diffuse colors, keyed by the dye name mods prefix with. */
+const DYE_COLORS = {
+	white: 16383998,
+	orange: 16351261,
+	magenta: 13061821,
+	light_blue: 3847130,
+	yellow: 16701501,
+	lime: 8439583,
+	pink: 15961002,
+	gray: 4673362,
+	light_gray: 10329495,
+	cyan: 1481884,
+	purple: 8991416,
+	blue: 3949738,
+	brown: 8606770,
+	green: 6192150,
+	red: 11546150,
+	black: 1908001
+};
+const DYE_PREFIX = new RegExp(`^(${Object.keys(DYE_COLORS).join("|")})_(.+)$`);
+/**
+* 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
+* the vanilla base item tinted with the dye color. Suffixes like `_empty`/`_map`
+* are state variants of the same icon.
+*/
+async function renderDyedVariantFallback(id, models, textures, options) {
+	const locator = ResourceLocator.parse(id);
+	if (locator.namespace === "minecraft") return null;
+	const name = locator.path.split("/").pop() ?? locator.path;
+	const match = DYE_PREFIX.exec(name);
+	if (!match) return null;
+	const base = match[2].replace(/_(?:empty|map)$/, "");
+	const color = DYE_COLORS[match[1]];
+	const tint = {
+		r: (color >>> 16 & 255) / 255,
+		g: (color >>> 8 & 255) / 255,
+		b: (color & 255) / 255
+	};
+	for (const candidate of [`minecraft:item/${base}`, `minecraft:item/item_${base}`]) try {
+		const model = await models.load(candidate);
+		return await renderModel(model, textures, {
+			...options,
+			tints: [tint]
+		});
+	} catch {
+		continue;
+	}
+	return null;
+}
+/** Non-body entity sheets that would skew a mob's dominant colors. */
+const EGG_SKIP_TOKENS = /* @__PURE__ */ new Set([
+	"eyes",
+	"glow",
+	"emissive",
+	"overlay",
+	"saddle",
+	"armor",
+	"markings"
+]);
+/**
+* Derive spawn-egg tints from the mob's entity texture. Mod egg colors live
+* in item-registration code, so the two dominant colors of the entity skin
+* stand in: primary = biggest color cluster, secondary = biggest cluster
+* visually distinct from it. Returns null when no entity texture matches —
+* the egg then renders untinted, as before.
+*/
+async function spawnEggTints(id, resources, textures) {
+	const locator = ResourceLocator.parse(id);
+	if (locator.namespace === "minecraft") return null;
+	const name = locator.path.split("/").pop() ?? locator.path;
+	const mob = /^spawn_egg_(.+)$/.exec(name)?.[1] ?? /^(.+)_spawn_egg$/.exec(name)?.[1];
+	if (!mob) return null;
+	const wanted = mob.split("_").filter((token) => token.length > 1);
+	let best = null;
+	let bestScore = 0;
+	let bestNoise = Infinity;
+	for (const candidate of await resources.listResources("texture", locator.namespace)) {
+		if (!candidate.path.startsWith("entity/")) continue;
+		const parts = candidate.path.split(/[./_]/).filter((token) => token.length > 1);
+		if (parts.some((token) => EGG_SKIP_TOKENS.has(token))) continue;
+		let score = 0;
+		for (const token of wanted) if (parts.includes(token)) score++;
+		if (score === 0) continue;
+		if (score > bestScore || score === bestScore && parts.length < bestNoise) {
+			best = candidate;
+			bestScore = score;
+			bestNoise = parts.length;
+		}
+	}
+	const skin = best ? await textures.load(best) : null;
+	if (!skin) return null;
+	const buckets = /* @__PURE__ */ new Map();
+	for (let offset = 0; offset < skin.data.length; offset += 4) {
+		if (skin.data[offset + 3] <= 128) continue;
+		const key = skin.data[offset] >> 5 << 6 | skin.data[offset + 1] >> 5 << 3 | skin.data[offset + 2] >> 5;
+		const bucket = buckets.get(key) ?? [
+			0,
+			0,
+			0,
+			0
+		];
+		bucket[0] += skin.data[offset];
+		bucket[1] += skin.data[offset + 1];
+		bucket[2] += skin.data[offset + 2];
+		bucket[3]++;
+		buckets.set(key, bucket);
+	}
+	const clusters = buckets.values().toArray().toSorted((a, b) => b[3] - a[3]).map(([r, g, b, count]) => {
+		return {
+			r: r / count / 255,
+			g: g / count / 255,
+			b: b / count / 255,
+			count
+		};
+	});
+	if (clusters.length === 0) return null;
+	const primary = clusters[0];
+	const distance = (a, b) => Math.hypot(a.r - b.r, a.g - b.g, a.b - b.b);
+	const secondary = clusters.find((cluster) => distance(cluster, primary) > .25) ?? {
+		r: primary.r * .6,
+		g: primary.g * .6,
+		b: primary.b * .6
+	};
+	return [{
+		r: primary.r,
+		g: primary.g,
+		b: primary.b
+	}, {
+		r: secondary.r,
+		g: secondary.g,
+		b: secondary.b
+	}];
+}
+/**
+* Render a code-rendered (builtin/entity) item through builtin geometry when
+* its name identifies the kind. Returns null when no heuristic applies —
+* this must never guess across kinds.
+*/
+async function renderEntityFallback(id, models, textures, resources, options) {
+	const locator = ResourceLocator.parse(id);
+	const name = locator.path.split("/").pop() ?? locator.path;
+	const headMatch = /^(.+?)_(?:head|skull)$/.exec(name);
+	if (headMatch) {
+		const parts = headMatch[1].replace(/^(?:carved|wall|floor)_/, "").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;
+		}
+		return null;
+	}
+	if (name.includes("chest") && !name.includes("chestplate")) {
+		const variant = name.includes("ender") ? "ender" : name.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 {
+			const model = await models.load(modelPath);
+			let rebound = model;
+			if (modTexture && await textures.load(modTexture)) rebound = withTexture(model, "texture", modTexture);
+			else if (defaultTexture) rebound = withTexture(model, "texture", ResourceLocator.parse(defaultTexture));
+			return await renderModel(rebound, textures, options);
+		} catch {
+			continue;
+		}
+		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 (name.endsWith("banner")) try {
+		const model = await models.load("renderchest:item/banner");
+		return await renderModel(model, textures, {
+			...options,
+			tints: [WHITE_BANNER]
+		});
+	} catch {
+		return null;
+	}
+	return null;
+}
+//#endregion
+export { renderEntityFallback as n, spawnEggTints as r, renderDyedVariantFallback as t };

package/dist/face-DC6cNMdz.d.ts

@@ -0,0 +1,24 @@
+import { t as FloatTexture } from "./blend-Qvrn6YgK.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-CVOlRsuw.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;
+}
+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;
+//#endregion
+export { renderFace as i, TintColor as n, faceMaxZ as r, RenderableFace as t };

package/dist/face-Wfia-_Yx.js

@@ -0,0 +1,92 @@
+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 { i as phpRound, n as createFaceBuffer, r as drawTexturedTriangle, t as RowCursor } from "./rasterizer-ABgsWTYN.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 faceMaxZ(geometry) {
+	return Math.max(geometry.vertices[0][2], geometry.vertices[1][2], geometry.vertices[2][2], geometry.vertices[3][2]);
+}
+function linearDepth(z) {
+	return (z + 1) / 3;
+}
+function faceNormal(v0, v1, v2) {
+	const normal = cross(sub(v2, v0), sub(v1, v0));
+	if (normal[0] === 0 && normal[1] === 0 && normal[2] === 0) return null;
+	return normalize(normal);
+}
+/** Returns null when the face is culled, degenerate, or has a zero-area UV. */
+function renderFace(face, width, height, transformation) {
+	const { geometry } = face;
+	const uvWidth = geometry.uv2[0] - geometry.uv1[0];
+	const uvHeight = geometry.uv2[1] - geometry.uv1[1];
+	if (uvWidth === 0 || uvHeight === 0) return null;
+	const [mv0, mv1, mv2, mv3] = geometry.vertices;
+	let normal = geometry.shadeDirectionOverride ?? faceNormal(mv0, mv1, mv2);
+	if (normal === null) return null;
+	normal = normalize(transformDirection(transformation, normal));
+	if (dot([
+		0,
+		0,
+		-1
+	], normal) >= -.01) return null;
+	let shadeDirection = normal;
+	if (geometry.shadeDirectionOverride) shadeDirection = normalize(transformDirection(transformation, geometry.shadeDirectionOverride));
+	const v0 = transformVector(transformation, mv0);
+	const v1 = transformVector(transformation, mv1);
+	const v2 = transformVector(transformation, mv2);
+	const v3 = transformVector(transformation, mv3);
+	const projected = [
+		v0,
+		v1,
+		v2,
+		v3
+	].map((v) => {
+		return {
+			x: phpRound((v[0] - .5) * width + width / 2),
+			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 uvs = [
+		[geometry.uv1[0], geometry.uv1[1]],
+		[geometry.uv1[0] + uvWidth, geometry.uv1[1]],
+		[geometry.uv1[0] + uvWidth, geometry.uv1[1] + uvHeight],
+		[geometry.uv1[0], geometry.uv1[1] + uvHeight]
+	];
+	const rotations = Math.floor(geometry.rotation / 90);
+	for (let i = 0; i < rotations; i++) {
+		const last = uvs.pop();
+		if (last) uvs.unshift(last);
+	}
+	const buffer = createFaceBuffer(width, height);
+	const depths = [
+		linearDepth(v0[2]),
+		linearDepth(v1[2]),
+		linearDepth(v2[2]),
+		linearDepth(v3[2])
+	];
+	const point = (i) => {
+		return {
+			x: projected[i].x,
+			y: projected[i].y,
+			u: uvs[i][0],
+			v: uvs[i][1],
+			depth: depths[i]
+		};
+	};
+	const cursor = new RowCursor();
+	drawTexturedTriangle(point(0), point(2), point(3), buffer, texture, cursor);
+	drawTexturedTriangle(point(0), point(1), point(2), buffer, texture, cursor);
+	return buffer;
+}
+//#endregion
+export { renderFace as n, faceMaxZ as t };