@nodecraft/rendermite 0.0.1 → 1.0.1

package/dist/renderer-CmOz6WI9.js

@@ -0,0 +1,507 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+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 { i as resolveTexture } from "./loader-C-eqwp3M.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-cph4bfdr.js";
+import { i as phpRound, n as createFaceBuffer, r as drawTexturedTriangle, t as RowCursor } from "./rasterizer-ABgsWTYN.js";
+import { n as renderFace, t as faceMaxZ } from "./face-Wfia-_Yx.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";
+//#region src/render/obj.ts
+/**
+* Forge/NeoForge OBJ model rendering — the class the old pipeline left
+* permanently broken ("the geometry is in a different file format"). Parses
+* OBJ + MTL out of the asset tree and rasterizes the triangles through the
+* same projection/lighting as JSON elements, with a z-tested shared buffer
+* (per-triangle painter buffers would be quadratic in triangle count).
+*/
+/** Parse OBJ text into triangles (polygon faces are fan-triangulated). */
+function parseObj(text, flipV) {
+	const positions = [];
+	const uvs = [];
+	const triangles = [];
+	const materialLibs = [];
+	let material = "";
+	for (const rawLine of text.split("\n")) {
+		const line = rawLine.trim();
+		if (line === "" || line.startsWith("#")) continue;
+		const parts = line.split(/\s+/);
+		switch (parts[0]) {
+			case "v":
+				positions.push([
+					Number(parts[1]),
+					Number(parts[2]),
+					Number(parts[3])
+				]);
+				break;
+			case "vt": {
+				const u = Number(parts[1]);
+				const v = Number(parts[2] ?? 0);
+				uvs.push([u, flipV ? 1 - v : v]);
+				break;
+			}
+			case "usemtl":
+				material = parts.slice(1).join(" ");
+				break;
+			case "mtllib":
+				materialLibs.push(parts.slice(1).join(" "));
+				break;
+			case "f": {
+				const corners = parts.slice(1).map((corner) => {
+					const [vIndex, vtIndex] = corner.split("/", 2);
+					const position = Number(vIndex);
+					const uvIndex = vtIndex === void 0 || vtIndex === "" ? 0 : Number(vtIndex);
+					const uv = uvIndex === 0 ? void 0 : uvs[uvIndex > 0 ? uvIndex - 1 : uvs.length + uvIndex];
+					return {
+						position: positions[position > 0 ? position - 1 : positions.length + position],
+						uv: uv ?? [0, 0]
+					};
+				});
+				for (let i = 2; i < corners.length; i++) {
+					if (!corners[0]?.position || !corners[i - 1]?.position || !corners[i]?.position) continue;
+					triangles.push({
+						positions: [
+							corners[0].position,
+							corners[i - 1].position,
+							corners[i].position
+						],
+						uvs: [
+							corners[0].uv,
+							corners[i - 1].uv,
+							corners[i].uv
+						],
+						material
+					});
+				}
+				break;
+			}
+		}
+	}
+	return {
+		triangles,
+		materialLibs
+	};
+}
+/** map_Kd texture per material name out of an MTL library. */
+function parseMtl(text) {
+	const materials = /* @__PURE__ */ new Map();
+	let current = "";
+	for (const rawLine of text.split("\n")) {
+		const parts = rawLine.trim().split(/\s+/);
+		if (parts[0] === "newmtl") current = parts.slice(1).join(" ");
+		else if (parts[0] === "map_Kd" && current) materials.set(current, parts.slice(1).join(" "));
+	}
+	return materials;
+}
+/**
+* Resolve a material name to a texture locator: `#key` and MTL map_Kd values
+* go through the model's texture map (Forge binds materials that way); bare
+* names fall back to a direct locator.
+*/
+function materialTexture(model, materials, material) {
+	const mapped = materials.get(material) ?? material;
+	if (mapped.startsWith("#")) return resolveTexture(model, mapped);
+	const viaMap = resolveTexture(model, `#${mapped}`);
+	if (viaMap) return viaMap;
+	return ResourceLocator.tryParse(mapped);
+}
+async function renderObjModel(model, resources, textures, options) {
+	if (!model.obj) throw new ItemRenderError(`renderObjModel called without obj geometry: ${model.locator}`);
+	const objLocator = ResourceLocator.parse(model.obj.model);
+	const objSource = await resources.getResource("raw", objLocator);
+	if (!objSource) throw new ItemRenderError(`OBJ file not found: ${model.obj.model} for ${model.locator}`);
+	const parsed = parseObj(objSource.toString("utf8"), model.obj.flipV);
+	if (parsed.triangles.length === 0) throw new ItemRenderError(`OBJ has no faces: ${model.obj.model}`);
+	const materials = /* @__PURE__ */ new Map();
+	const objDirectory = objLocator.path.split("/").slice(0, -1).join("/");
+	for (const lib of parsed.materialLibs) {
+		const libPath = lib.includes("/") ? lib : `${objDirectory}/${lib}`;
+		const libLocator = ResourceLocator.tryParse(`${objLocator.namespace}:${libPath}`);
+		const source = libLocator ? await resources.getResource("raw", libLocator) : null;
+		if (source) for (const [name, texture] of parseMtl(source.toString("utf8"))) materials.set(name, texture);
+	}
+	const lights = lightsForProfile(options.lightingProfile);
+	const light = model.elementsGuiLight === "side" ? lights.side : lights.front;
+	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 renderSize = options.size * options.quality;
+	const out = createFaceBuffer(renderSize, renderSize);
+	const shaded = /* @__PURE__ */ new Map();
+	for (const triangle of parsed.triangles) {
+		const transformed = triangle.positions.map((position) => transformVector(transformation, position));
+		const rawNormal = cross(sub(transformed[1], transformed[0]), sub(transformed[2], transformed[0]));
+		if (rawNormal[0] === 0 && rawNormal[1] === 0 && rawNormal[2] === 0) continue;
+		const normal = normalize(rawNormal);
+		if (dot([
+			0,
+			0,
+			-1
+		], normal) >= -.01) continue;
+		const level = light.lightLevelForNormal(normal);
+		const bucket = Math.round(level * 64);
+		const locator = materialTexture(model, materials, triangle.material);
+		if (!locator) throw new ItemRenderError(`Unresolvable OBJ material ${triangle.material} in ${model.locator}`);
+		const key = `${locator} ${bucket}`;
+		let texture = shaded.get(key);
+		if (!texture) {
+			const base = await textures.load(locator) ?? await textures.load(new ResourceLocator(locator.namespace, `item/${locator.path}`));
+			if (!base) throw new ItemRenderError(`Missing texture ${locator} referenced by ${model.obj.model}`);
+			texture = cloneFloatTexture(toFloatTexture(base));
+			darkenTexture(texture, 1 - bucket / 64, 0, 0, texture.width, texture.height);
+			shaded.set(key, texture);
+		}
+		const scratch = createFaceBuffer(renderSize, renderSize);
+		const cursor = new RowCursor();
+		const point = (index) => {
+			return {
+				x: phpRound((transformed[index][0] - .5) * renderSize + renderSize / 2),
+				y: phpRound(renderSize - ((transformed[index][1] - .5) * renderSize + renderSize / 2)),
+				u: triangle.uvs[index][0],
+				v: triangle.uvs[index][1],
+				depth: (transformed[index][2] + 1) / 3
+			};
+		};
+		drawTexturedTriangle(point(0), point(1), point(2), scratch, texture, cursor);
+		for (let pixel = 0; pixel < renderSize * renderSize; pixel++) {
+			const offset = pixel * 4;
+			const alpha = scratch.colors[offset + 3];
+			if (alpha <= 0) continue;
+			if (scratch.depths[pixel] >= out.depths[pixel] || out.colors[offset + 3] === 0) {
+				if (alpha >= 1 || out.colors[offset + 3] === 0) {
+					out.colors[offset] = scratch.colors[offset];
+					out.colors[offset + 1] = scratch.colors[offset + 1];
+					out.colors[offset + 2] = scratch.colors[offset + 2];
+					out.colors[offset + 3] = alpha;
+				} else blendPixel(out.colors, offset, scratch.colors[offset], scratch.colors[offset + 1], scratch.colors[offset + 2], alpha);
+				out.depths[pixel] = Math.max(out.depths[pixel], scratch.depths[pixel]);
+			}
+		}
+	}
+	return {
+		width: renderSize,
+		height: renderSize,
+		data: out.colors
+	};
+}
+//#endregion
+//#region src/render/renderer.ts
+/**
+* Item rendering entry: flat generated items (2D layer compositing) and 3D
+* element models (transform → rasterize → per-pixel composite), both rendered
+* at size × quality then box-downscaled, matching upstream ItemRenderTask.
+*/
+var ItemRenderError = class extends Error {};
+const TICK_MS = 50;
+const MAX_ANIMATION_FRAMES = 128;
+function gcd(left, right) {
+	return right === 0 ? left : gcd(right, left % right);
+}
+/**
+* Render every animation frame of a model (a single frame for unanimated
+* items). The tick loop mirrors upstream: total ticks = lcm of the involved
+* textures' lengths, identical frames are skipped, and interpolated textures
+* are capped at 128 emitted frames.
+*/
+async function renderModelFrames(model, textures, options) {
+	assertDrawable(model);
+	if (model.obj || model.fluid) return {
+		frames: [await renderModel(model, textures, options)],
+		delaysMs: [TICK_MS]
+	};
+	const references = /* @__PURE__ */ new Set();
+	if (model.builtinParent === "builtin/generated") {
+		for (const name of Object.keys(model.textures)) if (/^layer\d+$/.test(name)) references.add(`#${name}`);
+	} else for (const element of model.elements) for (const face of Object.values(element.faces)) if (face?.texture) references.add(face.texture);
+	const animated = /* @__PURE__ */ new Map();
+	const skipped = /* @__PURE__ */ new Set();
+	for (const reference of references) {
+		if (model.builtinParent !== "builtin/generated" && reference.startsWith("#") && resolveTexture(model, reference) === null) {
+			skipped.add(reference);
+			continue;
+		}
+		animated.set(reference, await loadAnimatedTexture(model, textures, reference));
+	}
+	let ticks = 1;
+	let interpolated = false;
+	for (const texture of animated.values()) {
+		ticks = ticks / gcd(ticks, texture.tickLength) * texture.tickLength;
+		interpolated ||= texture.interpolated;
+	}
+	const maxSkippable = interpolated ? Math.ceil(ticks / MAX_ANIMATION_FRAMES) : null;
+	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 supplier = async (reference) => {
+			if (skipped.has(reference)) return null;
+			const texture = animated.get(reference);
+			if (!texture) throw new ItemRenderError(`Untracked texture reference ${reference} in ${model.locator}`);
+			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);
+		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);
+		})
+	};
+}
+async function loadAnimatedTexture(model, textures, reference) {
+	const locator = resolveTexture(model, reference);
+	if (locator) {
+		const texture = await textures.loadAnimated(locator);
+		if (texture) return texture;
+	}
+	if (!reference.startsWith("#") && model.textures[reference] !== void 0) {
+		const variable = resolveTexture(model, `#${reference}`);
+		if (variable) {
+			const texture = await textures.loadAnimated(variable);
+			if (texture) return texture;
+		}
+	}
+	throw new ItemRenderError(`Missing texture ${locator ?? reference} referenced by ${model.locator}`);
+}
+/**
+* Models with neither generated layers nor elements have no drawable geometry
+* (OBJ loaders, code-built block entities) — fail loudly rather than shipping
+* a transparent icon that still counts as "has an icon" downstream.
+*/
+function assertDrawable(model) {
+	if (model.obj) return;
+	if (model.builtinParent !== null && model.builtinParent !== "builtin/generated") throw new ItemRenderError(`Unsupported builtin parent ${model.builtinParent} in ${model.locator}`);
+	if (model.builtinParent === null && model.elements.length === 0) throw new ItemRenderError(`No drawable geometry in ${model.locator} (code-rendered model)`);
+	if (model.builtinParent === "builtin/generated" && !Object.keys(model.textures).some((name) => /^layer\d+$/.test(name))) throw new ItemRenderError(`Generated model without layers in ${model.locator} (would render invisible)`);
+}
+async function renderModel(model, textures, options) {
+	assertDrawable(model);
+	if (model.obj) {
+		if (!options.resources) throw new ItemRenderError(`OBJ model ${model.locator} needs RenderOptions.resources for file access`);
+		const full = await renderObjModel(model, options.resources, textures, options);
+		return options.quality === 1 ? full : boxDownscale(full, options.quality);
+	}
+	const renderSize = options.size * options.quality;
+	if (model.fluid && model.builtinParent === "builtin/generated") {
+		const filled = await renderFluidBucket(model, textures, renderSize, options.resources);
+		if (filled) return options.quality === 1 ? filled : boxDownscale(filled, options.quality);
+	}
+	const full = model.builtinParent === "builtin/generated" ? await renderGeneratedItem(model, textures, renderSize, options.tints) : await renderElementModel(model, textures, renderSize, options);
+	return options.quality === 1 ? full : boxDownscale(full, options.quality);
+}
+/**
+* fluid_container buckets: bucket sprite with the contained fluid painted into
+* the water-bucket fill region. Null when the fluid resolves to nothing, in
+* which case the plain bucket renders as before.
+*/
+async function renderFluidBucket(model, textures, renderSize, resources) {
+	const locator = resolveTexture(model, "#layer0");
+	const base = locator ? await textures.load(locator) : null;
+	if (!base || !model.fluid) return null;
+	const copy = {
+		width: base.width,
+		height: base.height,
+		data: new Uint8ClampedArray(base.data)
+	};
+	if (!await paintBucketFluid(copy, model.fluid, textures, resources)) return null;
+	return pointResize(toFloatTexture(copy), renderSize, renderSize);
+}
+async function loadTexture(model, textures, reference) {
+	const locator = resolveTexture(model, reference);
+	if (locator) {
+		const texture = await textures.load(locator);
+		if (texture) return {
+			locator,
+			texture
+		};
+	}
+	if (!reference.startsWith("#") && model.textures[reference] !== void 0) {
+		const variable = resolveTexture(model, `#${reference}`);
+		if (variable) {
+			const texture = await textures.load(variable);
+			if (texture) return {
+				locator: variable,
+				texture
+			};
+		}
+	}
+	throw new ItemRenderError(`Missing texture ${locator ?? reference} referenced by ${model.locator}`);
+}
+/**
+* Flat generated item: numerically-sorted layerN textures, tinted by layer index,
+* point-upscaled to the render size, source-over composited. GUI display transforms
+* and lighting deliberately do not apply (upstream behavior).
+*/
+async function renderGeneratedItem(model, textures, renderSize, tints) {
+	const supplier = async (reference) => {
+		return (await loadTexture(model, textures, reference)).texture;
+	};
+	return renderGeneratedItemWith(model, supplier, renderSize, tints);
+}
+async function renderGeneratedItemWith(model, supplier, renderSize, tints) {
+	const layerNames = Object.keys(model.textures).map((name) => /^layer(\d+)$/.exec(name)).filter((match) => match !== null).toSorted((a, b) => Number(a[1]) - Number(b[1]));
+	const out = new Float64Array(renderSize * renderSize * 4);
+	for (const match of layerNames) {
+		const layerIndex = Number(match[1]);
+		const texture = await supplier(`#${match[0]}`);
+		if (!texture) throw new ItemRenderError(`Missing texture #${match[0]} referenced by ${model.locator}`);
+		const float = toFloatTexture(texture);
+		const tint = tints?.[layerIndex] ?? null;
+		if (tint) tintTexture(float, tint.r, tint.g, tint.b);
+		const resized = pointResize(float, renderSize, renderSize);
+		for (let offset = 0; offset < out.length; offset += 4) {
+			const alpha = resized.data[offset + 3];
+			if (alpha > 0) blendPixel(out, offset, resized.data[offset], resized.data[offset + 1], resized.data[offset + 2], alpha);
+		}
+	}
+	return {
+		width: renderSize,
+		height: renderSize,
+		data: out
+	};
+}
+async function renderElementModel(model, textures, renderSize, options) {
+	const supplier = async (reference) => {
+		if (reference.startsWith("#") && resolveTexture(model, reference) === null) return null;
+		return (await loadTexture(model, textures, reference)).texture;
+	};
+	return renderElementModelWith(model, supplier, renderSize, options);
+}
+async function renderElementModelWith(model, supplier, renderSize, options) {
+	const lights = lightsForProfile(options.lightingProfile);
+	const light = model.elementsGuiLight === "side" ? lights.side : lights.front;
+	const faces = [];
+	let skippedFaces = 0;
+	for (const element of model.elements) for (const geometry of buildElementFaces(element)) {
+		const texture = await supplier(geometry.textureRef);
+		if (!texture) {
+			skippedFaces++;
+			continue;
+		}
+		faces.push({
+			geometry,
+			texture: toFloatTexture(texture),
+			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);
+		if (buffer) buffers.push(buffer);
+	}
+	return combineFaceBuffers(renderSize, renderSize, buffers);
+}
+/** Nearest-neighbour resize matching Imagick FILTER_POINT (destination-center sampling). */
+function pointResize(texture, width, height) {
+	const data = new Float64Array(width * height * 4);
+	for (let y = 0; y < height; y++) {
+		let srcY = Math.floor((y + .5) * texture.height / height);
+		srcY = srcY >= texture.height ? texture.height - 1 : srcY;
+		for (let x = 0; x < width; x++) {
+			let srcX = Math.floor((x + .5) * texture.width / width);
+			srcX = srcX >= texture.width ? texture.width - 1 : srcX;
+			const src = (srcY * texture.width + srcX) * 4;
+			const dst = (y * width + x) * 4;
+			data[dst] = texture.data[src];
+			data[dst + 1] = texture.data[src + 1];
+			data[dst + 2] = texture.data[src + 2];
+			data[dst + 3] = texture.data[src + 3];
+		}
+	}
+	return {
+		width,
+		height,
+		data
+	};
+}
+/**
+* Box downscale matching ImageMagick 6 ResizeImage with an alpha channel: two
+* passes (horizontal then vertical), each computing alpha-weighted colors
+* (color = Σ(aᵢ·cᵢ)/Σ(aᵢ), alpha = mean) and storing every intermediate as a
+* Q16 quantum with round-half-up. Verified against Imagick FILTER_BOX output.
+*/
+function boxDownscale(texture, factor) {
+	return boxPass(boxPass(texture, factor, true), factor, false);
+}
+function boxPass(texture, factor, isHorizontal) {
+	const width = isHorizontal ? Math.round(texture.width / factor) : texture.width;
+	const height = isHorizontal ? texture.height : Math.round(texture.height / factor);
+	const data = new Float64Array(width * height * 4);
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+		let r = 0;
+		let g = 0;
+		let b = 0;
+		let alphaSum = 0;
+		for (let i = 0; i < factor; i++) {
+			const srcX = isHorizontal ? x * factor + i : x;
+			const src = ((isHorizontal ? y : y * factor + i) * texture.width + srcX) * 4;
+			const alpha = Math.round(texture.data[src + 3] * 65535);
+			r += Math.round(texture.data[src] * 65535) * alpha;
+			g += Math.round(texture.data[src + 1] * 65535) * alpha;
+			b += Math.round(texture.data[src + 2] * 65535) * alpha;
+			alphaSum += alpha;
+		}
+		const dst = (y * width + x) * 4;
+		if (alphaSum > 0) {
+			data[dst] = clampQuantum(r / alphaSum) / 65535;
+			data[dst + 1] = clampQuantum(g / alphaSum) / 65535;
+			data[dst + 2] = clampQuantum(b / alphaSum) / 65535;
+		}
+		data[dst + 3] = clampQuantum(alphaSum / factor) / 65535;
+	}
+	return {
+		width,
+		height,
+		data
+	};
+}
+/** ClampToQuantum on a value already in quantum units: floor(x + 0.5), clamped. */
+function clampQuantum(quantum) {
+	const rounded = Math.floor(quantum + .5);
+	return rounded < 0 ? 0 : Math.min(rounded, 65535);
+}
+//#endregion
+export { renderModelFrames as a, renderObjModel as c, renderModel as i, boxDownscale as n, parseMtl as o, pointResize as r, parseObj as s, ItemRenderError as t };

