@nodecraft/rendermite 1.0.4 → 1.0.6

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 };

package/dist/pool-CKGp1qup.js

@@ -0,0 +1,131 @@
+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 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.
+*/
+var WorkerRenderPool = class {
+	options;
+	inFlightLimit;
+	workers = /* @__PURE__ */ new Set();
+	tasks = [];
+	cursor = 0;
+	started = false;
+	onResult = null;
+	settle = null;
+	settled = false;
+	/** Workers dying before completing anything mean a bad config, not bad luck. */
+	startupFailures = 0;
+	constructor(options) {
+		this.options = options;
+		this.inFlightLimit = Math.max(1, options.inFlight ?? 2);
+		for (let i = 0; i < Math.max(1, options.workers); i++) this.spawn();
+	}
+	spawn() {
+		const entry = {
+			worker: new Worker(this.options.workerUrl, { workerData: this.options.workerData }),
+			inFlight: /* @__PURE__ */ new Set(),
+			ready: false,
+			stopped: false
+		};
+		this.workers.add(entry);
+		entry.worker.on("message", (message) => {
+			if ("ready" in message) entry.ready = true;
+			else {
+				entry.inFlight.delete(message.id);
+				this.startupFailures = 0;
+				this.onResult?.(message);
+			}
+			this.pump(entry);
+		});
+		entry.worker.on("error", (err) => {
+			if (entry.inFlight.size === 0) {
+				this.startupFailures++;
+				if (this.startupFailures > 3) {
+					this.abort(err);
+					return;
+				}
+			}
+			this.fail(entry, `Worker crashed: ${err.message}`);
+		});
+		entry.worker.on("exit", (code) => {
+			if (code !== 0) this.fail(entry, `Worker exited with code ${code}`);
+		});
+	}
+	pump(entry) {
+		if (!this.started || entry.stopped || !entry.ready) return;
+		while (entry.inFlight.size < this.inFlightLimit && this.cursor < this.tasks.length) {
+			const task = this.tasks[this.cursor++];
+			entry.inFlight.add(task.id);
+			entry.worker.postMessage(task);
+		}
+		if (entry.inFlight.size === 0 && this.cursor >= this.tasks.length) this.retire(entry);
+	}
+	retire(entry) {
+		if (entry.stopped) return;
+		entry.stopped = true;
+		this.workers.delete(entry);
+		entry.worker.terminate().catch(() => {});
+		this.finish();
+	}
+	fail(entry, reason) {
+		if (entry.stopped) return;
+		for (const id of entry.inFlight) this.onResult?.({
+			id,
+			error: reason
+		});
+		entry.inFlight.clear();
+		entry.stopped = true;
+		this.workers.delete(entry);
+		if (this.started && this.cursor < this.tasks.length) this.spawn();
+		else this.finish();
+	}
+	finish() {
+		if (!this.settled && this.started && this.workers.size === 0) {
+			this.settled = true;
+			this.settle?.resolve();
+		}
+	}
+	abort(err) {
+		if (this.settled) return;
+		this.settled = true;
+		for (const entry of this.workers) {
+			entry.stopped = true;
+			entry.worker.terminate().catch(() => {});
+		}
+		this.workers.clear();
+		this.settle?.reject(err);
+	}
+	/** Run every task, calling back as results arrive. Terminates the pool after. */
+	async run(tasks, onResult) {
+		this.tasks = tasks;
+		this.onResult = onResult;
+		this.started = true;
+		try {
+			if (tasks.length > 0) await new Promise((resolve, reject) => {
+				this.settle = {
+					resolve,
+					reject
+				};
+				for (const entry of this.workers) this.pump(entry);
+			});
+		} finally {
+			await this.close();
+		}
+	}
+	async close() {
+		const workers = [...this.workers];
+		this.workers.clear();
+		await Promise.all(workers.map((entry) => entry.worker.terminate().catch(() => {})));
+	}
+};
+//#endregion
+export { WorkerRenderPool as t };

package/dist/{prepare-Bvc5ve2m.js → prepare-BESRrh6K.js}

