@nodecraft/rendermite 1.0.5 → 1.0.7

package/dist/zip-reader-BSbJKUT1.js

@@ -0,0 +1,156 @@
+import { close, createReadStream, fstat, open, read } from "node:fs";
+import { Readable } from "node:stream";
+import { RandomAccessReader, fromRandomAccessReader, open as open$1 } from "yauzl";
+//#region src/resources/zip-reader.ts
+/**
+* Opens a zip with its central directory held in memory.
+*
+* yauzl reads each central-directory record with its own small read, so a
+* 26,000-entry client jar costs ~26,000 syscalls and well over a second before
+* the first icon renders. The directory is one contiguous region, so reading it
+* whole and serving those reads from the buffer makes indexing ~6× faster while
+* keeping entry data itself on disk — only the directory stays resident.
+*
+* Anything unexpected (zip64, a truncated archive, no end-of-directory record)
+* falls back to yauzl's own open, which is correct for every archive.
+*/
+const EOCD_SIGNATURE = 101010256;
+/** End-of-directory record plus the largest possible archive comment. */
+const EOCD_SEARCH_BYTES = 65557;
+const ZIP64_SENTINEL = 4294967295;
+/** Above this, a range streams from its own descriptor instead of one buffer. */
+const MAX_BUFFERED_READ_BYTES = 33554432;
+/** Locate the central directory from the end-of-directory record. */
+function findCentralDirectory(tail, tailStart) {
+	for (let index = tail.length - 22; index >= 0; index--) {
+		if (tail.readUInt32LE(index) !== EOCD_SIGNATURE) continue;
+		const size = tail.readUInt32LE(index + 12);
+		const offset = tail.readUInt32LE(index + 16);
+		if (size === ZIP64_SENTINEL || offset === ZIP64_SENTINEL) return null;
+		if (offset + size > tailStart + index) return null;
+		return {
+			offset,
+			size
+		};
+	}
+	return null;
+}
+/** Promisified positional read; a raw descriptor avoids FileHandle's close-on-GC. */
+async function readAt(fd, buffer, offset, length, position) {
+	return new Promise((resolve, reject) => {
+		read(fd, buffer, offset, length, position, (err, bytesRead) => {
+			if (err) {
+				reject(err);
+				return;
+			}
+			resolve(bytesRead);
+		});
+	});
+}
+var BufferedDirectoryReader = class extends RandomAccessReader {
+	path;
+	fd;
+	directory;
+	directoryStart;
+	constructor(path, fd, directory, directoryStart) {
+		super();
+		this.path = path;
+		this.fd = fd;
+		this.directory = directory;
+		this.directoryStart = directoryStart;
+	}
+	_readStreamForRange(start, end) {
+		const directoryEnd = this.directoryStart + this.directory.length;
+		if (start >= this.directoryStart && end <= directoryEnd) return Readable.from([this.directory.subarray(start - this.directoryStart, end - this.directoryStart)]);
+		const length = end - start;
+		if (length > MAX_BUFFERED_READ_BYTES) return createReadStream(this.path, {
+			start,
+			end: end - 1
+		});
+		const { fd } = this;
+		return Readable.from((async function* read() {
+			const buffer = Buffer.alloc(length);
+			let filled = 0;
+			while (filled < length) {
+				const bytesRead = await readAt(fd, buffer, filled, length - filled, start + filled);
+				if (bytesRead === 0) break;
+				filled += bytesRead;
+			}
+			yield filled === length ? buffer : buffer.subarray(0, filled);
+		})());
+	}
+	/**
+	* yauzl reads each directory record through here. Copying from the buffer
+	* skips the per-read stream pipeline entirely, which is most of the cost of
+	* indexing tens of thousands of entries.
+	*/
+	read(buffer, offset, length, position, callback) {
+		const directoryEnd = this.directoryStart + this.directory.length;
+		if (position >= this.directoryStart && position + length <= directoryEnd) {
+			const from = position - this.directoryStart;
+			this.directory.copy(buffer, offset, from, from + length);
+			queueMicrotask(() => callback(null));
+			return;
+		}
+		readAt(this.fd, buffer, offset, length, position).then(() => callback(null)).catch(callback);
+	}
+	/** yauzl's close hook, reached when the ZipFile releases its last reference. */
+	close(callback) {
+		close(this.fd, (err) => callback(err ?? null));
+	}
+};
+async function openZip(zipPath) {
+	const fallback = async () => new Promise((resolve, reject) => {
+		open$1(zipPath, {
+			lazyEntries: true,
+			autoClose: false
+		}, (err, zip) => {
+			if (err) {
+				reject(err);
+				return;
+			}
+			resolve(zip);
+		});
+	});
+	let fd;
+	try {
+		fd = await new Promise((resolve, reject) => {
+			open(zipPath, "r", (err, handle) => err ? reject(err) : resolve(handle));
+		});
+	} catch {
+		return fallback();
+	}
+	const abandon = async () => {
+		close(fd, () => {});
+		return fallback();
+	};
+	try {
+		const size = await new Promise((resolve, reject) => {
+			fstat(fd, (err, stats) => err ? reject(err) : resolve(stats.size));
+		});
+		const tailStart = Math.max(0, size - EOCD_SEARCH_BYTES);
+		const tail = Buffer.alloc(size - tailStart);
+		await readAt(fd, tail, 0, tail.length, tailStart);
+		const central = findCentralDirectory(tail, tailStart);
+		if (!central) return await abandon();
+		const directory = Buffer.alloc(central.size);
+		await readAt(fd, directory, 0, central.size, central.offset);
+		const reader = new BufferedDirectoryReader(zipPath, fd, directory, central.offset);
+		return await new Promise((resolve, reject) => {
+			fromRandomAccessReader(reader, size, {
+				lazyEntries: true,
+				autoClose: false
+			}, (err, zip) => {
+				if (err) {
+					reject(err);
+					return;
+				}
+				resolve(zip);
+			});
+		});
+	} catch {
+		return abandon();
+	}
+}
+//#endregion
+export { openZip as t };

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@nodecraft/rendermite",
-	"version": "1.0.5",
+	"version": "1.0.7",
 	"description": "Minecraft item icon renderer: renders inventory-identical item icons from vanilla and modded assets across game versions, outputting optimized PNG/WebP/AVIF plus CSS and a JSON item library.",
 	"type": "module",
 	"license": "MIT",