package/dist/renderer-DQfv6axF.d.ts

@@ -0,0 +1,44 @@
+import { a as ResourceManager } from "./manager-CoZaeQTu.js";
+import { i as TextureLoader } from "./loader-TFFNV4Jl.js";
+import { r as ResolvedModel } from "./loader-lCkMRDH4.js";
+import { t as FloatTexture } from "./blend-Qvrn6YgK.js";
+import { t as Mat4 } from "./vector-DRKRi4--.js";
+import { a as LightingProfileName } from "./lighting-3FGRC3Af.js";
+import { n as TintColor } from "./face-DC6cNMdz.js";
+//#region src/render/renderer.d.ts
+interface RenderOptions {
+  size: number;
+  quality: number;
+  lightingProfile: LightingProfileName;
+  /** Accumulated item-definition transformation (inner matrix). */
+  itemTransform?: Mat4;
+  /** Tint colors by index (face tintindex / generated layer number). */
+  tints?: Array<TintColor | null>;
+  /** Needed for OBJ models, which read .obj/.mtl files from the asset tree. */
+  resources?: ResourceManager;
+}
+declare class ItemRenderError extends Error {}
+interface RenderedFrames {
+  frames: FloatTexture[];
+  /** Display duration per frame in milliseconds (50ms per game tick). */
+  delaysMs: number[];
+}
+/**
+ * Render every animation frame of a model (a single frame for unanimated
+ * items). The tick loop mirrors upstream: total ticks = lcm of the involved
+ * textures' lengths, identical frames are skipped, and interpolated textures
+ * are capped at 128 emitted frames.
+ */
+declare function renderModelFrames(model: ResolvedModel, textures: TextureLoader, options: RenderOptions): Promise<RenderedFrames>;
+declare function renderModel(model: ResolvedModel, textures: TextureLoader, options: RenderOptions): Promise<FloatTexture>;
+/** Nearest-neighbour resize matching Imagick FILTER_POINT (destination-center sampling). */
+declare function pointResize(texture: FloatTexture, width: number, height: number): FloatTexture;
+/**
+ * Box downscale matching ImageMagick 6 ResizeImage with an alpha channel: two
+ * passes (horizontal then vertical), each computing alpha-weighted colors
+ * (color = Σ(aᵢ·cᵢ)/Σ(aᵢ), alpha = mean) and storing every intermediate as a
+ * Q16 quantum with round-half-up. Verified against Imagick FILTER_BOX output.
+ */
+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 };

