@nodecraft/rendermite 1.0.5 → 1.0.6

package/dist/{renderer-LDhBNHcl.js → renderer-CjT19tHd.js}

@@ -1,13 +1,13 @@
 import { c as normalize, g as transformVector, m as sub, n as displayMatrix, o as identity, r as dot, s as multiply, t as cross } from "./vector-CCxLae_T.js";
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { i as resolveTexture } from "./loader-A-BZa8J4.js";
 import { a as tintTexture, n as cloneFloatTexture, r as darkenTexture, s as toFloatTexture, t as blendPixel } from "./blend-CHP2-j9U.js";
-import { t as combineFaceBuffers } from "./compose-qjhyBvnS.js";
-import { a as phpRound, i as drawTexturedTriangle, r as createFaceBuffer, t as RowCursor } from "./rasterizer-BHWDrmGz.js";
-import { n as renderFace, t as faceMaxZ } from "./face-D-N1amV4.js";
+import { t as combineFaceBuffers } from "./compose-CQCb2LVv.js";
+import { a as drawTexturedTriangle, i as createFaceBuffer, n as clearFaceBuffer, o as phpRound, t as RowCursor } from "./rasterizer-76qO8TDh.js";
+import { n as renderFace, t as faceMaxZ } from "./face-DmCiHUd5.js";
 import { t as paintBucketFluid } from "./fluid-bucket-D-GpUQjg.js";
 import { r as buildElementFaces } from "./geometry-uIDha8S4.js";
 import { c as lightsForProfile } from "./lighting--5myudVu.js";