@@ -1,6 +1,7 @@
-import { n as LayeredResourceManager } from "./manager-dfI7b9N4.js";
-import { n as UnsafeJarError, t as JarResourceManager } from "./jar-Bt3i0ls4.js";
-import { t as synthesizeItemModels } from "./synthesize-CRgSEmEp.js";
+import { n as LayeredResourceManager } from "./manager-CkletR5K.js";
+import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-B8UJmZMu.js";
+import { n as UnsafeJarError, t as JarResourceManager } from "./jar-D9z-X7tA.js";
+import { t as synthesizeItemModels } from "./synthesize-3Q0aaOnK.js";
 //#region src/mods/prepare.ts
 /**
 * Mod asset composition: mod jars layered under the vanilla base (vanilla wins
@@ -43,7 +44,11 @@ async function prepareModResources(options) {
 			await manager.close().catch(() => {});
 		}
 	}
-	const base = new LayeredResourceManager([options.vanilla, ...jarLayers]);
+	const base = new LayeredResourceManager([
+		options.vanilla,
+		curatedTintOverrides(),
+		...jarLayers
+	]);
 	const namespaces = [];
 	let synthesized = 0;
 	const synthLayers = [];
@@ -57,10 +62,33 @@ async function prepareModResources(options) {
 			options.onProgress?.(`Synthesized ${result.synthesized} item models for ${namespace}`);
 		}
 	}
+	let tintOverrides = 0;
+	const tintLayers = [];
+	if (options.tintDonors?.length) {
+		const donorJars = options.tintDonors.map((jar) => new JarResourceManager(jar));
+		try {
+			const harvest = await harvestTintOverrides({
+				donors: new LayeredResourceManager(donorJars),
+				target: base
+			});
+			if (harvest.harvested > 0) {
+				tintLayers.push(harvest.overrides);
+				tintOverrides = harvest.harvested;
+				options.onProgress?.(`Harvested tints for ${harvest.harvested} items from ${donorJars.length} donor jars`);
+			}
+		} finally {
+			await Promise.all(donorJars.map((jar) => jar.close().catch(() => {})));
+		}
+	}
 	return {
-		resources: new LayeredResourceManager([base, ...synthLayers]),
+		resources: new LayeredResourceManager([
+			base,
+			...synthLayers,
+			...tintLayers
+		]),
 		namespaces,
 		synthesized,
+		tintOverrides,
 		rejected
 	};
 }

package/dist/{prepare-DnnGGv9k.d.ts → prepare-CPxO0kKz.d.ts}

@@ -1,4 +1,4 @@
-import { a as ResourceManager } from "./manager-CoZaeQTu.js";
+import { a as ResourceManager } from "./manager-Cv1NeFyF.js";
 //#region src/mods/prepare.d.ts
 /** Loader-owned namespaces that never contain renderable mod items. */
 declare const LOADER_NAMESPACES: Set<string>;
