@nodecraft/rendermite 0.0.1 → 1.0.0

package/dist/prepare-DROxBZp1.js

@@ -0,0 +1,112 @@
+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";
+//#region src/versions/prepare.ts
+/**
+* Version-era detection and asset preparation, replacing the file-tree surgery
+* the old pipeline did (fetch-assets.ts + legacy-assets.ts) with composed
+* resource-manager layers over the jars themselves:
+*
+* - 1.9+  — the jar as-is.
+* - 1.8.x — jar + synthesized `models/item/generated.json`.
+* - 1.6–1.7.x — jar textures + donor geometry (1.12.2 over 1.8.9, models and
+*   blockstates only) + synthesized generated.json + glint alias.
+* - <1.6 — reshaped legacy textures (see legacy-reshape.ts) + donor geometry.
+*/
+/** Dotted-numeric compare handling both `1.21.8` and the `26.2` scheme. */
+function compareVersions(left, right) {
+	const partsA = left.split(".").map((part) => Number(part) || 0);
+	const partsB = right.split(".").map((part) => Number(part) || 0);
+	for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+		const delta = (partsA[i] ?? 0) - (partsB[i] ?? 0);
+		if (delta !== 0) return Math.sign(delta);
+	}
+	return 0;
+}
+const Era = {
+	/** 1.21.4+: items/ definitions. */
+	modern: "modern",
+	/** 1.9–1.21.3: models/item scan. */
+	models: "models",
+	/** 1.8.x: models but no models/item/generated.json. */
+	earlyModels: "earlyModels",
+	/** 1.6–1.7.x: assets layout, flat textures, no JSON models. */
+	preModels: "preModels",
+	/** 1.5.x: root-layout individual textures, old names. */
+	legacyFiles: "legacyFiles",
+	/** ≤1.4.7: stitched terrain.png/items.png sheets. */
+	legacySheets: "legacySheets"
+};
+function eraForVersion(version) {
+	if (compareVersions(version, "1.21.4") >= 0) return "modern";
+	if (compareVersions(version, "1.9") >= 0) return "models";
+	if (compareVersions(version, "1.8") >= 0) return "earlyModels";
+	if (compareVersions(version, "1.6") >= 0) return "preModels";
+	if (compareVersions(version, "1.5") >= 0) return "legacyFiles";
+	return "legacySheets";
+}
+/** Donor jars for borrowed geometry, oldest→newest; the newest wins overlaps. */
+const GEOMETRY_DONOR_VERSIONS = ["1.8.9", "1.12.2"];
+/** [modern path, legacy path] — extended as more era moves surface. */
+const MOVED_TEXTURES = [
+	["minecraft:misc/enchanted_glint_item", "minecraft:misc/enchanted_item_glint"],
+	["minecraft:entity/banner/banner_base", "minecraft:entity/banner_base"],
+	["minecraft:entity/shield/shield_base_nopattern", "minecraft:entity/shield_base_nopattern"],
+	["minecraft:entity/shield/shield_base", "minecraft:entity/shield_base"],
+	["minecraft:entity/shulker/shulker", "minecraft:entity/shulker/shulker_purple"],
+	["minecraft:entity/player/wide/steve", "minecraft:entity/steve"]
+];
+/**
+* Compose the resource layers for a version. Highest priority first:
+* era shims, then the version's own assets, then donor geometry.
+*/
+async function prepareVersionResources(options) {
+	const era = eraForVersion(options.version);
+	const layers = [];
+	const shims = new MapResourceManager();
+	if (era === "legacyFiles" || era === "legacySheets") {
+		if (!options.referenceJar) throw new Error(`Versions below 1.6 need referenceJar (1.6.4) for texture naming: ${options.version}`);
+		layers.push(await reshapeLegacyAssets(options.jar, options.referenceJar, era === "legacySheets"));
+	} else {
+		if (options.bedCompat && compareVersions(options.version, "1.21.4") >= 0 && compareVersions(options.version, "26.2") < 0) layers.push(new FolderResourceManager(options.bedCompat));
+		layers.push(new JarResourceManager(options.jar));
+	}
+	if ([
+		"preModels",
+		"legacyFiles",
+		"legacySheets"
+	].includes(era)) for (const donor of GEOMETRY_DONOR_VERSIONS.toReversed()) {
+		const jar = options.donors?.[donor];
+		if (!jar) throw new Error(`Version ${options.version} needs donor jar ${donor} for geometry`);
+		layers.push(new KindFilteredResourceManager(new JarResourceManager(jar), ["model", "blockstate"]));
+	}
+	if (era !== "modern" && era !== "models") shims.set("model", "minecraft:item/generated", JSON.stringify({ parent: "builtin/generated" }));
+	if (compareVersions(options.version, "1.13") < 0) for (const [name, model] of [
+		["bed", {
+			parent: "renderchest:item/bed",
+			textures: { texture: "minecraft:entity/bed/red" }
+		}],
+		["banner", { parent: "renderchest:item/banner" }],
+		["shield_blocking", { parent: "minecraft:item/shield" }],
+		["skull", { parent: "mobheads:item/skeleton" }],
+		["skull_char", { parent: "mobheads:item/player" }],
+		["skull_creeper", { parent: "mobheads:item/creeper" }],
+		["skull_dragon", { parent: "mobheads:item/ender_dragon" }],
+		["skull_skeleton", { parent: "mobheads:item/skeleton" }],
+		["skull_wither", { parent: "mobheads:item/wither_skeleton" }],
+		["skull_zombie", { parent: "mobheads:item/zombie" }]
+	]) shims.set("model", `minecraft:item/${name}`, JSON.stringify(model));
+	const base = new LayeredResourceManager(layers);
+	for (const [modern, legacy] of MOVED_TEXTURES) {
+		const modernLocator = ResourceLocator.parse(modern);
+		if (!await base.hasResource("texture", modernLocator)) {
+			const legacyContent = await base.getResource("texture", ResourceLocator.parse(legacy));
+			if (legacyContent) shims.set("texture", modern, legacyContent);
+		}
+	}
+	return new LayeredResourceManager([shims, base]);
+}
+//#endregion
+export { prepareVersionResources as a, eraForVersion as i, GEOMETRY_DONOR_VERSIONS as n, compareVersions as r, Era as t };

