@nodecraft/rendermite 0.0.1 → 1.0.0

package/dist/fluid-bucket-D-GpUQjg.js

@@ -0,0 +1,88 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+//#region src/render/fluid-bucket.ts
+/**
+* Paint bucket contents for fluid_container loader models. Forge draws these
+* with a fluid sprite behind a mask texture we don't ship, but vanilla always
+* has both `bucket` and `water_bucket` sprites — their pixel diff IS the fill
+* region, and the fluid's average color (from its conventional still texture)
+* shaded by the water sprite's own shading paints it convincingly.
+*/
+/** Conventional homes for a fluid's still texture, most common first. */
+const STILL_TEXTURE_PATTERNS = [
+	(name) => `block/fluid/${name}_still`,
+	(name) => `block/${name}_still`,
+	(name) => `fluid/${name}_still`,
+	(name) => `block/fluid/${name}`,
+	(name) => `blocks/fluids/${name}_still`,
+	(name) => `blocks/${name}_still`
+];
+/** The particle texture declared by the fluid's block model, if any. */
+async function particleTexture(fluid, textures, resources) {
+	const raw = await resources.getResource("model", new ResourceLocator(fluid.namespace, `block/${fluid.path}`));
+	if (!raw) return null;
+	try {
+		const particle = JSON.parse(raw.toString("utf8")).textures?.particle;
+		const locator = typeof particle === "string" && !particle.startsWith("#") ? ResourceLocator.tryParse(particle) : null;
+		return locator ? await textures.load(locator) : null;
+	} catch {
+		return null;
+	}
+}
+/** Average color of a texture's opaque pixels, or null if fully transparent. */
+function averageColor(texture) {
+	let red = 0;
+	let green = 0;
+	let blue = 0;
+	let count = 0;
+	for (let offset = 0; offset < texture.data.length; offset += 4) {
+		if (texture.data[offset + 3] <= 128) continue;
+		red += texture.data[offset];
+		green += texture.data[offset + 1];
+		blue += texture.data[offset + 2];
+		count++;
+	}
+	return count === 0 ? null : [
+		red / count,
+		green / count,
+		blue / count
+	];
+}
+/**
+* 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.
+*/
+async function paintBucketFluid(bucket, fluid, textures, resources) {
+	const fluidLocator = ResourceLocator.tryParse(fluid);
+	if (!fluidLocator) return false;
+	let still = null;
+	for (const pattern of STILL_TEXTURE_PATTERNS) {
+		still = await textures.load(new ResourceLocator(fluidLocator.namespace, pattern(fluidLocator.path)));
+		if (still) break;
+	}
+	still ??= resources ? await particleTexture(fluidLocator, textures, resources) : null;
+	const color = still ? averageColor(still) : null;
+	if (!color) return false;
+	const water = await textures.load(ResourceLocator.parse("minecraft:item/water_bucket"));
+	if (!water || water.width !== bucket.width || water.height !== bucket.height) return false;
+	const luminance = (offset) => .299 * water.data[offset] + .587 * water.data[offset + 1] + .114 * water.data[offset + 2];
+	const isFill = (offset) => water.data[offset + 3] > 128 && (bucket.data[offset + 3] <= 128 || Math.abs(water.data[offset] - bucket.data[offset]) + Math.abs(water.data[offset + 1] - bucket.data[offset + 1]) + Math.abs(water.data[offset + 2] - bucket.data[offset + 2]) > 60);
+	let peakLuma = 1;
+	for (let offset = 0; offset < water.data.length; offset += 4) if (isFill(offset)) peakLuma = Math.max(peakLuma, luminance(offset));
+	let painted = false;
+	for (let offset = 0; offset < water.data.length; offset += 4) {
+		if (!isFill(offset)) continue;
+		const shade = luminance(offset) / peakLuma;
+		bucket.data[offset] = Math.min(255, color[0] * shade);
+		bucket.data[offset + 1] = Math.min(255, color[1] * shade);
+		bucket.data[offset + 2] = Math.min(255, color[2] * shade);
+		bucket.data[offset + 3] = 255;
+		painted = true;
+	}
+	return painted;
+}
+//#endregion
+export { paintBucketFluid as t };

package/dist/generators-CCB8h0mP.d.ts

