@nodecraft/rendermite 1.0.5 → 1.0.6

package/dist/{jar-Bt3i0ls4.js → jar-D9z-X7tA.js}

@@ -1,6 +1,6 @@
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { r as ResourceKind } from "./manager-dfI7b9N4.js";
-import { open } from "yauzl";
+import { r as ResourceKind } from "./manager-CkletR5K.js";
+import { t as openZip } from "./zip-reader-BSbJKUT1.js";
 //#region src/resources/jar.ts
 /**
 * Reads resources directly out of a jar/zip — no extraction step, unlike the
@@ -19,15 +19,9 @@ var JarResourceManager = class {
 		this.jarPath = jarPath;
 	}
 	getIndex() {
-		this.index ??= new Promise((resolve, reject) => {
-			open(this.jarPath, {
-				lazyEntries: true,
-				autoClose: false
-			}, (err, zip) => {
-				if (err) {
-					reject(err);
-					return;
-				}
+		this.index ??= (async () => {
+			const zip = await openZip(this.jarPath);
+			return new Promise((resolve, reject) => {
 				const entries = /* @__PURE__ */ new Map();
 				const entriesLower = /* @__PURE__ */ new Map();
 				const namespaces = /* @__PURE__ */ new Set();
@@ -55,7 +49,7 @@ var JarResourceManager = class {
 				zip.on("error", reject);
 				zip.readEntry();
 			});