package/dist/prepare-DnnGGv9k.d.ts

@@ -0,0 +1,25 @@
+import { a as ResourceManager } from "./manager-CoZaeQTu.js";
+//#region src/mods/prepare.d.ts
+/** Loader-owned namespaces that never contain renderable mod items. */
+declare const LOADER_NAMESPACES: Set<string>;
+interface ModPreparation {
+  resources: ResourceManager;
+  /** Renderable mod namespaces discovered across the jars. */
+  namespaces: string[];
+  /** Models synthesized for texture-only namespaces. */
+  synthesized: number;
+  /** Jars rejected (unsafe entries) or unreadable, with reasons. */
+  rejected: Array<{
+    jar: string;
+    reason: string;
+  }>;
+}
+interface PrepareModsOptions {
+  jars: string[];
+  /** Vanilla assets for the target version (wins the minecraft namespace). */
+  vanilla: ResourceManager;
+  onProgress?: (message: string) => void;
+}
+declare function prepareModResources(options: PrepareModsOptions): Promise<ModPreparation>;
+//#endregion
+export { prepareModResources as i, ModPreparation as n, PrepareModsOptions as r, LOADER_NAMESPACES as t };

package/dist/prepare-wfWtaz_X.d.ts

@@ -0,0 +1,45 @@
+import { a as ResourceManager } from "./manager-CoZaeQTu.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;
+declare const Era: {
+  /** 1.21.4+: items/ definitions. */
+  readonly modern: "modern";
+  /** 1.9–1.21.3: models/item scan. */
+  readonly models: "models";
+  /** 1.8.x: models but no models/item/generated.json. */
+  readonly earlyModels: "earlyModels";
+  /** 1.6–1.7.x: assets layout, flat textures, no JSON models. */
+  readonly preModels: "preModels";
+  /** 1.5.x: root-layout individual textures, old names. */
+  readonly legacyFiles: "legacyFiles";
+  /** ≤1.4.7: stitched terrain.png/items.png sheets. */
+  readonly legacySheets: "legacySheets";
+};
+type EraName = keyof typeof Era;
+declare function eraForVersion(version: string): EraName;
+/** Donor jars for borrowed geometry, oldest→newest; the newest wins overlaps. */
+declare const GEOMETRY_DONOR_VERSIONS: readonly ["1.8.9", "1.12.2"];
+interface PrepareOptions {
+  version: string;
+  /** Path to the version's client jar. */
+  jar: string;
+  /** Donor jar paths by version — required below 1.8 (and the 1.6.4 reference below 1.6). */
+  donors?: Partial<Record<string, string>>;
+  /** 1.6.4 jar for pixel-match naming of pre-1.6 textures. */
+  referenceJar?: string;
+  /**
+   * Bed geometry pack for 1.21.4 through 26.1: those jars' bed item models
+   * chain to builtin/entity (vanilla only shipped real bed block models in
+   * 26.2), so the corpus era renders beds as fully transparent icons. This
+   * layer shadows them with real geometry.
+   */
+  bedCompat?: string;
+}
+/**
+ * Compose the resource layers for a version. Highest priority first:
+ * era shims, then the version's own assets, then donor geometry.
+ */
+declare function prepareVersionResources(options: PrepareOptions): Promise<ResourceManager>;
+//#endregion
+export { compareVersions as a, PrepareOptions as i, EraName as n, eraForVersion as o, GEOMETRY_DONOR_VERSIONS as r, prepareVersionResources as s, Era as t };