+import { i as resolveTexture } from "./loader-B8NJO7pR.js";
 //#region src/render/obj.ts
 /**
 * Forge/NeoForge OBJ model rendering — the class the old pipeline left
@@ -140,6 +140,7 @@ async function renderObjModel(model, resources, textures, options) {
 	const transformation = multiply(guiMatrix, options.itemTransform ?? identity());
 	const renderSize = options.size * options.quality;
 	const out = createFaceBuffer(renderSize, renderSize);
+	const scratch = createFaceBuffer(renderSize, renderSize);
 	const shaded = /* @__PURE__ */ new Map();
 	for (const triangle of parsed.triangles) {
 		const transformed = triangle.positions.map((position) => transformVector(transformation, position));
@@ -164,7 +165,7 @@ async function renderObjModel(model, resources, textures, options) {
 			darkenTexture(texture, 1 - bucket / 64, 0, 0, texture.width, texture.height);
 			shaded.set(key, texture);
 		}
-		const scratch = createFaceBuffer(renderSize, renderSize);
+		clearFaceBuffer(scratch);
 		const cursor = new RowCursor();
 		const point = (index) => {
 			return {
@@ -176,7 +177,8 @@ async function renderObjModel(model, resources, textures, options) {
 			};
 		};
 		drawTexturedTriangle(point(0), point(1), point(2), scratch, texture, cursor);
-		for (let pixel = 0; pixel < renderSize * renderSize; pixel++) {
+		for (let y = Math.max(scratch.dirty.minY, 0); y <= Math.min(scratch.dirty.maxY, renderSize - 1); y++) for (let x = Math.max(scratch.dirty.minX, 0); x <= Math.min(scratch.dirty.maxX, renderSize - 1); x++) {
+			const pixel = y * renderSize + x;
 			const offset = pixel * 4;
 			const alpha = scratch.colors[offset + 3];
 			if (alpha <= 0) continue;
@@ -241,16 +243,19 @@ async function renderModelFrames(model, textures, options) {
 		ticks = ticks / gcd(ticks, texture.tickLength) * texture.tickLength;
 		interpolated ||= texture.interpolated;
 	}
-	const maxSkippable = interpolated ? Math.ceil(ticks / MAX_ANIMATION_FRAMES) : null;
+	const maxFrames = Math.max(1, options.animation?.maxFrames ?? MAX_ANIMATION_FRAMES);
+	const exact = interpolated ? null : changeTicks(animated.values().toArray(), ticks, maxFrames);
+	const candidates = exact ?? evenlySpacedTicks(ticks, maxFrames);
 	const frames = [];
 	const emitTicks = [];
 	let lastKey = null;
-	let sinceLast = 0;
-	for (let tick = 0; tick < ticks; tick++) {
-		sinceLast++;
-		const key = animated.values().map((texture) => texture.resolveFrame(tick).frame).toArray().join(",");
-		if (lastKey !== null && key === lastKey && !interpolated && tick !== ticks - 1) continue;
-		if (lastKey !== null && interpolated && maxSkippable !== null && sinceLast < maxSkippable && key === lastKey) continue;
+	const session = createSession();
+	for (const tick of candidates) {
+		const key = animated.values().map((texture) => {
+			const resolved = texture.resolveFrame(tick);
+			return texture.interpolated ? `${resolved.frame}+${resolved.interpolation}` : String(resolved.frame);
+		}).toArray().join(",");
+		if (key === lastKey) continue;
 		const supplier = async (reference) => {
 			if (skipped.has(reference)) return null;
 			const texture = animated.get(reference);
@@ -258,20 +263,59 @@ async function renderModelFrames(model, textures, options) {
 			return texture.at(tick);
 		};
 		const renderSize = options.size * options.quality;
-		const full = model.builtinParent === "builtin/generated" ? await renderGeneratedItemWith(model, supplier, renderSize, options.tints) : await renderElementModelWith(model, supplier, renderSize, options);
+		const full = model.builtinParent === "builtin/generated" ? await renderGeneratedItemWith(model, supplier, renderSize, options.tints) : await renderElementModelWith(model, supplier, renderSize, options, session);
 		frames.push(options.quality === 1 ? full : boxDownscale(full, options.quality));
 		emitTicks.push(tick);
 		lastKey = key;
-		sinceLast = 0;
 	}
 	return {
 		frames,
 		delaysMs: emitTicks.map((tick, index) => {
 			const next = index + 1 < emitTicks.length ? emitTicks[index + 1] : ticks;
 			return Math.max(TICK_MS, (next - tick) * TICK_MS);
-		})
+		}),
+		animation: {
+			ticks,
+			candidates: candidates.length,
+			sampled: exact === null && ticks > frames.length,
+			interpolated
+		}
 	};
 }
+/**
+* Every tick in the combined timeline where some texture switches frame, or
+* null once that exceeds `limit` — past that the caller samples instead, and
+* enumerating a multi-minute timeline in full would be the very cost this
+* bound exists to avoid.
+*/
+function changeTicks(textures, ticks, limit) {
+	const found = /* @__PURE__ */ new Set([0]);
+	for (const texture of textures) {
+		if (texture.frameCount <= 1) continue;
+		const period = Math.max(1, texture.tickLength);
+		const starts = texture.frameStartTicks();
+		for (let base = 0; base < ticks; base += period) for (const start of starts) {
+			const tick = base + start;
+			if (tick < ticks) found.add(tick);
+			if (found.size > limit) return null;
+		}
+	}
+	return [...found].toSorted((left, right) => left - right);
+}
+/** `count` tick positions spread evenly across the cycle, always starting at 0. */
+function evenlySpacedTicks(ticks, maxFrames) {
+	const count = Math.min(ticks, maxFrames);
+	const sampled = [];
+	let previous = -1;
+	for (let index = 0; index < count; index++) {
+		const tick = Math.floor(index * ticks / count);
+		if (tick !== previous) {
+			sampled.push(tick);
+			previous = tick;
+		}
+	}
+	return sampled;
+}
 async function loadAnimatedTexture(model, textures, reference) {
 	const locator = resolveTexture(model, reference);
 	if (locator) {
@@ -391,11 +435,23 @@ async function renderElementModel(model, textures, renderSize, options) {
 	};
 	return renderElementModelWith(model, supplier, renderSize, options);
 }
-async function renderElementModelWith(model, supplier, renderSize, options) {
+function createSession() {
+	return {
+		geometry: null,
+		order: null,
+		transformation: null,
+		scratch: null,
+		shadeCache: /* @__PURE__ */ new WeakMap(),
+		floatTextures: /* @__PURE__ */ new Map(),
+		faceBuffers: []
+	};
+}
+/** Interpolated frames are new objects every tick; don't grow without bound. */
+const MAX_CACHED_FLOAT_TEXTURES = 32;
+async function renderElementModelWith(model, supplier, renderSize, options, session = createSession()) {
 	const lights = lightsForProfile(options.lightingProfile);
 	const light = model.elementsGuiLight === "side" ? lights.side : lights.front;
 	const loadedTextures = /* @__PURE__ */ new Map();
-	const floatTextures = /* @__PURE__ */ new Map();
 	const load = (reference) => {
 		let pending = loadedTextures.get(reference);
 		if (!pending) {
@@ -404,47 +460,68 @@ async function renderElementModelWith(model, supplier, renderSize, options) {
 		}
 		return pending;
 	};
-	const faces = [];
+	if (!session.geometry) {
+		const geometry = [];
+		for (const element of model.elements) for (const face of buildElementFaces(element)) geometry.push({
+			geometry: face,
+			maxZ: faceMaxZ(face)
+		});
+		session.geometry = geometry;
+		session.order = geometry.map((_, index) => index).toSorted((left, right) => geometry[left].maxZ - geometry[right].maxZ);
+	}
+	const specs = session.geometry;
+	const order = session.order ?? [];
 	let skippedFaces = 0;
-	for (const element of model.elements) for (const geometry of buildElementFaces(element)) {
-		const texture = await load(geometry.textureRef);
-		if (!texture) {
-			skippedFaces++;
-			continue;
-		}
-		let float = floatTextures.get(texture);
+	let drawable = 0;
+	for (const spec of specs) if (await load(spec.geometry.textureRef)) drawable++;
+	else skippedFaces++;
+	if (drawable === 0 && skippedFaces > 0) throw new ItemRenderError(`Every face texture unresolved in ${model.locator} (would render invisible)`);
+	if (!session.transformation) {
+		const gui = model.display.gui;
+		const guiMatrix = displayMatrix(gui?.rotation ?? [
+			0,
+			0,
+			0
+		], gui?.translation ?? [
+			0,
+			0,
+			0
+		], gui?.scale ?? [
+			1,
+			1,
+			1
+		]);
+		session.transformation = multiply(guiMatrix, options.itemTransform ?? identity());
+	}
+	session.scratch ??= createFaceBuffer(renderSize, renderSize);
+	if (session.floatTextures.size > MAX_CACHED_FLOAT_TEXTURES) session.floatTextures.clear();
+	const buffers = [];
+	for (const index of order) {
+		const spec = specs[index];
+		const texture = await load(spec.geometry.textureRef);
+		if (!texture) continue;
+		let float = session.floatTextures.get(texture);
 		if (!float) {
 			float = toFloatTexture(texture);
-			floatTextures.set(texture, float);
+			session.floatTextures.set(texture, float);
 		}
-		faces.push({
-			geometry,
+		const cached = session.faceBuffers[index];
+		if (cached?.texture === float) {
+			if (cached.buffer) buffers.push(cached.buffer);
+			continue;
+		}
+		const face = {
+			geometry: spec.geometry,
 			texture: float,
 			light,
-			tint: geometry.tintIndex !== null ? options.tints?.[geometry.tintIndex] ?? null : null,
-			maxZ: faceMaxZ(geometry)
-		});
-	}
-	if (faces.length === 0 && skippedFaces > 0) throw new ItemRenderError(`Every face texture unresolved in ${model.locator} (would render invisible)`);
-	faces.sort((a, b) => a.maxZ - b.maxZ);
-	const gui = model.display.gui;
-	const guiMatrix = displayMatrix(gui?.rotation ?? [
-		0,
-		0,
-		0
-	], gui?.translation ?? [
-		0,
-		0,
-		0
-	], gui?.scale ?? [
-		1,
-		1,
-		1
-	]);
-	const transformation = multiply(guiMatrix, options.itemTransform ?? identity());
-	const buffers = [];
-	for (const face of faces) {
-		const buffer = renderFace(face, renderSize, renderSize, transformation);
+			tint: spec.geometry.tintIndex !== null ? options.tints?.[spec.geometry.tintIndex] ?? null : null,
+			maxZ: spec.maxZ
+		};
+		const buffer = renderFace(face, renderSize, renderSize, session.transformation, session.scratch, session.shadeCache);
+		session.faceBuffers[index] = {
+			texture: float,
+			buffer
+		};
 		if (buffer) buffers.push(buffer);
 	}
 	return combineFaceBuffers(renderSize, renderSize, buffers);

package/dist/{renderer-nbMCw1Pl.d.ts → renderer-DVsZHAvf.d.ts}

@@ -1,15 +1,21 @@
-import { a as ResourceManager } from "./manager-CoZaeQTu.js";
-import { i as TextureLoader } from "./loader-TFFNV4Jl.js";
-import { r as ResolvedModel } from "./loader-C-6QN3xv.js";
-import { t as FloatTexture } from "./blend-Qvrn6YgK.js";
+import { a as ResourceManager } from "./manager-Cv1NeFyF.js";
+import { i as TextureLoader } from "./loader-Myy22TDL.js";
+import { r as ResolvedModel } from "./loader-D22zZME7.js";
+import { t as FloatTexture } from "./blend-CyDIxCne.js";
 import { t as Mat4 } from "./vector-DRKRi4--.js";
 import { a as LightingProfileName } from "./lighting-3FGRC3Af.js";
-import { n as TintColor } from "./face-CpVdnf-w.js";
+import { r as TintColor } from "./face-BIYg14TE.js";
 //#region src/render/renderer.d.ts
+interface AnimationLimits {
+  /** Emitted frames per icon (default 128). */
+  maxFrames?: number;
+}
 interface RenderOptions {
   size: number;
   quality: number;
   lightingProfile: LightingProfileName;
+  /** Bounds on animated timelines; defaults apply when omitted. */
+  animation?: AnimationLimits;
   /** Accumulated item-definition transformation (inner matrix). */
   itemTransform?: Mat4;
   /** Tint colors by index (face tintindex / generated layer number). */
@@ -22,6 +28,17 @@ interface RenderedFrames {
   frames: FloatTexture[];
   /** Display duration per frame in milliseconds (50ms per game tick). */
   delaysMs: number[];
+  /** What the timeline did, so a bounded animation is never a silent one. */
+  animation?: AnimationDiagnostics;
+}
+interface AnimationDiagnostics {
+  /** Combined cycle length in game ticks (the lcm of the textures' periods). */
+  ticks: number;
+  /** Ticks considered before identical neighbours were coalesced. */
+  candidates: number;
+  /** Whether the frame cap forced even sampling instead of exact frames. */
+  sampled: boolean;
+  interpolated: boolean;
 }
 /**
  * Render every animation frame of a model (a single frame for unanimated
@@ -41,4 +58,4 @@ declare function pointResize(texture: FloatTexture, width: number, height: numbe
  */
 declare function boxDownscale(texture: FloatTexture, factor: number): FloatTexture;
 //#endregion
-export { pointResize as a, boxDownscale as i, RenderOptions as n, renderModel as o, RenderedFrames as r, renderModelFrames as s, ItemRenderError as t };
+export { RenderedFrames as a, renderModel as c, RenderOptions as i, renderModelFrames as l, AnimationLimits as n, boxDownscale as o, ItemRenderError as r, pointResize as s, AnimationDiagnostics as t };

package/dist/resources/cache.d.ts

@@ -0,0 +1,30 @@
+//#region src/resources/cache.d.ts
+/**
+ * Least-recently-used map used by the model and texture loaders. Their caches
+ * were unbounded, which is fine for one namespace and not fine for a run that
+ * walks thousands of them in a single process — resident memory only ever grew.
+ */
+declare class LruCache<K, V> {
+  private readonly entries;
+  private readonly maxEntries;
+  private readonly weigh;
+  private readonly maxWeight;
+  private readonly weights;
+  private weight;
+  constructor(maxEntries: number, options?: {
+    maxWeight?: number;
+    weigh?: (value: V) => number;
+  });
+  private evict;
+  get size(): number;
+  get(key: K): V | undefined;
+  set(key: K, value: V): void;
+  /**
+   * Record a value's real cost once it is known. Loaders cache promises, so the
+   * weight of a decoded texture only exists after it resolves.
+   */
+  settle(key: K, value: V): void;
+  clear(): void;
+}
+//#endregion
+export { LruCache };

package/dist/resources/cache.js

@@ -0,0 +1,2 @@
+import { t as LruCache } from "../cache-Cr2ON3RQ.js";
+export { LruCache };

package/dist/resources/descriptor.d.ts

@@ -0,0 +1,2 @@
+import { c as describeResources, l as restoreResources, o as DescribableResourceManager, s as ResourceDescriptor } from "../manager-Cv1NeFyF.js";
+export { DescribableResourceManager, ResourceDescriptor, describeResources, restoreResources };

package/dist/resources/descriptor.js

@@ -0,0 +1,2 @@
+import { n as restoreResources, t as describeResources } from "../descriptor-DWebtkI1.js";
+export { describeResources, restoreResources };

package/dist/resources/jar.d.ts

@@ -1,2 +1,2 @@
-import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "../jar-6T3xdgaL.js";
+import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "../jar-CFkA-VgT.js";
 export { JarResourceManager, UnsafeJarError, isUnsafeEntryPath };

package/dist/resources/jar.js

@@ -1,2 +1,2 @@
-import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "../jar-Bt3i0ls4.js";
+import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "../jar-D9z-X7tA.js";
 export { JarResourceManager, UnsafeJarError, isUnsafeEntryPath };

package/dist/resources/manager.d.ts

@@ -1,2 +1,2 @@
-import { a as ResourceManager, i as ResourceKindName, n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "../manager-CoZaeQTu.js";
+import { a as ResourceManager, i as ResourceKindName, n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "../manager-Cv1NeFyF.js";
 export { FolderResourceManager, LayeredResourceManager, ResourceKind, ResourceKindName, ResourceManager };

package/dist/resources/manager.js

@@ -1,2 +1,2 @@
-import { n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "../manager-dfI7b9N4.js";
+import { n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "../manager-CkletR5K.js";
 export { FolderResourceManager, LayeredResourceManager, ResourceKind };

package/dist/resources/synthetic.d.ts

@@ -1,2 +1,2 @@
-import { n as MapResourceManager, t as KindFilteredResourceManager } from "../synthetic-CDsj--li.js";
+import { n as MapResourceManager, t as KindFilteredResourceManager } from "../synthetic-Qk-BSUXO.js";
 export { KindFilteredResourceManager, MapResourceManager };

package/dist/resources/synthetic.js

@@ -1,2 +1,2 @@
-import { n as MapResourceManager, t as KindFilteredResourceManager } from "../synthetic-DC2bSnGe.js";
+import { n as MapResourceManager, t as KindFilteredResourceManager } from "../synthetic-ZAUjXT7E.js";
 export { KindFilteredResourceManager, MapResourceManager };

package/dist/resources/zip-reader.d.ts

@@ -0,0 +1,5 @@
+import { ZipFile } from "yauzl";
+//#region src/resources/zip-reader.d.ts
+declare function openZip(zipPath: string): Promise<ZipFile>;
+//#endregion
+export { openZip };

package/dist/resources/zip-reader.js

@@ -0,0 +1,2 @@
+import { t as openZip } from "../zip-reader-BSbJKUT1.js";
+export { openZip };

package/dist/run-BnICOF4I.js

@@ -0,0 +1,209 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import { n as discoverItems } from "./discovery-0SM0cTLw.js";
+import { r as encodeRasterAsset } from "./encode-D6dQu2dJ.js";
+import { t as classifyItemStyle } from "./item-styles-upgEO1yP.js";
+import { t as minifyStylesheet } from "./minify-bjMRmr5J.js";
+import { t as generateStylesheet } from "./stylesheet-CovT3B2S.js";
+import { t as ItemPipeline } from "./pipeline-BIk1RRIp.js";
+import { t as describeResources } from "./descriptor-DWebtkI1.js";
+import { t as WorkerRenderPool } from "./pool-CKGp1qup.js";
+import path from "node:path";
+import os from "node:os";
+import { mkdir, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+//#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.
+*
+* Items render in worker threads when the resource tree can describe itself
+* (see resources/descriptor.ts); otherwise the same pipeline runs in-process.
+*/
+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 settings = {
+		builtin: options.builtin,
+		output: options.output,
+		size,
+		quality,
+		format,
+		gif: options.gif,
+		avif: options.avif,
+		lightingProfile,
+		animation: options.animation
+	};
+	const concurrency = Math.max(1, options.concurrency ?? 8);
+	const requestedWorkers = resolveWorkerCount(options.workers);
+	const descriptor = requestedWorkers > 1 ? describeResources(options.resources) : null;
+	const pool = descriptor ? new WorkerRenderPool({
+		workerUrl: workerUrl(),
+		workerData: {
+			resources: descriptor,
+			settings,
+			sharpConcurrency: Math.max(1, Math.round(os.availableParallelism() / requestedWorkers))
+		},
+		workers: requestedWorkers,
+		inFlight: concurrency
+	}) : null;
+	const usedWorkers = pool ? requestedWorkers : 1;
+	const pipeline = await ItemPipeline.create(options.resources, settings).catch(async (err) => {
+		await pool?.close();
+		throw err;
+	});
+	const { resources } = pipeline;
+	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]);
+	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 (pipeline.dynamicItems && 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 id of pipeline.dynamicItems) if ((groupAvailable[id.split(":", 1)[0]] ?? true) && !seen.has(id)) {
+			seen.add(id);
+			ids.push(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());
+	};
+	let completed = 0;
+	const record = async (id, outcome, error) => {
+		if (outcome) {
+			writtenFiles += outcome.written;
+			rendered.push(id);
+			if (outcome.usedFallback) spriteFallbacks.push(id);
+		} else if (await isTemplateModel(id).catch(() => false)) skippedTemplates.push(id);
+		else failed.push({
+			id,
+			error: error ?? "Unknown render failure"
+		});
+		completed++;
+		options.onProgress?.(completed, ids.length, id, outcome ? void 0 : error);
+	};
+	if (pool) {
+		const pending = [];
+		await pool.run(ids.map((id) => {
+			return { id };
+		}), (message) => {
+			pending.push(record(message.id, message.result ?? null, message.error));
+		});
+		await Promise.all(pending);
+	} else {
+		let nextIndex = 0;
+		await Promise.all(Array.from({ length: Math.min(concurrency, ids.length) }, async () => {
+			while (nextIndex < ids.length) {
+				const id = ids[nextIndex++];
+				try {
+					await record(id, await pipeline.renderItem(id));
+				} catch (err) {
+					await record(id, null, err.message);
+				}
+			}
+		}));
+	}
+	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,
+		workers: usedWorkers
+	};
+}
+/**
+* One thread per core less the orchestrator, capped at 8: measured throughput
+* on a 16-thread host peaks around 4-8 workers and falls off above that, where
+* per-worker asset caches and libvips threads start competing for the same cores.
+*/
+function resolveWorkerCount(requested) {
+	if (requested !== void 0) return Math.max(1, Math.floor(requested));
+	return Math.min(8, Math.max(1, os.availableParallelism() - 1));
+}
+/** The worker's own file, in whichever form this module was loaded from. */
+function workerUrl() {
+	const extension = path.extname(fileURLToPath(import.meta.url)) || ".js";
+	return new URL(`./workers/render-worker${extension}`, import.meta.url);
+}
+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;
+}
+//#endregion
+export { run as t };

package/dist/{run-BlSZw9Qk.d.ts → run-CKUtynTy.d.ts}

@@ -1,5 +1,6 @@
-import { a as ResourceManager } from "./manager-CoZaeQTu.js";
+import { a as ResourceManager } from "./manager-Cv1NeFyF.js";
 import { a as LightingProfileName } from "./lighting-3FGRC3Af.js";
+import { n as AnimationLimits } from "./renderer-DVsZHAvf.js";
 //#region src/run.d.ts
 interface RunOptions {
   resources: ResourceManager;
@@ -22,8 +23,15 @@ interface RunOptions {
   avif?: boolean;
   /** Minify the stylesheet via lightningcss (default true). */
   minify?: boolean;
-  /** In-flight items (encode overlaps on libvips' threadpool; default 8). */
+  /** In-flight items per thread (encode overlaps on libvips' threadpool; default 8). */
   concurrency?: number;
+  /**
+   * Render threads. Defaults to one per core (minus the main thread). 1 renders
+   * in-process; a resource tree that cannot be described falls back to that too.
+   */
+  workers?: number;
+  /** Bounds on animated timelines (frame count). */
+  animation?: AnimationLimits;
   /**
    * Drop classic item models with no matching translation (default true).
    * Disable for a prepared asset tree whose own preprocessing has already
@@ -54,6 +62,8 @@ interface RunResult {
   skippedTemplates: string[];
   /** Image files actually written, the only trustworthy success signal. */
   writtenFiles: number;
+  /** Worker threads used; 1 means everything rendered in-process. */
+  workers: number;
 }
 declare function run(options: RunOptions): Promise<RunResult>;
 //#endregion

package/dist/run.d.ts

@@ -1,3 +1,3 @@
 import { l as evaluateItemModel } from "./definition-BwX6Xxv0.js";
-import { i as run, n as RunOptions, r as RunResult, t as ItemFailure } from "./run-BlSZw9Qk.js";
+import { i as run, n as RunOptions, r as RunResult, t as ItemFailure } from "./run-CKUtynTy.js";
 export { ItemFailure, RunOptions, RunResult, evaluateItemModel, run };

package/dist/run.js

@@ -1,3 +1,3 @@
 import { o as evaluateItemModel } from "./definition-3MBm8ar_.js";
-import { t as run } from "./run-CfnWIRY4.js";
+import { t as run } from "./run-BnICOF4I.js";
 export { evaluateItemModel, run };

package/dist/{sources-DH9dk3KF.d.ts → sources-B9X9w3qP.d.ts}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
-import { r as Texture } from "./loader-TFFNV4Jl.js";
+import { r as Texture } from "./loader-Myy22TDL.js";
 //#region src/atlas/sources.d.ts
 declare class AtlasSourceError extends Error {}
 interface AtlasSource {