@nodecraft/rendermite 1.0.5 → 1.0.6

package/dist/{synthesize-CRgSEmEp.js → synthesize-3Q0aaOnK.js}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { n as MapResourceManager } from "./synthetic-DC2bSnGe.js";
+import { n as MapResourceManager } from "./synthetic-ZAUjXT7E.js";
 //#region src/mods/synthesize.ts
 /**
 * Model synthesis for mods that ship textures without item models, ported from

package/dist/{synthetic-CDsj--li.d.ts → synthetic-Qk-BSUXO.d.ts}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
-import { a as ResourceManager, i as ResourceKindName } from "./manager-CoZaeQTu.js";
+import { a as ResourceManager, i as ResourceKindName, s as ResourceDescriptor } from "./manager-Cv1NeFyF.js";
 //#region src/resources/synthetic.d.ts
 /**
  * In-memory resources, used for era shims (synthesized `models/item/generated.json`,
@@ -7,6 +7,8 @@ import { a as ResourceManager, i as ResourceKindName } from "./manager-CoZaeQTu.
  * mutating asset trees on disk like the old pipeline did.
  */
 declare class MapResourceManager implements ResourceManager {
+  /** Rebuild from a describe() payload (worker side). */
+  static fromEntries(entries: Iterable<[string, Uint8Array]>): MapResourceManager;
   private readonly entries;
   set(kind: ResourceKindName, locator: string | ResourceLocator, content: Buffer | string): this;
   getResource(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer | null>;
@@ -14,6 +16,7 @@ declare class MapResourceManager implements ResourceManager {
   getAllResources(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer[]>;
   listResources(kind: ResourceKindName, namespace: string): Promise<ResourceLocator[]>;
   listNamespaces(): Promise<string[]>;
+  describe(): ResourceDescriptor;
 }
 /**
  * Restricts a manager to specific resource kinds — donor versions may only
@@ -29,6 +32,7 @@ declare class KindFilteredResourceManager implements ResourceManager {
   getAllResources(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer[]>;
   listResources(kind: ResourceKindName, namespace: string): Promise<ResourceLocator[]>;
   listNamespaces(): Promise<string[]>;
+  describe(): ResourceDescriptor | null;
 }
 //#endregion
 export { MapResourceManager as n, KindFilteredResourceManager as t };

package/dist/textures/loader.d.ts

@@ -1,2 +1,2 @@
-import { a as TextureMeta, i as TextureLoader, n as AtlasResolverLike, o as TextureResolutionError, r as Texture, t as AnimatedTexture } from "../loader-TFFNV4Jl.js";
+import { a as TextureMeta, i as TextureLoader, n as AtlasResolverLike, o as TextureResolutionError, r as Texture, t as AnimatedTexture } from "../loader-Myy22TDL.js";
 export { AnimatedTexture, AtlasResolverLike, Texture, TextureLoader, TextureMeta, TextureResolutionError };

package/dist/textures/loader.js

@@ -1,2 +1,2 @@
-import { n as TextureLoader, r as TextureResolutionError, t as AnimatedTexture } from "../loader-CBzn3Koc.js";
+import { n as TextureLoader, r as TextureResolutionError, t as AnimatedTexture } from "../loader-CfXMxcEV.js";
 export { AnimatedTexture, TextureLoader, TextureResolutionError };

package/dist/{tints-CuG6GwQJ.js → tints-B8UJmZMu.js}

@@ -1,8 +1,8 @@
 import { r as modTintPackPath } from "./builtin-caYjESh0.js";
 import { a as defaultProperties, o as evaluateItemModel } from "./definition-3MBm8ar_.js";
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { t as FolderResourceManager } from "./manager-dfI7b9N4.js";
-import { n as MapResourceManager } from "./synthetic-DC2bSnGe.js";
+import { t as FolderResourceManager } from "./manager-CkletR5K.js";
+import { n as MapResourceManager } from "./synthetic-ZAUjXT7E.js";
 //#region src/mods/tints.ts
 /**
 * Tints for mod items whose colors live in client code rather than asset JSON.

package/dist/{tints-txt-8xI5.d.ts → tints-DLBExVWN.d.ts}

@@ -1,5 +1,5 @@
-import { i as TextureLoader } from "./loader-TFFNV4Jl.js";
-import { n as TintColor } from "./face-CpVdnf-w.js";
+import { i as TextureLoader } from "./loader-Myy22TDL.js";
+import { r as TintColor } from "./face-BIYg14TE.js";
 import { o as TintDefinition } from "./definition-BwX6Xxv0.js";
 //#region src/render/tints.d.ts
 declare class InvalidTinterDefinitionError extends Error {}

package/dist/versions/legacy-reshape.d.ts

@@ -1,4 +1,4 @@
-import { a as ResourceManager } from "../manager-CoZaeQTu.js";
+import { a as ResourceManager } from "../manager-Cv1NeFyF.js";
 //#region src/versions/legacy-reshape.d.ts
 /**
  * Build an in-memory texture layer for a pre-1.6 jar. `sheets` selects the

package/dist/versions/legacy-reshape.js

@@ -1,2 +1,2 @@
-import { t as reshapeLegacyAssets } from "../legacy-reshape-CewShfF3.js";
+import { t as reshapeLegacyAssets } from "../legacy-reshape-C05SfAPR.js";
 export { reshapeLegacyAssets };

package/dist/versions/prepare.d.ts

@@ -1,2 +1,2 @@
-import { a as compareVersions, i as PrepareOptions, n as EraName, o as eraForVersion, r as GEOMETRY_DONOR_VERSIONS, s as prepareVersionResources, t as Era } from "../prepare-wfWtaz_X.js";
+import { a as compareVersions, i as PrepareOptions, n as EraName, o as eraForVersion, r as GEOMETRY_DONOR_VERSIONS, s as prepareVersionResources, t as Era } from "../prepare-Cs6QDqie.js";
 export { Era, EraName, GEOMETRY_DONOR_VERSIONS, PrepareOptions, compareVersions, eraForVersion, prepareVersionResources };

package/dist/versions/prepare.js

@@ -1,2 +1,2 @@
-import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS, r as compareVersions, t as Era } from "../prepare-C8wRjAXP.js";
+import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS, r as compareVersions, t as Era } from "../prepare-Cc8QZ3j0.js";
 export { Era, GEOMETRY_DONOR_VERSIONS, compareVersions, eraForVersion, prepareVersionResources };

package/dist/workers/pool.d.ts

@@ -2,8 +2,14 @@
 /**
  * Worker-thread pool for parallel item rendering. Design goals born from the
  * PHP tool's failure modes (docs/research/mod-failure-taxonomy.md): errors
- * cross the worker boundary as structured data, a dead worker's queue items are
- * requeued not orphaned, and results stream back so output lands incrementally.
+ * cross the worker boundary as structured data, a dead worker's in-flight items
+ * are reported rather than orphaned, and results stream back so output lands
+ * incrementally.
+ *
+ * Workers spawn as soon as the pool is constructed, so their asset indexing
+ * overlaps the caller's own discovery pass; each holds several tasks at once so
+ * native encoding overlaps the next item's rasterization; and the queue drains
+ * through a cursor, because shift() on a 400k-item array is quadratic.
  */
 interface WorkerTask {
   id: string;
@@ -16,8 +22,33 @@ interface WorkerResult<T> {
 interface PoolOptions {
   workerUrl: URL;
   workerData: unknown;
-  concurrency: number;
+  /** Worker threads to spawn. */
+  workers: number;
+  /** Tasks held by each worker at once (default 2). */
+  inFlight?: number;
+}
+declare class WorkerRenderPool<T> {
+  private readonly options;
+  private readonly inFlightLimit;
+  private readonly workers;
+  private tasks;
+  private cursor;
+  private started;
+  private onResult;
+  private settle;
+  private settled;
+  /** Workers dying before completing anything mean a bad config, not bad luck. */
+  private startupFailures;
+  constructor(options: PoolOptions);
+  private spawn;
+  private pump;
+  private retire;
+  private fail;
+  private finish;
+  private abort;
+  /** Run every task, calling back as results arrive. Terminates the pool after. */
+  run(tasks: WorkerTask[], onResult: (result: WorkerResult<T>) => void): Promise<void>;
+  close(): Promise<void>;
 }
-declare function runPool<T>(tasks: WorkerTask[], options: PoolOptions, onResult: (result: WorkerResult<T>) => void): Promise<void>;
 //#endregion
-export { PoolOptions, WorkerResult, WorkerTask, runPool };
+export { PoolOptions, WorkerRenderPool, WorkerResult, WorkerTask };

package/dist/workers/pool.js

@@ -1,67 +1,2 @@
-import { Worker } from "node:worker_threads";
-//#region src/workers/pool.ts
-/**
-* Worker-thread pool for parallel item rendering. Design goals born from the
-* PHP tool's failure modes (docs/research/mod-failure-taxonomy.md): errors
-* cross the worker boundary as structured data, a dead worker's queue items are
-* requeued not orphaned, and results stream back so output lands incrementally.
-*/
-async function runPool(tasks, options, onResult) {
-	const queue = [...tasks];
-	const inFlight = /* @__PURE__ */ new Map();
-	await new Promise((resolve) => {
-		let active = 0;
-		const spawn = () => {
-			const worker = new Worker(options.workerUrl, { workerData: options.workerData });
-			active++;
-			const next = () => {
-				const task = queue.shift();
-				if (task === void 0) {
-					worker.terminate().catch(() => {});
-					active--;
-					if (active === 0) resolve();
-					return;
-				}
-				inFlight.set(worker, task);
-				worker.postMessage(task);
-			};
-			worker.on("message", (message) => {
-				inFlight.delete(worker);
-				onResult(message);
-				next();
-			});
-			worker.on("error", (err) => {
-				const task = inFlight.get(worker);
-				inFlight.delete(worker);
-				if (task) onResult({
-					id: task.id,
-					error: `Worker crashed: ${err.message}`
-				});
-				active--;
-				if (queue.length > 0) spawn();
-				else if (active === 0) resolve();
-			});
-			worker.on("exit", (code) => {
-				const task = inFlight.get(worker);
-				if (task && code !== 0) {
-					inFlight.delete(worker);
-					onResult({
-						id: task.id,
-						error: `Worker exited with code ${code}`
-					});
-					active--;
-					if (queue.length > 0) spawn();
-					else if (active === 0) resolve();
-				}
-			});
-			next();
-		};
-		if (queue.length === 0) {
-			resolve();
-			return;
-		}
-		for (let i = 0; i < Math.min(options.concurrency, queue.length); i++) spawn();
-	});
-}
-//#endregion
-export { runPool };
+import { t as WorkerRenderPool } from "../pool-CKGp1qup.js";
+export { WorkerRenderPool };

package/dist/workers/render-worker.d.ts

@@ -0,0 +1,15 @@
+import { s as ResourceDescriptor } from "../manager-Cv1NeFyF.js";
+import { n as ItemRenderOutcome, r as PipelineSettings } from "../pipeline-zq-yU3Te.js";
+//#region src/workers/render-worker.d.ts
+interface RenderWorkerData {
+  resources: ResourceDescriptor;
+  settings: PipelineSettings;
+  /** libvips threads per worker; the pool already saturates the CPU. */
+  sharpConcurrency: number;
+}
+interface RenderWorkerTask {
+  id: string;
+}
+type RenderWorkerOutcome = ItemRenderOutcome;
+//#endregion
+export { RenderWorkerData, RenderWorkerOutcome, RenderWorkerTask };

package/dist/workers/render-worker.js

@@ -0,0 +1,40 @@
+import { t as ItemPipeline } from "../pipeline-BIk1RRIp.js";
+import { n as restoreResources } from "../descriptor-DWebtkI1.js";
+import sharp from "sharp";
+import { parentPort, workerData } from "node:worker_threads";
+//#region src/workers/render-worker.ts
+/**
+* Worker entry: rebuilds the run's resource tree from its descriptor, then
+* renders, encodes and writes items on demand. Items are written here rather
+* than shipped back as buffers — the main thread only needs the outcome, and
+* the file write is the run's success signal either way.
+*
+* Messages in are `{ id }`; messages out are `{ id, result }` or `{ id, error }`.
+* Errors cross as strings because Error instances lose their type across the
+* structured-clone boundary.
+*/
+if (!parentPort) throw new Error("render-worker must be started as a worker thread");
+const port = parentPort;
+const data = workerData;
+sharp.concurrency(data.sharpConcurrency);
+const pipeline = await ItemPipeline.create(restoreResources(data.resources), data.settings);
+async function handle(task) {
+	try {
+		const result = await pipeline.renderItem(task.id);
+		port.postMessage({
+			id: task.id,
+			result
+		});
+	} catch (err) {
+		port.postMessage({
+			id: task.id,
+			error: err.message
+		});
+	}
+}
+port.on("message", (task) => {
+	handle(task).catch(() => {});
+});
+port.postMessage({ ready: true });
+//#endregion
+export {};

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.6",
 	"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 };