package/dist/rasterizer-ABgsWTYN.js

@@ -0,0 +1,139 @@
+//#region src/render/rasterizer.ts
+function createFaceBuffer(width, height) {
+	return {
+		width,
+		height,
+		colors: new Float64Array(width * height * 4),
+		depths: new Float64Array(width * height)
+	};
+}
+/**
+* Emulates ImagickPixelIterator's cursor, including the quirk the whole
+* corpus is rendered with: next() on an unconsumed iterator (fresh or just
+* rewound) fetches row 0 instead of advancing. Upstream's moveIterator never
+* calls current(), so the first triangle part after a rewind draws every
+* scanline ONE ROW ABOVE its computed y. Shared by a face's two triangles.
+*/
+var RowCursor = class {
+	row = 0;
+	consumed = false;
+	/** Upstream moveIterator: rewind when past the target, then advance via next(). */
+	moveTo(targetRow) {
+		if (this.row > targetRow) {
+			this.row = 0;
+			this.consumed = false;
+		}
+		const steps = targetRow - this.row;
+		for (let i = 0; i < steps; i++) this.next();
+	}
+	/** current(): marks the row consumed and returns it. */
+	current() {
+		this.consumed = true;
+		return this.row;
+	}
+	next() {
+		if (this.consumed) this.row++;
+		else this.consumed = true;
+	}
+	valid(height) {
+		return this.row < height;
+	}
+};
+/** PHP round(): half away from zero, unlike Math.round's half toward +Infinity. */
+function phpRound(value) {
+	return value < 0 ? -Math.round(-value) : Math.round(value);
+}
+function drawTexturedTriangle(p1in, p2in, p3in, buffer, texture, cursor = new RowCursor()) {
+	const { width, height } = buffer;
+	const [p1, p2, p3] = [
+		p1in,
+		p2in,
+		p3in
+	].toSorted((a, b) => a.y - b.y);
+	let diff1x = p2.x - p1.x;
+	let diff1y = p2.y - p1.y;
+	let uvDiff1u = p2.u - p1.u;
+	let uvDiff1v = p2.v - p1.v;
+	let depthDiff1 = p2.depth - p1.depth;
+	const diff2x = p3.x - p1.x;
+	const diff2y = p3.y - p1.y;
+	const uvDiff2u = p3.u - p1.u;
+	const uvDiff2v = p3.v - p1.v;
+	const depthDiff2 = p3.depth - p1.depth;
+	let xyStep1 = diff1y ? diff1x / diff1y : 0;
+	const xyStep2 = diff2y ? diff2x / diff2y : 0;
+	let uvStep1u = diff1y ? uvDiff1u / Math.abs(diff1y) : 0;
+	let uvStep1v = diff1y ? uvDiff1v / Math.abs(diff1y) : 0;
+	const uvStep2u = diff2y ? uvDiff2u / Math.abs(diff2y) : 0;
+	const uvStep2v = diff2y ? uvDiff2v / Math.abs(diff2y) : 0;
+	let depthStep1 = diff1y ? depthDiff1 / Math.abs(diff1y) : 0;
+	const depthStep2 = diff2y ? depthDiff2 / Math.abs(diff2y) : 0;
+	let startPoint = p1;
+	let endPoint = p2;
+	for (let part = 0; part < 2; part++) {
+		if (diff1y > 0) {
+			const startY = startPoint.y;
+			const endY = endPoint.y;
+			cursor.moveTo(startY);
+			for (let y = startY; y <= endY; y++) {
+				if (y < 0) continue;
+				if (!cursor.valid(height)) break;
+				const row = cursor.current();
+				let startX = phpRound(startPoint.x + (y - startPoint.y) * xyStep1);
+				let endX = phpRound(p1.x + (y - p1.y) * xyStep2);
+				let startU = startPoint.u + (y - startPoint.y) * uvStep1u;
+				let startV = startPoint.v + (y - startPoint.y) * uvStep1v;
+				let startDepth = startPoint.depth + (y - startPoint.y) * depthStep1;
+				let endU = p1.u + (y - p1.y) * uvStep2u;
+				let endV = p1.v + (y - p1.y) * uvStep2v;
+				let endDepth = p1.depth + (y - p1.y) * depthStep2;
+				if (startX > endX) {
+					[startX, endX] = [endX, startX];
+					[startU, endU] = [endU, startU];
+					[startV, endV] = [endV, startV];
+					[startDepth, endDepth] = [endDepth, startDepth];
+				}
+				const lineLength = endX - startX;
+				const textureStep = lineLength ? 1 / lineLength : 0;
+				let textureX = textureStep * .3;
+				const rowOffset = row * width;
+				for (let x = startX - 1; x <= endX + 1; x++) {
+					const currentU = (1 - textureX) * startU + textureX * endU;
+					const currentV = (1 - textureX) * startV + textureX * endV;
+					const currentDepth = (1 - textureX) * startDepth + textureX * endDepth;
+					if (x >= 0 && x < width) {
+						let texX = Math.trunc(currentU * texture.width);
+						let texY = Math.trunc(currentV * texture.height);
+						texX = texX < 0 ? 0 : texX >= texture.width ? texture.width - 1 : texX;
+						texY = texY < 0 ? 0 : texY >= texture.height ? texture.height - 1 : texY;
+						const src = (texY * texture.width + texX) * 4;
+						const dst = (rowOffset + x) * 4;
+						buffer.colors[dst] = texture.data[src];
+						buffer.colors[dst + 1] = texture.data[src + 1];
+						buffer.colors[dst + 2] = texture.data[src + 2];
+						buffer.colors[dst + 3] = texture.data[src + 3];
+					}
+					if (x >= startX && x < endX && x >= 0 && x < width) {
+						const clamped = currentDepth < 0 ? 0 : Math.min(currentDepth, 1);
+						buffer.depths[rowOffset + x] = Math.round(clamped * 65535) / 65535;
+						textureX += textureStep;
+					}
+				}
+				cursor.next();
+			}
+		}
+		diff1x = p3.x - p2.x;
+		diff1y = p3.y - p2.y;
+		uvDiff1u = p3.u - p2.u;
+		uvDiff1v = p3.v - p2.v;
+		depthDiff1 = p3.depth - p2.depth;
+		xyStep1 = diff1y ? diff1x / diff1y : 0;
+		uvStep1u = diff1y ? uvDiff1u / Math.abs(diff1y) : 0;
+		uvStep1v = diff1y ? uvDiff1v / Math.abs(diff1y) : 0;
+		depthStep1 = diff1y ? depthDiff1 / Math.abs(diff1y) : 0;
+		startPoint = p2;
+		endPoint = p3;
+	}
+}
+//#endregion
+export { phpRound as i, createFaceBuffer as n, drawTexturedTriangle as r, RowCursor as t };