@@ -0,0 +1,23 @@
+import { n as MapResourceManager } from "./synthetic-CDsj--li.js";
+//#region src/dynamic/generators.d.ts
+declare const TRIM_MATERIALS: readonly ["quartz", "iron", "gold", "diamond", "netherite", "redstone", "copper", "emerald", "lapis", "amethyst", "resin"];
+/** Materials with a darker variant used when the trim matches the armor metal. */
+declare const TRIM_DARKER_MATERIALS: Set<string>;
+declare const ARMOR_ITEM_TYPES: readonly ["boots", "leggings", "chestplate", "helmet"];
+declare const POTTERY_SHERDS: readonly ["brick", "angler", "archer", "arms_up", "blade", "brewer", "burn", "danger", "explorer", "friend", "heart", "heartbreak", "howl", "miner", "mourner", "plenty", "prize", "sheaf", "shelter", "skull", "snort", "flow", "guster", "scrape"];
+interface DynamicItem {
+  /** Item id including the synthetic namespace, e.g. `_armor_trims:helmet_trim_gold`. */
+  id: string;
+}
+interface DynamicResources {
+  layer: MapResourceManager;
+  items: DynamicItem[];
+}
+/**
+ * Materials whose trim sprites exist for the target version are discovered by
+ * the caller (via the atlas resolver); this generates the full matrix and lets
+ * missing sprites fail per item.
+ */
+declare function builtinDynamicResources(): DynamicResources;
+//#endregion
+export { TRIM_DARKER_MATERIALS as a, POTTERY_SHERDS as i, DynamicItem as n, TRIM_MATERIALS as o, DynamicResources as r, builtinDynamicResources as s, ARMOR_ITEM_TYPES as t };

package/dist/generators-CcVRG30y.js