-		});
+		})();
 		return this.index;
 	}
 	entryPath(kind, locator) {
@@ -108,6 +102,12 @@ var JarResourceManager = class {
 	async listNamespaces() {
 		return [...(await this.getIndex()).namespaces].toSorted((left, right) => left.localeCompare(right));
 	}
+	describe() {
+		return {
+			kind: "jar",
+			path: this.jarPath
+		};
+	}
 	async close() {
 		if (this.index) {
 			(await this.index).zip.close();

package/dist/{legacy-reshape-CewShfF3.js → legacy-reshape-C05SfAPR.js}

@@ -1,4 +1,4 @@
-import { n as MapResourceManager } from "./synthetic-DC2bSnGe.js";
+import { n as MapResourceManager } from "./synthetic-ZAUjXT7E.js";
 import { open } from "yauzl";
 import sharp from "sharp";
 //#region src/versions/legacy-reshape.ts

package/dist/{loader-A-BZa8J4.js → loader-B8NJO7pR.js}

@@ -1,4 +1,5 @@
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import { t as LruCache } from "./cache-Cr2ON3RQ.js";
 //#region src/models/loader.ts
 var ModelResolutionError = class extends Error {};
 const MAX_PARENT_DEPTH = 64;
@@ -248,12 +249,20 @@ function salvageJson(text) {
 	}
 	return null;
 }
+/**
+* Resolved models and their source JSON are small but there are a lot of them:
+* a full modded run walks thousands of namespaces in one process, so the caches
+* are bounded rather than kept for the life of the run.
+*/
+const MAX_CACHED_MODELS = 4096;
 var ModelLoader = class {
 	resources;
-	cache = /* @__PURE__ */ new Map();
-	jsonCache = /* @__PURE__ */ new Map();
-	constructor(resources) {
+	cache;
+	jsonCache;
+	constructor(resources, maxCachedModels = MAX_CACHED_MODELS) {
 		this.resources = resources;
+		this.cache = new LruCache(maxCachedModels);
+		this.jsonCache = new LruCache(maxCachedModels);
 	}
 	readModelJson(locator) {
 		const key = locator.toString();

package/dist/{loader-CBzn3Koc.js → loader-CfXMxcEV.js}

@@ -1,6 +1,10 @@
+import { t as LruCache } from "./cache-Cr2ON3RQ.js";
 import sharp from "sharp";
 //#region src/textures/loader.ts
 var TextureResolutionError = class extends Error {};
+/** Decoded-pixel budget and hard entry cap for one loader's texture cache. */
+const MAX_TEXTURE_CACHE_BYTES = 134217728;
+const MAX_TEXTURE_CACHE_ENTRIES = 8192;
 /**
 * Animation-aware texture access: frame extraction over strips and grids with
 * mcmeta frame lists, per-frame times, and interpolation (upstream semantics:
@@ -42,6 +46,25 @@ var AnimatedTexture = class {
 		}
 		return this.frameCount * frameTime;
 	}
+	/**
+	* Ticks within one cycle at which the displayed frame changes. Used to emit
+	* exactly the frames an animation actually has instead of walking every tick
+	* of a combined timeline that can run to tens of thousands.
+	*/
+	frameStartTicks() {
+		const animation = this.meta?.animation;
+		if (!animation || this.frameCount <= 1) return [0];
+		const frameTime = animation.frametime ?? 1;
+		const frames = animation.frames;
+		if (!frames?.length) return Array.from({ length: this.frameCount }, (_, index) => index * frameTime);
+		const starts = [];
+		let tick = 0;
+		for (const entry of frames) {
+			starts.push(tick);
+			tick += typeof entry === "number" ? frameTime : entry.time ?? frameTime;
+		}
+		return starts;
+	}
 	/** Which physical frame index shows at a tick, and the interpolation factor. */
 	resolveFrame(tick) {
 		const animation = this.meta?.animation;
@@ -107,10 +130,14 @@ var AnimatedTexture = class {
 };
 var TextureLoader = class {
 	resources;
-	cache = /* @__PURE__ */ new Map();
+	cache;
 	atlas = null;
-	constructor(resources) {
+	constructor(resources, maxCacheBytes = MAX_TEXTURE_CACHE_BYTES) {
 		this.resources = resources;
+		this.cache = new LruCache(MAX_TEXTURE_CACHE_ENTRIES, {
+			maxWeight: maxCacheBytes,
+			weigh: (pending) => pending.bytes ?? 0
+		});
 	}
 	async decode(locator) {
 		let raw = await this.resources.getResource("texture", locator);
@@ -183,11 +210,14 @@ var TextureLoader = class {
 	*/
 	async load(locator) {
 		const key = locator.toString();
-		let pending = this.cache.get(key);
-		if (!pending) {
-			pending = this.decode(locator);
-			this.cache.set(key, pending);
-		}
+		const cached = this.cache.get(key);
+		if (cached) return cached;
+		const pending = this.decode(locator);
+		this.cache.set(key, pending);
+		pending.then((texture) => {
+			Object.assign(pending, { bytes: texture ? texture.data.length : 0 });
+			this.cache.settle(key, pending);
+		}).catch(() => {});
 		return pending;
 	}
 };

package/dist/{loader-C-6QN3xv.d.ts → loader-D22zZME7.d.ts}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
-import { a as ResourceManager } from "./manager-CoZaeQTu.js";
+import { a as ResourceManager } from "./manager-Cv1NeFyF.js";
 import { c as ModelJson, n as DisplayTransformJson, o as ModelElementJson, t as DisplayPosition } from "./types-COGbtA1t.js";
 //#region src/models/loader.d.ts
 /**
@@ -54,7 +54,7 @@ declare class ModelLoader {
   private readonly resources;
   private readonly cache;
   private readonly jsonCache;
-  constructor(resources: ResourceManager);
+  constructor(resources: ResourceManager, maxCachedModels?: number);
   private readModelJson;
   private loadModelJson;
   private resolve;

package/dist/{loader-TFFNV4Jl.d.ts → loader-Myy22TDL.d.ts}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
-import { a as ResourceManager } from "./manager-CoZaeQTu.js";
+import { a as ResourceManager } from "./manager-Cv1NeFyF.js";
 //#region src/textures/loader.d.ts
 /** Structural interface for atlas resolvers (avoids a circular module edge). */
 interface AtlasResolverLike {
@@ -48,6 +48,12 @@ declare class AnimatedTexture {
   get interpolated(): boolean;
   /** Total animation length in game ticks (1 for unanimated). */
   get tickLength(): number;
+  /**
+   * Ticks within one cycle at which the displayed frame changes. Used to emit
+   * exactly the frames an animation actually has instead of walking every tick
+   * of a combined timeline that can run to tens of thousands.
+   */
+  frameStartTicks(): number[];
   /** Which physical frame index shows at a tick, and the interpolation factor. */
   resolveFrame(tick: number): {
     frame: number;
@@ -62,7 +68,7 @@ declare class TextureLoader {
   private readonly resources;
   private readonly cache;
   private atlas;
-  constructor(resources: ResourceManager);
+  constructor(resources: ResourceManager, maxCacheBytes?: number);
   private decode;
   private readMeta;
   /**

package/dist/{manager-dfI7b9N4.js → manager-CkletR5K.js}

@@ -1,7 +1,7 @@
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
 import path from "node:path";
 import { existsSync } from "node:fs";
-import { readFile, readdir } from "node:fs/promises";
+import { readFile, readdir, stat } from "node:fs/promises";
 //#region src/resources/manager.ts
 /**
 * A category of resource inside a pack, mapping to a directory under
@@ -65,7 +65,11 @@ var FolderResourceManager = class {
 		}
 	}
 	async hasResource(kind, locator) {
-		return await this.getResource(kind, locator) !== null;
+		try {
+			return (await stat(this.resolve(kind, locator))).isFile();
+		} catch {
+			return false;
+		}
 	}
 	async getAllResources(kind, locator) {
 		const resource = await this.getResource(kind, locator);
@@ -102,6 +106,12 @@ var FolderResourceManager = class {
 			throw err;
 		}
 	}
+	describe() {
+		return {
+			kind: "folder",
+			root: this.root
+		};
+	}
 };
 /**
 * Layers several managers; earlier managers win, matching resource-pack precedence.
@@ -145,6 +155,23 @@ var LayeredResourceManager = class {
 		for (const layer of this.layers) for (const namespace of await layer.listNamespaces()) namespaces.add(namespace);
 		return [...namespaces].toSorted((left, right) => left.localeCompare(right));
 	}
+	describe() {
+		const layers = [];
+		for (const layer of this.layers) {
+			const described = describeLayer(layer);
+			if (!described) return null;
+			layers.push(described);
+		}
+		return {
+			kind: "layered",
+			layers
+		};
+	}
 };
+/** Local copy of describeResources, avoiding an import cycle with descriptor.ts. */
+function describeLayer(manager) {
+	const describable = manager;
+	return typeof describable.describe === "function" ? describable.describe() : null;
+}
 //#endregion
 export { LayeredResourceManager as n, ResourceKind as r, FolderResourceManager as t };

package/dist/{manager-CoZaeQTu.d.ts → manager-Cv1NeFyF.d.ts}

@@ -1,4 +1,29 @@
 import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
+//#region src/resources/descriptor.d.ts
+type ResourceDescriptor = {
+  kind: 'folder';
+  root: string;
+} | {
+  kind: 'jar';
+  path: string;
+} | {
+  kind: 'map';
+  entries: Array<[string, Uint8Array]>;
+} | {
+  kind: 'layered';
+  layers: ResourceDescriptor[];
+} | {
+  kind: 'kindFiltered';
+  inner: ResourceDescriptor;
+  kinds: ResourceKindName[];
+};
+/** Managers that can cross a worker boundary implement this. */
+interface DescribableResourceManager extends ResourceManager {
+  describe(): ResourceDescriptor | null;
+}
+declare function describeResources(manager: ResourceManager): ResourceDescriptor | null;
+declare function restoreResources(descriptor: ResourceDescriptor): ResourceManager;
+//#endregion
 //#region src/resources/manager.d.ts
 /**
  * A category of resource inside a pack, mapping to a directory under
@@ -70,6 +95,7 @@ declare class FolderResourceManager implements ResourceManager {
   getAllResources(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer[]>;
   listResources(kind: ResourceKindName, namespace: string): Promise<ResourceLocator[]>;
   listNamespaces(): Promise<string[]>;
+  describe(): ResourceDescriptor;
 }
 /**
  * Layers several managers; earlier managers win, matching resource-pack precedence.
@@ -83,6 +109,7 @@ declare class LayeredResourceManager implements ResourceManager {
   getAllResources(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer[]>;
   listResources(kind: ResourceKindName, namespace: string): Promise<ResourceLocator[]>;
   listNamespaces(): Promise<string[]>;
+  describe(): ResourceDescriptor | null;
 }
 //#endregion
-export { ResourceManager as a, ResourceKindName as i, LayeredResourceManager as n, ResourceKind as r, FolderResourceManager as t };
+export { ResourceManager as a, describeResources as c, ResourceKindName as i, restoreResources as l, LayeredResourceManager as n, DescribableResourceManager as o, ResourceKind as r, ResourceDescriptor as s, FolderResourceManager as t };

package/dist/models/loader.d.ts

@@ -1,2 +1,2 @@
-import { a as resolveTexture, i as flattenLoaderModel, n as ModelResolutionError, o as salvageJson, r as ResolvedModel, t as ModelLoader } from "../loader-C-6QN3xv.js";
+import { a as resolveTexture, i as flattenLoaderModel, n as ModelResolutionError, o as salvageJson, r as ResolvedModel, t as ModelLoader } from "../loader-D22zZME7.js";
 export { ModelLoader, ModelResolutionError, ResolvedModel, flattenLoaderModel, resolveTexture, salvageJson };

package/dist/models/loader.js

@@ -1,2 +1,2 @@
-import { a as salvageJson, i as resolveTexture, n as ModelResolutionError, r as flattenLoaderModel, t as ModelLoader } from "../loader-A-BZa8J4.js";
+import { a as salvageJson, i as resolveTexture, n as ModelResolutionError, r as flattenLoaderModel, t as ModelLoader } from "../loader-B8NJO7pR.js";
 export { ModelLoader, ModelResolutionError, flattenLoaderModel, resolveTexture, salvageJson };

package/dist/mods/prepare.d.ts

@@ -1,2 +1,2 @@
-import { i as prepareModResources, n as ModPreparation, r as PrepareModsOptions, t as LOADER_NAMESPACES } from "../prepare-gfR1aIjt.js";
+import { i as prepareModResources, n as ModPreparation, r as PrepareModsOptions, t as LOADER_NAMESPACES } from "../prepare-CPxO0kKz.js";
 export { LOADER_NAMESPACES, ModPreparation, PrepareModsOptions, prepareModResources };

package/dist/mods/prepare.js

@@ -1,2 +1,2 @@
-import { n as prepareModResources, t as LOADER_NAMESPACES } from "../prepare-BeUpXwaP.js";
+import { n as prepareModResources, t as LOADER_NAMESPACES } from "../prepare-BESRrh6K.js";
 export { LOADER_NAMESPACES, prepareModResources };

package/dist/mods/synthesize.d.ts

@@ -1,5 +1,5 @@
-import { a as ResourceManager } from "../manager-CoZaeQTu.js";
-import { n as MapResourceManager } from "../synthetic-CDsj--li.js";
+import { a as ResourceManager } from "../manager-Cv1NeFyF.js";
+import { n as MapResourceManager } from "../synthetic-Qk-BSUXO.js";
 //#region src/mods/synthesize.d.ts
 interface SynthesisResult {
   models: MapResourceManager;

package/dist/mods/synthesize.js

@@ -1,2 +1,2 @@
-import { t as synthesizeItemModels } from "../synthesize-CRgSEmEp.js";
+import { t as synthesizeItemModels } from "../synthesize-3Q0aaOnK.js";
 export { synthesizeItemModels };

package/dist/mods/tints.d.ts

@@ -1,5 +1,5 @@
-import { a as ResourceManager } from "../manager-CoZaeQTu.js";
-import { n as MapResourceManager } from "../synthetic-CDsj--li.js";
+import { a as ResourceManager } from "../manager-Cv1NeFyF.js";
+import { n as MapResourceManager } from "../synthetic-Qk-BSUXO.js";
 //#region src/mods/tints.d.ts
 interface HarvestTintsOptions {
   /** Assets from 1.21.4+ releases of the same mods, read only for their tints. */

package/dist/mods/tints.js

@@ -1,2 +1,2 @@
-import { n as harvestTintOverrides, t as curatedTintOverrides } from "../tints-CuG6GwQJ.js";
+import { n as harvestTintOverrides, t as curatedTintOverrides } from "../tints-B8UJmZMu.js";
 export { curatedTintOverrides, harvestTintOverrides };

package/dist/output/encode.d.ts

@@ -1,2 +1,2 @@
-import { a as RasterAssetFormat, c as encodeRasterAsset, i as EncodedIcon, n as EncodeOptions, o as encodeAnimatedIcon, r as EncodedAnimatedIcon, s as encodeIcon, t as AnimatedEncodeOptions } from "../encode-C5kdAm45.js";
+import { a as RasterAssetFormat, c as encodeRasterAsset, i as EncodedIcon, n as EncodeOptions, o as encodeAnimatedIcon, r as EncodedAnimatedIcon, s as encodeIcon, t as AnimatedEncodeOptions } from "../encode-DaNQF28M.js";
 export { AnimatedEncodeOptions, EncodeOptions, EncodedAnimatedIcon, EncodedIcon, RasterAssetFormat, encodeAnimatedIcon, encodeIcon, encodeRasterAsset };

package/dist/output/encode.js

@@ -1,2 +1,2 @@
-import { n as encodeIcon, r as encodeRasterAsset, t as encodeAnimatedIcon } from "../encode-3u49i-eD.js";
+import { n as encodeIcon, r as encodeRasterAsset, t as encodeAnimatedIcon } from "../encode-D6dQu2dJ.js";
 export { encodeAnimatedIcon, encodeIcon, encodeRasterAsset };

package/dist/output/item-styles.js

@@ -1,2 +1,2 @@
-import { t as classifyItemStyle } from "../item-styles-DJ3LWZS2.js";
+import { t as classifyItemStyle } from "../item-styles-upgEO1yP.js";
 export { classifyItemStyle };

package/dist/pipeline-BIk1RRIp.js

@@ -0,0 +1,221 @@
+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-CkletR5K.js";
+import { r as resolveItem } from "./discovery-0SM0cTLw.js";
+import { s as toFloatTexture, t as blendPixel } from "./blend-CHP2-j9U.js";
+import { t as encodeAnimatedIcon } from "./encode-D6dQu2dJ.js";
+import { a as builtinDynamicResources } from "./generators-BlG4KmtP.js";
+import { t as ModelLoader } from "./loader-B8NJO7pR.js";
+import { a as renderModelFrames, i as renderModel, n as boxDownscale, r as pointResize } from "./renderer-CjT19tHd.js";
+import { n as renderEntityFallback, r as spawnEggTints, t as renderDyedVariantFallback } from "./entity-fallback-BRCeGKBT.js";
+import { i as renderGeo, t as findGeoForItem } from "./geo-Diky41Tw.js";
+import { t as legacyTintsForChain } from "./legacy-tints-B09J0Rxh.js";
+import { a as resolveTints } from "./tints-BtbHegpI.js";
+import { t as loadAtlasResolver } from "./registry-B9TcjVbs.js";
+import { n as TextureLoader } from "./loader-CfXMxcEV.js";
+import path from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+//#region src/render/pipeline.ts
+/**
+* The per-item pipeline: asset layering, model/texture loading, the render
+* fallback chain, encoding, and file output. Extracted from run() so a worker
+* thread renders items exactly the way the main thread does — a second
+* implementation would drift, and the failure taxonomy depends on the fallback
+* order being identical everywhere.
+*/
+var ItemPipeline = class ItemPipeline {
+	static async create(base, settings) {
+		const dynamic = settings.builtin ? builtinDynamicResources() : null;
+		const resources = settings.builtin && dynamic ? new LayeredResourceManager([
+			new FolderResourceManager(settings.builtin),
+			dynamic.layer,
+			base
+		]) : base;
+		const pipeline = new ItemPipeline(resources, dynamic?.items.map((item) => item.id) ?? null, settings);
+		pipeline.textures.setAtlasResolver(await loadAtlasResolver(resources, (locator) => pipeline.textures.load(locator)));
+		return pipeline;
+	}
+	settings;
+	models;
+	textures;
+	createdDirectories = /* @__PURE__ */ new Set();
+	/** The layered tree actually rendered (builtin + dynamic above the input). */
+	resources;
+	/** Dynamic vanilla items (trims, pots, crossbows), or null without a builtin pack. */
+	dynamicItems;
+	constructor(resources, dynamicItems, settings) {
+		this.resources = resources;
+		this.dynamicItems = dynamicItems;
+		this.settings = settings;
+		this.models = new ModelLoader(resources);
+		this.textures = new TextureLoader(resources);
+	}
+	/**
+	* 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.
+	*/
+	async spriteFallback(id) {
+		const { size, quality } = this.settings;
+		const locator = ResourceLocator.parse(id);
+		for (const directory of ["item", "items"]) {
+			const texture = await this.textures.load(new ResourceLocator(locator.namespace, `${directory}/${locator.path}`));
+			if (texture) {
+				const upscaled = pointResize(toFloatTexture(texture), size * quality, size * quality);
+				return quality === 1 ? upscaled : boxDownscale(upscaled, quality);
+			}
+		}
+		return null;
+	}
+	/** Render an item's frames from its own model, without any fallback. */
+	async renderFrames(id) {
+		const { size, quality, lightingProfile, animation } = this.settings;
+		const { resources, models, textures } = this;
+		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,
+				animation
+			});
+			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 ?? blankFrame(size)];
+			delaysMs = [50];
+		}
+		if (frames.length === 0) {
+			frames = [blankFrame(size)];
+			delaysMs = [50];
+		}
+		return {
+			frames,
+			delaysMs
+		};
+	}
+	/**
+	* Frames for an item, falling back through the same-name block model,
+	* GeckoLib geometry, builtin entity geometry, dyed variants, and finally the
+	* flat sprite. Rethrows the item's own error when nothing draws it.
+	*/
+	async renderFramesWithFallback(id) {
+		try {
+			return {
+				...await this.renderFrames(id),
+				usedFallback: false
+			};
+		} catch (err) {
+			const { size, quality, lightingProfile, builtin } = this.settings;
+			const { resources, models, textures } = this;
+			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 ??= 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) return {
+				frames: [fallbackRender],
+				delaysMs: [50],
+				usedFallback: false
+			};
+			const sprite = await this.spriteFallback(id).catch(() => null);
+			if (!sprite) throw err;
+			return {
+				frames: [sprite],
+				delaysMs: [50],
+				usedFallback: true
+			};
+		}
+	}
+	/** Render, encode and write one item. Throws when the item cannot be drawn. */
+	async renderItem(id) {
+		const { frames, delaysMs, usedFallback } = await this.renderFramesWithFallback(id);
+		const encoded = await encodeAnimatedIcon(frames, delaysMs, {
+			webp: true,
+			gif: this.settings.gif,
+			avif: this.settings.avif || this.settings.format === "avif"
+		});
+		const [namespace, itemPath] = id.split(":", 2);
+		const imageBase = path.join(this.settings.output, "items", namespace, itemPath);
+		const directory = path.dirname(imageBase);
+		if (!this.createdDirectories.has(directory)) {
+			await mkdir(directory, { recursive: true });
+			this.createdDirectories.add(directory);
+		}
+		await writeFile(`${imageBase}.png`, encoded.png);
+		let written = 1;
+		for (const [extension, buffer] of [
+			["webp", encoded.webp],
+			["gif", encoded.gif],
+			["avif", encoded.avif]
+		]) {
+			if (!buffer) continue;
+			await writeFile(`${imageBase}.${extension}`, buffer);
+			written++;
+		}
+		return {
+			written,
+			usedFallback
+		};
+	}
+};
+function blankFrame(size) {
+	return {
+		width: size,
+		height: size,
+		data: new Float64Array(size * size * 4)
+	};
+}
+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 { ItemPipeline as t };

package/dist/pipeline-zq-yU3Te.d.ts

@@ -0,0 +1,58 @@
+import { a as ResourceManager } from "./manager-Cv1NeFyF.js";
+import { t as FloatTexture } from "./blend-CyDIxCne.js";
+import { a as LightingProfileName } from "./lighting-3FGRC3Af.js";
+import { n as AnimationLimits } from "./renderer-DVsZHAvf.js";
+//#region src/render/pipeline.d.ts
+interface PipelineSettings {
+  builtin?: string;
+  output: string;
+  size: number;
+  quality: number;
+  format: 'webp' | 'avif';
+  gif?: boolean;
+  avif?: boolean;
+  lightingProfile: LightingProfileName;
+  animation?: AnimationLimits;
+}
+interface ItemRenderOutcome {
+  /** Image files written for the item. */
+  written: number;
+  /** Whether the item fell back to its flat sprite instead of its model. */
+  usedFallback: boolean;
+}
+interface RenderedFrames {
+  frames: FloatTexture[];
+  delaysMs: number[];
+}
+declare class ItemPipeline {
+  static create(base: ResourceManager, settings: PipelineSettings): Promise<ItemPipeline>;
+  private readonly settings;
+  private readonly models;
+  private readonly textures;
+  private readonly createdDirectories;
+  /** The layered tree actually rendered (builtin + dynamic above the input). */
+  readonly resources: ResourceManager;
+  /** Dynamic vanilla items (trims, pots, crossbows), or null without a builtin pack. */
+  readonly dynamicItems: string[] | null;
+  private constructor();
+  /**
+   * 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.
+   */
+  private spriteFallback;
+  /** Render an item's frames from its own model, without any fallback. */
+  renderFrames(id: string): Promise<RenderedFrames>;
+  /**
+   * Frames for an item, falling back through the same-name block model,
+   * GeckoLib geometry, builtin entity geometry, dyed variants, and finally the
+   * flat sprite. Rethrows the item's own error when nothing draws it.
+   */
+  renderFramesWithFallback(id: string): Promise<RenderedFrames & {
+    usedFallback: boolean;
+  }>;
+  /** Render, encode and write one item. Throws when the item cannot be drawn. */
+  renderItem(id: string): Promise<ItemRenderOutcome>;
+}
+//#endregion
+export { RenderedFrames as i, ItemRenderOutcome as n, PipelineSettings as r, ItemPipeline as t };