package/dist/rasterizer-CVOlRsuw.d.ts

@@ -0,0 +1,41 @@
+import { t as FloatTexture } from "./blend-Qvrn6YgK.js";
+//#region src/render/rasterizer.d.ts
+/** Per-face private color + depth buffers, image sized. */
+interface FaceBuffer {
+  width: number;
+  height: number;
+  /** RGBA float, overwritten (not blended) by the rasterizer. */
+  colors: Float64Array;
+  /** Depth per pixel; 0 where never written — the overdraw band relies on that. */
+  depths: Float64Array;
+}
+declare function createFaceBuffer(width: number, height: number): FaceBuffer;
+interface RasterPoint {
+  x: number;
+  y: number;
+  u: number;
+  v: number;
+  depth: number;
+}
+/**
+ * Emulates ImagickPixelIterator's cursor, including the quirk the whole
+ * corpus is rendered with: next() on an unconsumed iterator (fresh or just
+ * rewound) fetches row 0 instead of advancing. Upstream's moveIterator never
+ * calls current(), so the first triangle part after a rewind draws every
+ * scanline ONE ROW ABOVE its computed y. Shared by a face's two triangles.
+ */
+declare class RowCursor {
+  row: number;
+  consumed: boolean;
+  /** Upstream moveIterator: rewind when past the target, then advance via next(). */
+  moveTo(targetRow: number): void;
+  /** current(): marks the row consumed and returns it. */
+  current(): number;
+  next(): void;
+  valid(height: number): boolean;
+}
+/** PHP round(): half away from zero, unlike Math.round's half toward +Infinity. */
+declare function phpRound(value: number): number;
+declare function drawTexturedTriangle(p1in: RasterPoint, p2in: RasterPoint, p3in: RasterPoint, buffer: FaceBuffer, texture: FloatTexture, cursor?: RowCursor): void;
+//#endregion
+export { drawTexturedTriangle as a, createFaceBuffer as i, RasterPoint as n, phpRound as o, RowCursor as r, FaceBuffer as t };