@@ -0,0 +1,145 @@
+import { n as MapResourceManager } from "./synthetic-DC2bSnGe.js";
+//#region src/dynamic/generators.ts
+/**
+* Dynamic resources ported from renderchest's DynamicResourceGenerators, built
+* as plain model/item layers instead of code-backed namespaces: decorated pot
+* variants, leather armor trim layers, armor trim sprites (resolved by the
+* paletted_permutations atlas), and charged crossbows. The synthetic namespace
+* names (underscore prefix) match upstream so the CSS contract stays stable.
+*/
+const TRIM_MATERIALS = [
+	"quartz",
+	"iron",
+	"gold",
+	"diamond",
+	"netherite",
+	"redstone",
+	"copper",
+	"emerald",
+	"lapis",
+	"amethyst",
+	"resin"
+];
+/** Materials with a darker variant used when the trim matches the armor metal. */
+const TRIM_DARKER_MATERIALS = /* @__PURE__ */ new Set([
+	"iron",
+	"gold",
+	"diamond",
+	"netherite"
+]);
+const ARMOR_ITEM_TYPES = [
+	"boots",
+	"leggings",
+	"chestplate",
+	"helmet"
+];
+const POTTERY_SHERDS = [
+	"brick",
+	"angler",
+	"archer",
+	"arms_up",
+	"blade",
+	"brewer",
+	"burn",
+	"danger",
+	"explorer",
+	"friend",
+	"heart",
+	"heartbreak",
+	"howl",
+	"miner",
+	"mourner",
+	"plenty",
+	"prize",
+	"sheaf",
+	"shelter",
+	"skull",
+	"snort",
+	"flow",
+	"guster",
+	"scrape"
+];
+function sherdTextureName(sherd) {
+	return sherd === "brick" ? "brick" : `${sherd}_pottery_sherd`;
+}
+/**
+* Materials whose trim sprites exist for the target version are discovered by
+* the caller (via the atlas resolver); this generates the full matrix and lets
+* missing sprites fail per item.
+*/
+function builtinDynamicResources() {
+	const layer = new MapResourceManager();
+	const items = [];
+	for (const type of ARMOR_ITEM_TYPES) for (const material of TRIM_MATERIALS) {
+		const variants = TRIM_DARKER_MATERIALS.has(material) ? [material, `${material}_darker`] : [material];
+		for (const variant of variants) {
+			const name = `${type}_trim_${variant}`;
+			layer.set("model", `_armor_trims:item/${name}`, JSON.stringify({
+				parent: "minecraft:item/generated",
+				textures: { layer0: `minecraft:trims/items/${type}_trim_${variant}` }
+			}));
+			layer.set("itemDefinition", `_armor_trims:${name}`, JSON.stringify({ model: {
+				type: "minecraft:model",
+				model: `_armor_trims:item/${name}`
+			} }));
+			items.push({ id: `_armor_trims:${name}` });
+		}
+	}
+	for (const type of ARMOR_ITEM_TYPES) {
+		const entries = [[`leather_${type}_base`, { layer0: `minecraft:item/leather_${type}` }], [`leather_${type}_overlay`, { layer0: `minecraft:item/leather_${type}_overlay` }]];
+		for (const material of TRIM_MATERIALS) entries.push([`leather_${type}_${material}_trim`, {
+			layer0: `minecraft:item/leather_${type}_overlay`,
+			layer1: `minecraft:trims/items/${type}_trim_${material}`
+		}]);
+		for (const [name, textures] of entries) {
+			layer.set("model", `_leather_armor:item/${name}`, JSON.stringify({
+				parent: "minecraft:item/generated",
+				textures
+			}));
+			layer.set("itemDefinition", `_leather_armor:${name}`, JSON.stringify({ model: {
+				type: "minecraft:model",
+				model: `_leather_armor:item/${name}`
+			} }));
+			items.push({ id: `_leather_armor:${name}` });
+		}
+	}
+	for (const sherd of POTTERY_SHERDS) {
+		const texture = sherdTextureName(sherd);
+		layer.set("model", `_decorated_pot:pot_b_${sherd}`, JSON.stringify({
+			parent: "renderchest:item/decorated_pot",
+			textures: {
+				north: "#brick",
+				south: "#brick",
+				east: "#brick",
+				west: `#${texture}`
+			}
+		}));
+		layer.set("itemDefinition", `_decorated_pot:pot_b_${sherd}`, JSON.stringify({ model: {
+			type: "minecraft:model",
+			model: `_decorated_pot:pot_b_${sherd}`
+		} }));
+		items.push({ id: `_decorated_pot:pot_b_${sherd}` });
+		layer.set("model", `_decorated_pot:pot_o_${sherd}`, JSON.stringify({
+			parent: "renderchest:item/decorated_pot_overlay",
+			textures: { south: `#${texture}` }
+		}));
+		layer.set("itemDefinition", `_decorated_pot:pot_o_${sherd}`, JSON.stringify({ model: {
+			type: "minecraft:model",
+			model: `_decorated_pot:pot_o_${sherd}`
+		} }));
+		items.push({ id: `_decorated_pot:pot_o_${sherd}` });
+	}
+	for (const [name, model] of [["arrow", "minecraft:item/crossbow_arrow"], ["rocket", "minecraft:item/crossbow_firework"]]) {
+		layer.set("itemDefinition", `_crossbow:${name}`, JSON.stringify({ model: {
+			type: "minecraft:model",
+			model
+		} }));
+		items.push({ id: `_crossbow:${name}` });
+	}
+	return {
+		layer,
+		items
+	};
+}
+//#endregion
+export { builtinDynamicResources as a, TRIM_MATERIALS as i, POTTERY_SHERDS as n, TRIM_DARKER_MATERIALS as r, ARMOR_ITEM_TYPES as t };

package/dist/geo-B5VqGulc.js