-	"author": "James Ross <james@jross.me> (https://jross.me/)",
+	"author": "Nodecraft",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/nodecraft/rendermite.git"
@@ -42,6 +42,8 @@
 		"lint": "eslint . --fix",
 		"lint:ci": "eslint .",
 		"test": "vitest run",
+		"bench": "vitest bench --config vitest.bench.config.ts --run",
+		"bench:report": "vitest bench --config vitest.bench.config.ts --run --outputJson bench-results.json && node scripts/bench-report.ts",
 		"test:watch": "vitest",
 		"typecheck": "tsc --noEmit",
 		"semantic-release": "semantic-release"

package/dist/compose-qjhyBvnS.js

@@ -1,41 +0,0 @@
-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++) {
-		const x = pixel % width;
-		const y = Math.floor(pixel / width);
-		const localPixel = (face) => {
-			const localX = x - face.x;
-			const localY = y - face.y;
-			return localX >= 0 && localX < face.width && localY >= 0 && localY < face.height ? localY * face.width + localX : null;
-		};
-		order.sort((a, b) => {
-			const aPixel = localPixel(a);
-			const bPixel = localPixel(b);
-			return (aPixel === null ? 0 : a.depths[aPixel]) - (bPixel === null ? 0 : b.depths[bPixel]);
-		});
-		const offset = pixel * 4;
-		for (const face of order) {
-			const facePixel = localPixel(face);
-			if (facePixel === null) continue;
-			const faceOffset = facePixel * 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);
-		}
-	}
-	return {
-		width,
-		height,
-		data: out
-	};
-}
-//#endregion
-export { combineFaceBuffers as t };

package/dist/run-CfnWIRY4.js