package/dist/registry-C9E7jyzG.js

@@ -0,0 +1,28 @@
+import { o as createAtlasResolver, s as parseAtlasSources } from "./sources-Bxk-WOzH.js";
+//#region src/atlas/registry.ts
+/**
+* Collects every `atlases/*.json` across namespaces into one resolver.
+* Load order matches upstream: sources from later-loaded files win, so the
+* resolver checks sources in reverse. Unknown source types are skipped with a
+* warning rather than failing the run (mods ship experimental types).
+*/
+async function loadAtlasResolver(resources, loadTexture, onWarning) {
+	const sources = [];
+	for (const namespace of await resources.listNamespaces()) {
+		const atlasFiles = await resources.listResources("atlas", namespace);
+		atlasFiles.sort((a, b) => a.path.localeCompare(b.path));
+		for (const file of atlasFiles) {
+			const copies = await resources.getAllResources("atlas", file);
+			copies.reverse();
+			for (const raw of copies) try {
+				const json = JSON.parse(raw.toString("utf8"));
+				sources.push(...parseAtlasSources(namespace, json, loadTexture, (type) => onWarning?.(`Skipping unknown atlas source type ${type} in ${file}`), (locator) => resources.hasResource("texture", locator)));
+			} catch (err) {
+				onWarning?.(`Unparseable atlas ${file}: ${err.message}`);
+			}
+		}
+	}
+	return createAtlasResolver(sources);
+}
+//#endregion
+export { loadAtlasResolver as t };

package/dist/render/blend.d.ts

@@ -0,0 +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";
+export { FloatTexture, blendPixel, cloneFloatTexture, darkenTexture, q16, tintTexture, toByteTexture, toFloatTexture };

package/dist/render/blend.js

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

package/dist/render/compose.d.ts

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

package/dist/render/compose.js

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

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

@@ -0,0 +1,30 @@
+import { a as ResourceManager } from "../manager-CoZaeQTu.js";
+import { i as TextureLoader } from "../loader-TFFNV4Jl.js";
+import { t as ModelLoader } from "../loader-lCkMRDH4.js";
+import { t as FloatTexture } from "../blend-Qvrn6YgK.js";
+import { n as TintColor } from "../face-DC6cNMdz.js";
+import { n as RenderOptions } from "../renderer-DQfv6axF.js";
+//#region src/render/entity-fallback.d.ts
+/**
+ * Dyed variants of vanilla items whose models mods generate at runtime (quark's
+ * `black_frame_empty` parents a block model that exists nowhere on disk): render
+ * the vanilla base item tinted with the dye color. Suffixes like `_empty`/`_map`
+ * are state variants of the same icon.
+ */
+declare function renderDyedVariantFallback(id: string, models: ModelLoader, textures: TextureLoader, options: RenderOptions): Promise<FloatTexture | null>;
+/**
+ * Derive spawn-egg tints from the mob's entity texture. Mod egg colors live
+ * in item-registration code, so the two dominant colors of the entity skin
+ * stand in: primary = biggest color cluster, secondary = biggest cluster
+ * visually distinct from it. Returns null when no entity texture matches —
+ * the egg then renders untinted, as before.
+ */
+declare function spawnEggTints(id: string, resources: ResourceManager, textures: TextureLoader): Promise<TintColor[] | null>;
+/**
+ * Render a code-rendered (builtin/entity) item through builtin geometry when
+ * its name identifies the kind. Returns null when no heuristic applies —
+ * this must never guess across kinds.
+ */
+declare function renderEntityFallback(id: string, models: ModelLoader, textures: TextureLoader, resources: ResourceManager, options: RenderOptions): Promise<FloatTexture | null>;
+//#endregion
+export { renderDyedVariantFallback, renderEntityFallback, spawnEggTints };