@@ -0,0 +1,333 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import { n as displayMatrix } from "./vector-CCxLae_T.js";
+import { s as toFloatTexture } from "./blend-CHP2-j9U.js";
+import { t as combineFaceBuffers } from "./compose-cph4bfdr.js";
+import { n as renderFace, t as faceMaxZ } from "./face-Wfia-_Yx.js";
+import { c as lightsForProfile } from "./lighting--5myudVu.js";
+//#region src/render/geo.ts
+/**
+* Bedrock-format geometry (`.geo.json`) rendering, best-effort. GeckoLib mods
+* ship their item/entity geometry in this format and register the renderer in
+* Java code — the old pipeline extracted these files and never read them, so
+* every GeckoLib item was a guaranteed miss. Cubes + bone hierarchy convert
+* into the same face geometry the JSON-element pipeline rasterizes; the model
+* is auto-fitted into the unit cube and given the standard block gui pose.
+*/
+/** Handles both the modern (1.12+) and legacy (`geometry.name` keyed) layouts. */
+function parseGeo(json) {
+	const modern = json["minecraft:geometry"]?.[0];
+	if (modern?.bones) return {
+		textureWidth: modern.description?.texture_width ?? 64,
+		textureHeight: modern.description?.texture_height ?? 64,
+		bones: modern.bones
+	};
+	for (const [key, value] of Object.entries(json)) {
+		if (!(key.startsWith("geometry.") && value && typeof value === "object")) continue;
+		const legacy = value;
+		if (legacy.bones) return {
+			textureWidth: legacy.texturewidth ?? 64,
+			textureHeight: legacy.textureheight ?? 64,
+			bones: legacy.bones
+		};
+	}
+	return null;
+}
+function rotatePoint(point, pivot, rotation) {
+	const toRadians = Math.PI / 180;
+	let [x, y, z] = [
+		point[0] - pivot[0],
+		point[1] - pivot[1],
+		point[2] - pivot[2]
+	];
+	const [rx, ry, rz] = [
+		-rotation[0] * toRadians,
+		-rotation[1] * toRadians,
+		rotation[2] * toRadians
+	];
+	[x, y] = [x * Math.cos(rz) - y * Math.sin(rz), x * Math.sin(rz) + y * Math.cos(rz)];
+	[x, z] = [x * Math.cos(ry) + z * Math.sin(ry), -x * Math.sin(ry) + z * Math.cos(ry)];
+	[y, z] = [y * Math.cos(rx) - z * Math.sin(rx), y * Math.sin(rx) + z * Math.cos(rx)];
+	return [
+		x + pivot[0],
+		y + pivot[1],
+		z + pivot[2]
+	];
+}
+/** Standard Minecraft box unwrap for `uv: [u, v]` cubes. */
+function boxFaces(origin, size, u, v) {
+	const [ox, oy, oz] = origin;
+	const [sx, sy, sz] = size;
+	const x1 = ox + sx;
+	const y1 = oy + sy;
+	const z1 = oz + sz;
+	const corner = (x, y, z) => [
+		x,
+		y,
+		z
+	];
+	return [
+		{
+			direction: "up",
+			corners: [
+				corner(ox, y1, oz),
+				corner(x1, y1, oz),
+				corner(x1, y1, z1),
+				corner(ox, y1, z1)
+			],
+			uv: [
+				u + sz,
+				v,
+				u + sz + sx,
+				v + sz
+			]
+		},
+		{
+			direction: "down",
+			corners: [
+				corner(ox, oy, z1),
+				corner(x1, oy, z1),
+				corner(x1, oy, oz),
+				corner(ox, oy, oz)
+			],
+			uv: [
+				u + sz + sx,
+				v,
+				u + sz + sx + sx,
+				v + sz
+			]
+		},
+		{
+			direction: "north",
+			corners: [
+				corner(x1, y1, oz),
+				corner(ox, y1, oz),
+				corner(ox, oy, oz),
+				corner(x1, oy, oz)
+			],
+			uv: [
+				u + sz,
+				v + sz,
+				u + sz + sx,
+				v + sz + sy
+			]
+		},
+		{
+			direction: "south",
+			corners: [
+				corner(ox, y1, z1),
+				corner(x1, y1, z1),
+				corner(x1, oy, z1),
+				corner(ox, oy, z1)
+			],
+			uv: [
+				u + sz + sx + sz,
+				v + sz,
+				u + sz + sx + sz + sx,
+				v + sz + sy
+			]
+		},
+		{
+			direction: "east",
+			corners: [
+				corner(x1, y1, z1),
+				corner(x1, y1, oz),
+				corner(x1, oy, oz),
+				corner(x1, oy, z1)
+			],
+			uv: [
+				u,
+				v + sz,
+				u + sz,
+				v + sz + sy
+			]
+		},
+		{
+			direction: "west",
+			corners: [
+				corner(ox, y1, oz),
+				corner(ox, y1, z1),
+				corner(ox, oy, z1),
+				corner(ox, oy, oz)
+			],
+			uv: [
+				u + sz + sx,
+				v + sz,
+				u + sz + sx + sz,
+				v + sz + sy
+			]
+		}
+	];
+}
+/** Convert a parsed geo into face geometry, unit-cube fitted with gui pose. */
+function geoToFaces(geo) {
+	const bonesByName = /* @__PURE__ */ new Map();
+	for (const bone of geo.bones) if (bone.name) bonesByName.set(bone.name, bone);
+	const boneChain = (bone) => {
+		const chain = [];
+		let current = bone;
+		while (current) {
+			chain.push(current);
+			current = current.parent ? bonesByName.get(current.parent) : void 0;
+			if (chain.length > 32) break;
+		}
+		return chain;
+	};
+	const faces = [];
+	const min = [
+		Infinity,
+		Infinity,
+		Infinity
+	];
+	const max = [
+		-Infinity,
+		-Infinity,
+		-Infinity
+	];
+	for (const bone of geo.bones) {
+		const chain = boneChain(bone);
+		for (const cube of bone.cubes ?? []) {
+			if (!cube.origin || !cube.size) continue;
+			const inflate = cube.inflate ?? 0;
+			const origin = [
+				cube.origin[0] - inflate,
+				cube.origin[1] - inflate,
+				cube.origin[2] - inflate
+			];
+			const size = [
+				cube.size[0] + inflate * 2,
+				cube.size[1] + inflate * 2,
+				cube.size[2] + inflate * 2
+			];
+			const uvBase = Array.isArray(cube.uv) ? cube.uv : null;
+			const perFace = !Array.isArray(cube.uv) && cube.uv ? cube.uv : null;
+			for (const spec of boxFaces(origin, size, uvBase?.[0] ?? 0, uvBase?.[1] ?? 0)) {
+				let uvRect = spec.uv;
+				if (perFace) {
+					const entry = perFace[spec.direction];
+					if (!entry) continue;
+					const uvSize = entry.uv_size ?? [size[0], size[1]];
+					uvRect = [
+						entry.uv[0],
+						entry.uv[1],
+						entry.uv[0] + uvSize[0],
+						entry.uv[1] + uvSize[1]
+					];
+				}
+				let corners = spec.corners.map((point) => [...point]);
+				if (cube.rotation && cube.pivot) corners = corners.map((point) => rotatePoint(point, cube.pivot, cube.rotation));
+				for (const link of chain) if (link.rotation && link.pivot) corners = corners.map((point) => rotatePoint(point, link.pivot, link.rotation));
+				corners = corners.map((point) => [
+					-point[0],
+					point[1],
+					point[2]
+				]);
+				for (const point of corners) for (let axis = 0; axis < 3; axis++) {
+					min[axis] = Math.min(min[axis], point[axis]);
+					max[axis] = Math.max(max[axis], point[axis]);
+				}
+				faces.push({
+					direction: spec.direction,
+					vertices: corners,
+					uv1: [uvRect[0] / geo.textureWidth, uvRect[1] / geo.textureHeight],
+					uv2: [uvRect[2] / geo.textureWidth, uvRect[3] / geo.textureHeight],
+					textureRef: "#geo",
+					rotation: 0,
+					tintIndex: null,
+					shadeDirectionOverride: null
+				});
+			}
+		}
+	}
+	const extent = Math.max(max[0] - min[0], max[1] - min[1], max[2] - min[2]);
+	if (!Number.isFinite(extent) || extent <= 0) return [];
+	const scale = 1 / extent;
+	const center = [
+		(min[0] + max[0]) / 2,
+		(min[1] + max[1]) / 2,
+		(min[2] + max[2]) / 2
+	];
+	for (const face of faces) for (const vertex of face.vertices) for (let axis = 0; axis < 3; axis++) vertex[axis] = (vertex[axis] - center[axis]) * scale + .5;
+	return faces;
+}
+/** Conventional locations GeckoLib mods keep item geometry and textures. */
+async function findGeoForItem(resources, id) {
+	const locator = ResourceLocator.parse(id);
+	const geoPaths = [
+		`geo/${locator.path}.geo.json`,
+		`geo/item/${locator.path}.geo.json`,
+		`geckolib/geo/${locator.path}.geo.json`,
+		`models/geo/${locator.path}.geo.json`
+	];
+	if (!(await Promise.all(geoPaths.map((path) => resources.hasResource("raw", new ResourceLocator(locator.namespace, path))))).includes(true)) {
+		const name = locator.path.split("/").pop();
+		const matches = (await resources.listResources("raw", locator.namespace)).map((candidate) => candidate.path).filter((path) => path.endsWith(`/${name}.geo.json`) && /(?:^|\/)(?:geo|geckolib)\//.test(path)).toSorted((a, b) => a.length - b.length);
+		geoPaths.push(...matches);
+	}
+	for (const geoPath of geoPaths) {
+		const raw = await resources.getResource("raw", new ResourceLocator(locator.namespace, geoPath));
+		if (!raw) continue;
+		let geo;
+		try {
+			geo = parseGeo(JSON.parse(raw.toString("utf8")));
+		} catch {
+			continue;
+		}
+		if (!geo) continue;
+		const mirrored = geoPath.replace(/(^|\/)(geo|geckolib\/geo|models\/geo)\//, "$1").replace(/^\//, "").replace(/\.geo\.json$/, "");
+		for (const texturePath of [
+			mirrored,
+			`item/${locator.path}`,
+			`items/${locator.path}`,
+			`geo/${locator.path}`
+		]) {
+			const texture = new ResourceLocator(locator.namespace, texturePath);
+			if (await resources.hasResource("texture", texture)) return {
+				geo,
+				texture
+			};
+		}
+	}
+	return null;
+}
+/** Render a parsed geo with the standard block gui pose. */
+async function renderGeo(geo, texture, textures, options) {
+	const faces = geoToFaces(geo);
+	if (faces.length === 0) return null;
+	const loaded = await textures.load(texture);
+	if (!loaded) return null;
+	const float = toFloatTexture(loaded);
+	const lights = lightsForProfile(options.lightingProfile);
+	const renderSize = options.size * options.quality;
+	const transformation = displayMatrix([
+		30,
+		225,
+		0
+	], [
+		0,
+		0,
+		0
+	], [
+		.9,
+		.9,
+		.9
+	]);
+	const renderable = faces.map((geometry) => {
+		return {
+			geometry,
+			texture: float,
+			light: lights.side,
+			tint: null,
+			maxZ: faceMaxZ(geometry)
+		};
+	});
+	renderable.sort((a, b) => a.maxZ - b.maxZ);
+	const buffers = [];
+	for (const face of renderable) {
+		const buffer = renderFace(face, renderSize, renderSize, transformation);
+		if (buffer) buffers.push(buffer);
+	}
+	if (buffers.length === 0) return null;
+	return combineFaceBuffers(renderSize, renderSize, buffers);
+}
+//#endregion
+export { renderGeo as i, geoToFaces as n, parseGeo as r, findGeoForItem as t };

package/dist/geometry-BSVmKx5b.d.ts

@@ -0,0 +1,28 @@
+import { a as FaceDirectionName, o as ModelElementJson, r as ElementRotationJson } from "./types-COGbtA1t.js";
+import { n as Vec3 } from "./vector-DRKRi4--.js";
+//#region src/render/geometry.d.ts
+interface FaceGeometry {
+  direction: FaceDirectionName;
+  /** Shared, possibly rotation-mutated corner vectors, in quad order v0..v3. */
+  vertices: [Vec3, Vec3, Vec3, Vec3];
+  /** Normalized UV rect corners (0–1). */
+  uv1: [number, number];
+  uv2: [number, number];
+  textureRef: string;
+  /** Degrees 0/90/180/270 — rotates the UV corner assignment. */
+  rotation: number;
+  tintIndex: number | null;
+  shadeDirectionOverride: Vec3 | null;
+}
+declare const FACE_NORMALS: Record<FaceDirectionName, Vec3>;
+declare function buildElementFaces(element: ModelElementJson): FaceGeometry[];
+/**
+ * Element rotation mutates the shared corner vectors in place, after face/UV
+ * construction. Supports the vanilla {origin, axis, angle} form and the newer
+ * per-axis {origin, x?, y?, z?} form (applied X, then Y, then Z). `rotation_rc`
+ * takes precedence when present (renderchest escape hatch). No angle restriction,
+ * no rescale — matching upstream.
+ */
+declare function applyElementRotation(rotation: ElementRotationJson | undefined, corners: Vec3[]): void;
+//#endregion
+export { buildElementFaces as i, FaceGeometry as n, applyElementRotation as r, FACE_NORMALS as t };