@@ -1,316 +0,0 @@
-import { a as defaultProperties } from "./definition-3MBm8ar_.js";
-import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-dfI7b9N4.js";
-import { t as loadAtlasResolver } from "./registry-B9TcjVbs.js";
-import { a as builtinDynamicResources } from "./generators-CcVRG30y.js";
-import { n as discoverItems, r as resolveItem } from "./discovery-0SM0cTLw.js";
-import { t as ModelLoader } from "./loader-A-BZa8J4.js";
-import { s as toFloatTexture, t as blendPixel } from "./blend-CHP2-j9U.js";
-import { r as encodeRasterAsset, t as encodeAnimatedIcon } from "./encode-3u49i-eD.js";
-import { t as classifyItemStyle } from "./item-styles-DJ3LWZS2.js";
-import { t as minifyStylesheet } from "./minify-bjMRmr5J.js";
-import { t as generateStylesheet } from "./stylesheet-CovT3B2S.js";
-import { a as renderModelFrames, i as renderModel, n as boxDownscale, r as pointResize } from "./renderer-LDhBNHcl.js";
-import { n as renderEntityFallback, r as spawnEggTints, t as renderDyedVariantFallback } from "./entity-fallback-DfL0_eyf.js";
-import { i as renderGeo, t as findGeoForItem } from "./geo-Dq2zve09.js";
-import { t as legacyTintsForChain } from "./legacy-tints-B09J0Rxh.js";
-import { a as resolveTints } from "./tints-BtbHegpI.js";
-import { n as TextureLoader } from "./loader-CBzn3Koc.js";
-import path from "node:path";
-import { mkdir, writeFile } from "node:fs/promises";
-//#region src/run.ts
-/**
-* Render-run orchestration: discover items, evaluate definitions, render,
-* encode, write images + stylesheet + item list. Unlike upstream, failures are
-* per-item, collected, and reported — a run summary counts files, never log lines.
-*/
-async function run(options) {
-	const namespaces = options.namespaces ?? ["minecraft"];
-	const size = options.size ?? 64;
-	const quality = options.quality ?? 2;
-	const prefix = options.prefix ?? "rc-";
-	const format = options.format ?? "webp";
-	const fallback = options.fallback ?? true;
-	const lightingProfile = options.lightingProfile ?? "modern";
-	const dynamic = options.builtin ? builtinDynamicResources() : null;
-	const resources = options.builtin && dynamic ? new LayeredResourceManager([
-		new FolderResourceManager(options.builtin),
-		dynamic.layer,
-		options.resources
-	]) : options.resources;
-	const models = new ModelLoader(resources);
-	const textures = new TextureLoader(resources);
-	const glint = await resolveEnchantmentGlint(resources);
-	if (!glint) throw new Error("Missing enchantment glint texture (minecraft:misc/enchanted_glint_item or enchanted_item_glint)");
-	const encodedGlint = await encodeRasterAsset(glint, fallback ? ["png", format] : [format]);
-	textures.setAtlasResolver(await loadAtlasResolver(resources, (locator) => textures.load(locator)));
-	const ids = [];
-	const seen = /* @__PURE__ */ new Set();
-	if (options.builtin) for (const placeholder of ["renderchest:unknown", "renderchest:empty"]) {
-		seen.add(placeholder);
-		ids.push(placeholder);
-	}
-	for (const namespace of namespaces) for (const item of await discoverItems(resources, namespace, { filterUntranslatedModels: options.filterUntranslatedModels })) {
-		if (seen.has(item.id)) continue;
-		if (options.builtin && !await itemExistsIn(options.resources, item.id)) continue;
-		seen.add(item.id);
-		ids.push(item.id);
-	}
-	if (dynamic && namespaces.includes("minecraft")) {
-		const hasTrims = await resources.hasResource("texture", ResourceLocator.parse("minecraft:trims/color_palettes/trim_palette"));
-		const groupAvailable = {
-			_armor_trims: hasTrims,
-			_leather_armor: hasTrims,
-			_decorated_pot: await resources.hasResource("texture", ResourceLocator.parse("minecraft:entity/decorated_pot/decorated_pot_base")),
-			_crossbow: await resources.hasResource("model", ResourceLocator.parse("minecraft:item/crossbow_arrow"))
-		};
-		for (const item of dynamic.items) if ((groupAvailable[item.id.split(":", 1)[0]] ?? true) && !seen.has(item.id)) {
-			seen.add(item.id);
-			ids.push(item.id);
-		}
-	}
-	const rendered = [];
-	const failed = [];
-	const spriteFallbacks = [];
-	const skippedTemplates = [];
-	const styles = [];
-	let writtenFiles = 0;
-	await mkdir(options.output, { recursive: true });
-	for (const [extension, buffer] of encodedGlint) {
-		await writeFile(path.join(options.output, `${prefix}enchantment.${extension}`), buffer);
-		writtenFiles++;
-	}
-	let templateParents = null;
-	const loadTemplateParents = async () => {
-		const parents = /* @__PURE__ */ new Set();
-		for (const namespace of namespaces) for (const modelLocator of await resources.listResources("model", namespace)) {
-			if (!modelLocator.path.startsWith("item/")) continue;
-			const raw = await resources.getResource("model", modelLocator);
-			if (!raw) continue;
-			try {
-				const parent = JSON.parse(raw.toString("utf8")).parent;
-				if (typeof parent === "string") parents.add(ResourceLocator.parse(parent).toString());
-			} catch {}
-		}
-		return parents;
-	};
-	const isTemplateModel = async (id) => {
-		const locator = ResourceLocator.parse(id);
-		if (await resources.hasResource("itemDefinition", locator)) return false;
-		templateParents ??= loadTemplateParents();
-		return (await templateParents).has(new ResourceLocator(locator.namespace, `item/${locator.path}`).toString());
-	};
-	/**
-	* Code-rendered models often still ship a flat item sprite (the old
-	* pipeline's black-icon audit checked exactly this). A real sprite beats
-	* no icon; the fallback is recorded so it is never a silent substitution.
-	*/
-	const spriteFallback = async (id) => {
-		const locator = ResourceLocator.parse(id);
-		for (const directory of ["item", "items"]) {
-			const texture = await textures.load(new ResourceLocator(locator.namespace, `${directory}/${locator.path}`));
-			if (texture) {
-				const float = toFloatTexture(texture);
-				const upscaled = pointResize(float, size * quality, size * quality);
-				return quality === 1 ? upscaled : boxDownscale(upscaled, quality);
-			}
-		}
-		return null;
-	};
-	const concurrency = Math.max(1, options.concurrency ?? 8);
-	let nextIndex = 0;
-	let completed = 0;
-	const renderFrames = async (id) => {
-		const instructions = await resolveItem(resources, id, defaultProperties());
-		let frames;
-		let delaysMs;
-		if (instructions.length === 1) {
-			const model = await models.load(instructions[0].model);
-			let tints = instructions[0].tints.length > 0 ? await resolveTints(instructions[0].tints, { textures }) : await legacyTintsForChain(model.chain, textures);
-			if (!tints && model.chain.some((entry) => entry.endsWith("item/template_spawn_egg"))) tints = await spawnEggTints(id, resources, textures).catch(() => null);
-			tints ??= [];
-			const result = await renderModelFrames(model, textures, {
-				size,
-				quality,
-				lightingProfile,
-				itemTransform: instructions[0].transform,
-				tints,
-				resources
-			});
-			frames = result.frames;
-			delaysMs = result.delaysMs;
-		} else {
-			let combined = null;
-			for (const instruction of instructions) {
-				const model = await models.load(instruction.model);
-				const tints = instruction.tints.length > 0 ? await resolveTints(instruction.tints, { textures }) : await legacyTintsForChain(model.chain, textures) ?? [];
-				const renderedModel = await renderModel(model, textures, {
-					size,
-					quality,
-					lightingProfile,
-					itemTransform: instruction.transform,
-					tints,
-					resources
-				});
-				combined = combined === null ? renderedModel : blendOver(combined, renderedModel);
-			}
-			frames = [combined ?? {
-				width: size,
-				height: size,
-				data: new Float64Array(size * size * 4)
-			}];
-			delaysMs = [50];
-		}
-		if (frames.length === 0) {
-			frames = [{
-				width: size,
-				height: size,
-				data: new Float64Array(size * size * 4)
-			}];
-			delaysMs = [50];
-		}
-		return {
-			frames,
-			delaysMs
-		};
-	};
-	const renderOne = async (index) => {
-		const id = ids[index];
-		let frames;
-		let delaysMs;
-		let usedFallback = false;
-		try {
-			({frames, delaysMs} = await renderFrames(id));
-		} catch (err) {
-			const blockLocator = ResourceLocator.parse(id);
-			const blockRender = await models.load(new ResourceLocator(blockLocator.namespace, `block/${blockLocator.path}`)).then((model) => renderModel(model, textures, {
-				size,
-				quality,
-				lightingProfile,
-				resources
-			})).catch(() => null);
-			const geo = blockRender ? null : await findGeoForItem(resources, id).catch(() => null);
-			const geoRender = geo ? await renderGeo(geo.geo, geo.texture, textures, {
-				size,
-				quality,
-				lightingProfile
-			}).catch(() => null) : null;
-			let fallbackRender = blockRender ?? (geoRender && quality !== 1 ? boxDownscale(geoRender, quality) : geoRender);
-			fallbackRender ??= options.builtin ? await renderEntityFallback(id, models, textures, resources, {
-				size,
-				quality,
-				lightingProfile,
-				resources
-			}).catch(() => null) : null;
-			fallbackRender ??= await renderDyedVariantFallback(id, models, textures, {
-				size,
-				quality,
-				lightingProfile,
-				resources
-			}).catch(() => null);
-			if (fallbackRender) {
-				frames = [fallbackRender];
-				delaysMs = [50];
-			} else {
-				const fallback = await spriteFallback(id).catch(() => null);
-				if (!fallback) {
-					if (await isTemplateModel(id).catch(() => false)) skippedTemplates.push(id);
-					else failed.push({
-						id,
-						error: err.message
-					});
-					completed++;
-					options.onProgress?.(completed, ids.length, id, err.message);
-					return;
-				}
-				frames = [fallback];
-				delaysMs = [50];
-				usedFallback = true;
-			}
-		}
-		try {
-			const encoded = await encodeAnimatedIcon(frames, delaysMs, {
-				webp: true,
-				gif: options.gif,
-				avif: options.avif || format === "avif"
-			});
-			const [namespace, itemPath] = id.split(":", 2);
-			const imageBase = path.join(options.output, "items", namespace, `${itemPath}`);
-			await mkdir(path.dirname(imageBase), { recursive: true });
-			await writeFile(`${imageBase}.png`, encoded.png);
-			writtenFiles++;
-			for (const [extension, buffer] of [
-				["webp", encoded.webp],
-				["gif", encoded.gif],
-				["avif", encoded.avif]
-			]) {
-				if (!buffer) continue;
-				await writeFile(`${imageBase}.${extension}`, buffer);
-				writtenFiles++;
-			}
-			rendered.push(id);
-			if (usedFallback) spriteFallbacks.push(id);
-			completed++;
-			options.onProgress?.(completed, ids.length, id);
-		} catch (err) {
-			failed.push({
-				id,
-				error: err.message
-			});
-			completed++;
-			options.onProgress?.(completed, ids.length, id, err.message);
-		}
-	};
-	await Promise.all(Array.from({ length: Math.min(concurrency, ids.length) }, async () => {
-		while (nextIndex < ids.length) {
-			const index = nextIndex++;
-			await renderOne(index);
-		}
-	}));
-	rendered.sort((left, right) => left.localeCompare(right));
-	const renderedSet = new Set(rendered);
-	for (const id of rendered) {
-		const style = classifyItemStyle(id, renderedSet);
-		if (style) styles.push(style);
-	}
-	const stylesheet = generateStylesheet(styles, {
-		prefix,
-		format,
-		fallback
-	});
-	const finalStylesheet = options.minify === false ? stylesheet : minifyStylesheet(stylesheet, (message) => options.onProgress?.(0, 0, "stylesheet", message));
-	await writeFile(path.join(options.output, `${prefix}${namespaces[0]}-${size}.css`), finalStylesheet);
-	if (options.itemList !== false) {
-		await writeFile(path.join(options.output, `${prefix}${namespaces[0]}.json`), JSON.stringify(rendered));
-		await writeFile(path.join(options.output, `${prefix}${namespaces[0]}-failures.json`), JSON.stringify(failed, null, "	"));
-	}
-	return {
-		rendered,
-		failed,
-		spriteFallbacks,
-		skippedTemplates,
-		writtenFiles
-	};
-}
-async function itemExistsIn(resources, id) {
-	const locator = ResourceLocator.parse(id);
-	if (await resources.hasResource("itemDefinition", locator)) return true;
-	return resources.hasResource("model", new ResourceLocator(locator.namespace, `item/${locator.path}`));
-}
-/** Resolve both names used on either side of Minecraft 1.19.3. */
-async function resolveEnchantmentGlint(resources) {
-	for (const path of ["misc/enchanted_glint_item", "misc/enchanted_item_glint"]) {
-		const texture = await resources.getResource("texture", new ResourceLocator("minecraft", path));
-		if (texture) return texture;
-	}
-	return null;
-}
-function blendOver(base, layer) {
-	for (let offset = 0; offset < base.data.length; offset += 4) {
-		const alpha = layer.data[offset + 3];
-		if (alpha > 0) blendPixel(base.data, offset, layer.data[offset], layer.data[offset + 1], layer.data[offset + 2], alpha);
-	}
-	return base;
-}
-//#endregion
-export { run as t };