package/dist/render/entity-fallback.js

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

package/dist/render/face.d.ts

@@ -0,0 +1,2 @@
+import { i as renderFace, n as TintColor, r as faceMaxZ, t as RenderableFace } from "../face-DC6cNMdz.js";
+export { RenderableFace, TintColor, faceMaxZ, renderFace };

package/dist/render/face.js

@@ -0,0 +1,2 @@
+import { n as renderFace, t as faceMaxZ } from "../face-Wfia-_Yx.js";
+export { faceMaxZ, renderFace };

package/dist/render/fluid-bucket.d.ts

@@ -0,0 +1,14 @@
+import { a as ResourceManager } from "../manager-CoZaeQTu.js";
+import { i as TextureLoader, r as Texture } from "../loader-TFFNV4Jl.js";
+//#region src/render/fluid-bucket.d.ts
+/**
+ * Paint the fluid into a bucket sprite IN PLACE (pass a copy, never a cached
+ * texture) at native sprite resolution. The unpainted sprite doubles as the
+ * empty-bucket reference: fill pixels are where water_bucket is opaque and the
+ * bucket is not, and each pixel's condition reads state that painting never
+ * touches. Returns false when the fluid can't be resolved — the plain bucket
+ * stays, which is the old behavior.
+ */
+declare function paintBucketFluid(bucket: Texture, fluid: string, textures: TextureLoader, resources?: ResourceManager): Promise<boolean>;
+//#endregion
+export { paintBucketFluid };

package/dist/render/fluid-bucket.js

@@ -0,0 +1,2 @@
+import { t as paintBucketFluid } from "../fluid-bucket-D-GpUQjg.js";
+export { paintBucketFluid };

package/dist/render/geo.d.ts

@@ -0,0 +1,54 @@
+import { n as ResourceLocator } from "../locator-jDbdUeTd.js";
+import { a as ResourceManager } from "../manager-CoZaeQTu.js";
+import { i as TextureLoader } from "../loader-TFFNV4Jl.js";
+import { t as FloatTexture } from "../blend-Qvrn6YgK.js";
+import { n as FaceGeometry } from "../geometry-BSVmKx5b.js";
+import { n as RenderOptions } from "../renderer-DQfv6axF.js";
+//#region src/render/geo.d.ts
+interface GeoCube {
+  origin?: number[];
+  size?: number[];
+  uv?: number[] | Record<string, {
+    uv: number[];
+    uv_size?: number[];
+  }>;
+  inflate?: number;
+  pivot?: number[];
+  rotation?: number[];
+}
+interface GeoBone {
+  name?: string;
+  parent?: string;
+  pivot?: number[];
+  rotation?: number[];
+  cubes?: GeoCube[];
+}
+interface GeoDescription {
+  texture_width?: number;
+  texture_height?: number;
+}
+interface GeoFile {
+  'minecraft:geometry'?: Array<{
+    description?: GeoDescription;
+    bones?: GeoBone[];
+  }>;
+  [key: string]: unknown;
+}
+interface ParsedGeo {
+  textureWidth: number;
+  textureHeight: number;
+  bones: GeoBone[];
+}
+/** Handles both the modern (1.12+) and legacy (`geometry.name` keyed) layouts. */
+declare function parseGeo(json: GeoFile): ParsedGeo | null;
+/** Convert a parsed geo into face geometry, unit-cube fitted with gui pose. */
+declare function geoToFaces(geo: ParsedGeo): FaceGeometry[];
+/** Conventional locations GeckoLib mods keep item geometry and textures. */
+declare function findGeoForItem(resources: ResourceManager, id: string): Promise<{
+  geo: ParsedGeo;
+  texture: ResourceLocator;
+} | null>;
+/** Render a parsed geo with the standard block gui pose. */
+declare function renderGeo(geo: ParsedGeo, texture: ResourceLocator, textures: TextureLoader, options: RenderOptions): Promise<FloatTexture | null>;
+//#endregion
+export { findGeoForItem, geoToFaces, parseGeo, renderGeo };