package/dist/resources/jar.d.ts

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

package/dist/resources/jar.js

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

package/dist/resources/locator.d.ts

@@ -0,0 +1,2 @@
+import { n as ResourceLocator, t as InvalidResourceLocatorError } from "../locator-jDbdUeTd.js";
+export { InvalidResourceLocatorError, ResourceLocator };

package/dist/resources/locator.js

@@ -0,0 +1,2 @@
+import { n as ResourceLocator, t as InvalidResourceLocatorError } from "../locator-ycZzh_6z.js";
+export { InvalidResourceLocatorError, ResourceLocator };

package/dist/resources/manager.d.ts

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

package/dist/resources/manager.js

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

package/dist/resources/synthetic.d.ts

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

package/dist/resources/synthetic.js

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

package/dist/run-BK7Q8WZ3.d.ts

@@ -0,0 +1,54 @@
+import { a as ResourceManager } from "./manager-CoZaeQTu.js";
+import { a as LightingProfileName } from "./lighting-3FGRC3Af.js";
+//#region src/run.d.ts
+interface RunOptions {
+  resources: ResourceManager;
+  /**
+   * Path to a renderchest-style builtin pack (`<dir>/<ns>/…`). Layered ABOVE
+   * user assets, matching upstream: its item overrides (chests, banners,
+   * shulkers, heads) shadow vanilla's code-drawn items.
+   */
+  builtin?: string;
+  output: string;
+  namespaces?: string[];
+  size?: number;
+  quality?: number;
+  prefix?: string;
+  format?: 'webp' | 'avif';
+  fallback?: boolean;
+  /** Also emit animated GIFs for legacy browsers. */
+  gif?: boolean;
+  /** Also emit AVIF (animated where libvips supports it, else first frame). */
+  avif?: boolean;
+  /** Minify the stylesheet via lightningcss (default true). */
+  minify?: boolean;
+  /** In-flight items (encode overlaps on libvips' threadpool; default 8). */
+  concurrency?: number;
+  lightingProfile?: LightingProfileName;
+  itemList?: boolean;
+  onProgress?: (done: number, total: number, id: string, error?: string) => void;
+}
+interface ItemFailure {
+  id: string;
+  error: string;
+}
+interface RunResult {
+  rendered: string[];
+  failed: ItemFailure[];
+  /**
+   * Items whose real model is code-rendered (no drawable geometry) but which
+   * ship a flat item sprite we rendered instead. Reported, never silent.
+   */
+  spriteFallbacks: string[];
+  /**
+   * Ids whose model is a parent template other item models extend (spectrum's
+   * handheld_oversized) — not real items, so their failure is reported apart
+   * from genuine misses.
+   */
+  skippedTemplates: string[];
+  /** Image files actually written, the only trustworthy success signal. */
+  writtenFiles: number;
+}
+declare function run(options: RunOptions): Promise<RunResult>;
+//#endregion
+export { run as i, RunOptions as n, RunResult as r, ItemFailure as t };