@@ -8,6 +8,8 @@ interface ModPreparation {
   namespaces: string[];
   /** Models synthesized for texture-only namespaces. */
   synthesized: number;
+  /** Items given a tint harvested from a donor jar. */
+  tintOverrides: number;
   /** Jars rejected (unsafe entries) or unreadable, with reasons. */
   rejected: Array<{
     jar: string;
@@ -18,6 +20,11 @@ interface PrepareModsOptions {
   jars: string[];
   /** Vanilla assets for the target version (wins the minecraft namespace). */
   vanilla: ResourceManager;
+  /**
+   * Jars from 1.21.4+ releases of the same mods, read only for the tints their
+   * item definitions state as data (see src/mods/tints.ts).
+   */
+  tintDonors?: string[];
   onProgress?: (message: string) => void;
 }
 declare function prepareModResources(options: PrepareModsOptions): Promise<ModPreparation>;

package/dist/{prepare-DROxBZp1.js → prepare-Cc8QZ3j0.js}

@@ -1,8 +1,8 @@
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-dfI7b9N4.js";
-import { t as JarResourceManager } from "./jar-Bt3i0ls4.js";
-import { n as MapResourceManager, t as KindFilteredResourceManager } from "./synthetic-DC2bSnGe.js";
-import { t as reshapeLegacyAssets } from "./legacy-reshape-CewShfF3.js";
+import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-CkletR5K.js";
+import { n as MapResourceManager, t as KindFilteredResourceManager } from "./synthetic-ZAUjXT7E.js";
+import { t as JarResourceManager } from "./jar-D9z-X7tA.js";
+import { t as reshapeLegacyAssets } from "./legacy-reshape-C05SfAPR.js";
 //#region src/versions/prepare.ts
 /**
 * Version-era detection and asset preparation, replacing the file-tree surgery

package/dist/{prepare-wfWtaz_X.d.ts → prepare-Cs6QDqie.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/prepare.d.ts
 /** Dotted-numeric compare handling both `1.21.8` and the `26.2` scheme. */
 declare function compareVersions(left: string, right: string): number;

package/dist/{rasterizer-BHWDrmGz.js → rasterizer-76qO8TDh.js}

@@ -6,10 +6,33 @@ function createFaceBuffer(width, height) {
 		width,
 		height,
 		colors: new Float64Array(width * height * 4),
-		depths: new Float64Array(width * height)
+		depths: new Float64Array(width * height),
+		dirty: {
+			minX: 0,
+			minY: 0,
+			maxX: width - 1,
+			maxY: height - 1
+		}
 	};
 }
 /**
+* Zero the written region and mark the buffer empty, so one scratch buffer can
+* serve every face of a model. Allocating an image-sized color+depth pair per
+* face is what made complex models allocate hundreds of megabytes transiently.
+*/
+function clearFaceBuffer(buffer) {
+	const { dirty } = buffer;
+	for (let y = dirty.minY; y <= dirty.maxY; y++) {
+		const row = y * buffer.width;
+		buffer.colors.fill(0, (row + dirty.minX) * 4, (row + dirty.maxX + 1) * 4);
+		buffer.depths.fill(0, row + dirty.minX, row + dirty.maxX + 1);
+	}
+	dirty.minX = buffer.width;
+	dirty.minY = buffer.height;
+	dirty.maxX = -1;
+	dirty.maxY = -1;
+}
+/**
 * Retain only the rectangle containing visible pixels. Complex block models can
 * contain thousands of tiny faces; keeping a full icon-sized color/depth buffer
 * for each one turns a 64px render into gigabytes of transient memory.
@@ -19,7 +42,7 @@ function compactFaceBuffer(buffer) {
 	let minY = buffer.height;
 	let maxX = -1;
 	let maxY = -1;
-	for (let y = 0; y < buffer.height; y++) for (let x = 0; x < buffer.width; x++) {
+	for (let y = Math.max(buffer.dirty.minY, 0); y <= Math.min(buffer.dirty.maxY, buffer.height - 1); y++) for (let x = Math.max(buffer.dirty.minX, 0); x <= Math.min(buffer.dirty.maxX, buffer.width - 1); x++) {
 		if (buffer.colors[(y * buffer.width + x) * 4 + 3] <= 0) continue;
 		minX = Math.min(minX, x);
 		minY = Math.min(minY, y);
@@ -43,7 +66,13 @@ function compactFaceBuffer(buffer) {
 		width,
 		height,
 		colors,
-		depths
+		depths,
+		dirty: {
+			minX: 0,
+			minY: 0,
+			maxX: width - 1,
+			maxY: height - 1
+		}
 	};
 }
 /**
@@ -136,6 +165,15 @@ function drawTexturedTriangle(p1in, p2in, p3in, buffer, texture, cursor = new Ro
 				const textureStep = lineLength ? 1 / lineLength : 0;
 				let textureX = textureStep * .3;
 				const rowOffset = row * width;
+				const spanMinX = Math.max(startX - 1, 0);
+				const spanMaxX = Math.min(endX + 1, width - 1);
+				if (spanMinX <= spanMaxX) {
+					const { dirty } = buffer;
+					dirty.minX = Math.min(dirty.minX, spanMinX);
+					dirty.maxX = Math.max(dirty.maxX, spanMaxX);
+					dirty.minY = Math.min(dirty.minY, row);
+					dirty.maxY = Math.max(dirty.maxY, row);
+				}
 				for (let x = startX - 1; x <= endX + 1; x++) {
 					const currentU = (1 - textureX) * startU + textureX * endU;
 					const currentV = (1 - textureX) * startV + textureX * endV;
@@ -175,4 +213,4 @@ function drawTexturedTriangle(p1in, p2in, p3in, buffer, texture, cursor = new Ro
 	}
 }
 //#endregion
-export { phpRound as a, drawTexturedTriangle as i, compactFaceBuffer as n, createFaceBuffer as r, RowCursor as t };
+export { drawTexturedTriangle as a, createFaceBuffer as i, clearFaceBuffer as n, phpRound as o, compactFaceBuffer as r, RowCursor as t };

package/dist/{rasterizer-Dh35qXbn.d.ts → rasterizer-yqJkicm1.d.ts}

@@ -1,5 +1,12 @@
-import { t as FloatTexture } from "./blend-Qvrn6YgK.js";
+import { t as FloatTexture } from "./blend-CyDIxCne.js";
 //#region src/render/rasterizer.d.ts
+/** The rectangle of a buffer written since it was last cleared. */
+interface DirtyRect {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+}
 /** Per-face private color + depth buffers, image sized. */
 interface FaceBuffer {
   /** Position within the final image (full-size scratch buffers start at 0,0). */
@@ -11,8 +18,20 @@ interface FaceBuffer {
   colors: Float64Array;
   /** Depth per pixel; 0 where never written — the overdraw band relies on that. */
   depths: Float64Array;
+  /**
+   * Where the rasterizer has written. A fresh buffer claims its whole extent
+   * so callers that fill it by hand still compact correctly; clearFaceBuffer
+   * resets it to empty, which is what makes buffer reuse cheap.
+   */
+  dirty: DirtyRect;
 }
 declare function createFaceBuffer(width: number, height: number): FaceBuffer;
+/**
+ * Zero the written region and mark the buffer empty, so one scratch buffer can
+ * serve every face of a model. Allocating an image-sized color+depth pair per
+ * face is what made complex models allocate hundreds of megabytes transiently.
+ */
+declare function clearFaceBuffer(buffer: FaceBuffer): void;
 /**
  * Retain only the rectangle containing visible pixels. Complex block models can
  * contain thousands of tiny faces; keeping a full icon-sized color/depth buffer
@@ -47,4 +66,4 @@ declare class RowCursor {
 declare function phpRound(value: number): number;
 declare function drawTexturedTriangle(p1in: RasterPoint, p2in: RasterPoint, p3in: RasterPoint, buffer: FaceBuffer, texture: FloatTexture, cursor?: RowCursor): void;
 //#endregion
-export { createFaceBuffer as a, compactFaceBuffer as i, RasterPoint as n, drawTexturedTriangle as o, RowCursor as r, phpRound as s, FaceBuffer as t };
+export { clearFaceBuffer as a, drawTexturedTriangle as c, RowCursor as i, phpRound as l, FaceBuffer as n, compactFaceBuffer as o, RasterPoint as r, createFaceBuffer as s, DirtyRect as t };

package/dist/render/blend.d.ts

@@ -1,2 +1,2 @@
-import { a as q16, c as toFloatTexture, i as darkenTexture, n as blendPixel, o as tintTexture, r as cloneFloatTexture, s as toByteTexture, t as FloatTexture } from "../blend-Qvrn6YgK.js";
+import { a as q16, c as toFloatTexture, i as darkenTexture, n as blendPixel, o as tintTexture, r as cloneFloatTexture, s as toByteTexture, t as FloatTexture } from "../blend-CyDIxCne.js";
 export { FloatTexture, blendPixel, cloneFloatTexture, darkenTexture, q16, tintTexture, toByteTexture, toFloatTexture };

package/dist/render/compose.d.ts

@@ -1,5 +1,5 @@
-import { t as FloatTexture } from "../blend-Qvrn6YgK.js";
-import { t as FaceBuffer } from "../rasterizer-Dh35qXbn.js";
+import { t as FloatTexture } from "../blend-CyDIxCne.js";
+import { n as FaceBuffer } from "../rasterizer-yqJkicm1.js";
 //#region src/render/compose.d.ts
 declare function combineFaceBuffers(width: number, height: number, faces: FaceBuffer[]): FloatTexture;
 //#endregion

package/dist/render/compose.js

@@ -1,2 +1,2 @@
-import { t as combineFaceBuffers } from "../compose-qjhyBvnS.js";
+import { t as combineFaceBuffers } from "../compose-CQCb2LVv.js";
 export { combineFaceBuffers };

package/dist/render/entity-fallback.d.ts

@@ -1,9 +1,9 @@
-import { a as ResourceManager } from "../manager-CoZaeQTu.js";
-import { i as TextureLoader } from "../loader-TFFNV4Jl.js";
-import { t as ModelLoader } from "../loader-C-6QN3xv.js";
-import { t as FloatTexture } from "../blend-Qvrn6YgK.js";
-import { n as TintColor } from "../face-CpVdnf-w.js";
-import { n as RenderOptions } from "../renderer-nbMCw1Pl.js";
+import { a as ResourceManager } from "../manager-Cv1NeFyF.js";
+import { i as TextureLoader } from "../loader-Myy22TDL.js";
+import { t as ModelLoader } from "../loader-D22zZME7.js";
+import { t as FloatTexture } from "../blend-CyDIxCne.js";
+import { r as TintColor } from "../face-BIYg14TE.js";
+import { i as RenderOptions } from "../renderer-DVsZHAvf.js";
 //#region src/render/entity-fallback.d.ts
 /**
  * Dyed variants of vanilla items whose models mods generate at runtime (quark's

package/dist/render/entity-fallback.js

@@ -1,2 +1,2 @@
-import { n as renderEntityFallback, r as spawnEggTints, t as renderDyedVariantFallback } from "../entity-fallback-CdCVEG6X.js";
+import { n as renderEntityFallback, r as spawnEggTints, t as renderDyedVariantFallback } from "../entity-fallback-BRCeGKBT.js";
 export { renderDyedVariantFallback, renderEntityFallback, spawnEggTints };