package/dist/render/geo.js

@@ -0,0 +1,2 @@
+import { i as renderGeo, n as geoToFaces, r as parseGeo, t as findGeoForItem } from "../geo-B5VqGulc.js";
+export { findGeoForItem, geoToFaces, parseGeo, renderGeo };

package/dist/render/geometry.d.ts

@@ -0,0 +1,2 @@
+import { i as buildElementFaces, n as FaceGeometry, r as applyElementRotation, t as FACE_NORMALS } from "../geometry-BSVmKx5b.js";
+export { FACE_NORMALS, FaceGeometry, applyElementRotation, buildElementFaces };

package/dist/render/geometry.js

@@ -0,0 +1,2 @@
+import { n as applyElementRotation, r as buildElementFaces, t as FACE_NORMALS } from "../geometry-uIDha8S4.js";
+export { FACE_NORMALS, applyElementRotation, buildElementFaces };

package/dist/render/legacy-tints.d.ts

@@ -0,0 +1,12 @@
+import { i as TextureLoader } from "../loader-TFFNV4Jl.js";
+import { n as TintColor } from "../face-DC6cNMdz.js";
+//#region src/render/legacy-tints.d.ts
+/**
+ * Tints for a model rendered without an item definition (pre-1.21.4 eras and
+ * modded models/item trees). Walks the resolved chain deepest-first, so an
+ * item model beats the block model it parents, matching upstream's per-model
+ * binding. Returns null when nothing in the chain is tinted.
+ */
+declare function legacyTintsForChain(chain: string[], textures: TextureLoader): Promise<Array<TintColor | null> | null>;
+//#endregion
+export { legacyTintsForChain };

package/dist/render/legacy-tints.js

@@ -0,0 +1,2 @@
+import { t as legacyTintsForChain } from "../legacy-tints-B09J0Rxh.js";
+export { legacyTintsForChain };

package/dist/render/lighting.d.ts

@@ -0,0 +1,2 @@
+import { a as LightingProfileName, c as legacyFrontLight, i as LightingProfile, l as legacySideLight, n as LegacyLightSource, o as guiFrontLight, r as LightSource, s as guiSideLight, t as DiffuseLightSource, u as lightsForProfile } from "../lighting-3FGRC3Af.js";
+export { DiffuseLightSource, LegacyLightSource, LightSource, LightingProfile, LightingProfileName, guiFrontLight, guiSideLight, legacyFrontLight, legacySideLight, lightsForProfile };

package/dist/render/lighting.js

@@ -0,0 +1,2 @@
+import { a as guiSideLight, c as lightsForProfile, i as guiFrontLight, n as LegacyLightSource, o as legacyFrontLight, r as LightingProfile, s as legacySideLight, t as DiffuseLightSource } from "../lighting--5myudVu.js";
+export { DiffuseLightSource, LegacyLightSource, LightingProfile, guiFrontLight, guiSideLight, legacyFrontLight, legacySideLight, lightsForProfile };

package/dist/render/obj.d.ts

@@ -0,0 +1,24 @@
+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 { n as Vec3 } from "../vector-DRKRi4--.js";
+import { n as RenderOptions } from "../renderer-DQfv6axF.js";
+//#region src/render/obj.d.ts
+interface ObjTriangle {
+  positions: [Vec3, Vec3, Vec3];
+  uvs: [[number, number], [number, number], [number, number]];
+  material: string;
+}
+interface ParsedObj {
+  triangles: ObjTriangle[];
+  /** MTL library paths referenced via mtllib, relative to the OBJ's directory. */
+  materialLibs: string[];
+}
+/** Parse OBJ text into triangles (polygon faces are fan-triangulated). */
+declare function parseObj(text: string, flipV: boolean): ParsedObj;
+/** map_Kd texture per material name out of an MTL library. */
+declare function parseMtl(text: string): Map<string, string>;
+declare function renderObjModel(model: ResolvedModel, resources: ResourceManager, textures: TextureLoader, options: RenderOptions): Promise<FloatTexture>;
+//#endregion
+export { parseMtl, parseObj, renderObjModel };

package/dist/render/obj.js

@@ -0,0 +1,2 @@
+import { c as renderObjModel, o as parseMtl, s as parseObj } from "../renderer-CmOz6WI9.js";
+export { parseMtl, parseObj, renderObjModel };

package/dist/render/rasterizer.d.ts

@@ -0,0 +1,2 @@
+import { a as drawTexturedTriangle, i as createFaceBuffer, n as RasterPoint, o as phpRound, r as RowCursor, t as FaceBuffer } from "../rasterizer-CVOlRsuw.js";
+export { FaceBuffer, RasterPoint, RowCursor, createFaceBuffer, drawTexturedTriangle, phpRound };

package/dist/render/rasterizer.js

@@ -0,0 +1,2 @@
+import { i as phpRound, n as createFaceBuffer, r as drawTexturedTriangle, t as RowCursor } from "../rasterizer-ABgsWTYN.js";
+export { RowCursor, createFaceBuffer, drawTexturedTriangle, phpRound };

package/dist/render/renderer.d.ts

@@ -0,0 +1,2 @@
+import { a as pointResize, i as boxDownscale, n as RenderOptions, o as renderModel, r as RenderedFrames, s as renderModelFrames, t as ItemRenderError } from "../renderer-DQfv6axF.js";
+export { ItemRenderError, RenderOptions, RenderedFrames, boxDownscale, pointResize, renderModel, renderModelFrames };

package/dist/render/renderer.js

@@ -0,0 +1,2 @@
+import { a as renderModelFrames, i as renderModel, n as boxDownscale, r as pointResize, t as ItemRenderError } from "../renderer-CmOz6WI9.js";
+export { ItemRenderError, boxDownscale, pointResize, renderModel, renderModelFrames };

package/dist/render/tints.d.ts

@@ -0,0 +1,2 @@
+import { a as resolveTint, i as parseTintValue, n as InvalidTinterDefinitionError, o as resolveTints, r as TintContext, t as DYE_COLORS } from "../tints-Fr6WoPaU.js";
+export { DYE_COLORS, InvalidTinterDefinitionError, TintContext, parseTintValue, resolveTint, resolveTints };

package/dist/render/tints.js

@@ -0,0 +1,2 @@
+import { a as resolveTints, i as resolveTint, n as InvalidTinterDefinitionError, r as parseTintValue, t as DYE_COLORS } from "../tints-FQlxTzUL.js";
+export { DYE_COLORS, InvalidTinterDefinitionError, parseTintValue, resolveTint, resolveTints };

package/dist/render/vector.d.ts

@@ -0,0 +1,2 @@
+import { _ as transformDirection, a as dot, b as vec3, c as identity, d as rotationEuler, f as rotationX, g as sub, h as scaling, i as displayMatrix, l as multiply, m as rotationZ, n as Vec3, o as fromItemTransform, p as rotationY, r as cross, s as fromQuaternion, t as Mat4, u as normalize, v as transformVector, y as translation } from "../vector-DRKRi4--.js";
+export { Mat4, Vec3, cross, displayMatrix, dot, fromItemTransform, fromQuaternion, identity, multiply, normalize, rotationEuler, rotationX, rotationY, rotationZ, scaling, sub, transformDirection, transformVector, translation, vec3 };

package/dist/render/vector.js

@@ -0,0 +1,2 @@
+import { _ as translation, a as fromQuaternion, c as normalize, d as rotationY, f as rotationZ, g as transformVector, h as transformDirection, i as fromItemTransform, l as rotationEuler, m as sub, n as displayMatrix, o as identity, p as scaling, r as dot, s as multiply, t as cross, u as rotationX, v as vec3 } from "../vector-CCxLae_T.js";
+export { cross, displayMatrix, dot, fromItemTransform, fromQuaternion, identity, multiply, normalize, rotationEuler, rotationX, rotationY, rotationZ, scaling, sub, transformDirection, transformVector, translation, vec3 };