@nodecraft/rendermite 1.4.1 → 1.6.0

package/dist/entity-models-c2HpfdWV.d.ts

@@ -0,0 +1,49 @@
+import { a as ResourceManager } from "./manager-exOIcdyx.js";
+import { S as EntityPackModel } from "./pack-format-QcVFxG_b.js";
+//#region src/blocks/entity-models.d.ts
+/** What the exporter needs to read code out of; a jar, in practice. */
+interface ClassSource {
+  list: () => Promise<string[]>;
+  read: (internalName: string) => Promise<Uint8Array | null>;
+}
+interface EntityGeometryResult {
+  /** Model id (the class it came from) → geometry. */
+  models: Record<string, EntityPackModel>;
+  /** Entity id → model id, for the entity table to point with. */
+  modelOf: Map<string, string>;
+  /** Entity sheets the models address, to be stitched into the pack's own atlas. */
+  spriteIds: Set<string>;
+  failures: Array<{
+    id: string;
+    reason: string;
+  }>;
+}
+interface CollectEntityGeometryOptions {
+  version: string;
+  /** Where mappings cache; the same directory the jars do. */
+  cacheDir: string;
+  classes: ClassSource;
+  /** Entity ids to look for, as the registry named them. */
+  entityIds: readonly string[];
+  /** The sheet each entity resolved to, from the entity registry, keyed by entity id. */
+  textureOf: ReadonlyMap<string, string>;
+  /**
+   * The assets, for the mods whose geometry is not in code at all.
+   *
+   * A GeckoLib mob ships Blockbench's bedrock format and registers it by resource location, so there
+   * is nothing for the interpreter to read; `entity-geo.ts` finds and converts it instead.
+   */
+  resources?: ResourceManager;
+  onProgress?: (done: number, total: number) => void;
+}
+/**
+ * Recovers geometry for as many of `entityIds` as the code describes.
+ *
+ * Mappings are resolved once: downloaded for an obfuscated jar, and the identity for one that is not
+ * (from the 26 line the client ships in the clear, and a mod jar never was obfuscated). A version that
+ * is obfuscated *and* unmapped — 1.13.x — yields nothing, with the reason recorded once rather than
+ * per entity.
+ */
+declare function collectEntityGeometry(options: CollectEntityGeometryOptions): Promise<EntityGeometryResult>;
+//#endregion
+export { collectEntityGeometry as i, CollectEntityGeometryOptions as n, EntityGeometryResult as r, ClassSource as t };

package/dist/{export-Bllg8Fw7.d.ts → export-D8fLC1wS.d.ts}

@@ -1,4 +1,5 @@
 import { a as ResourceManager } from "./manager-exOIcdyx.js";
+import { t as ClassSource } from "./entity-models-c2HpfdWV.js";
 //#region src/blocks/export.d.ts
 interface ExportBlockPackOptions {
   resources: ResourceManager;
@@ -19,6 +20,28 @@ interface ExportBlockPackOptions {
   padding?: number;
   /** Ceiling on an atlas page's dimensions (default 4096). */
   maxPageSize?: number;
+  /**
+   * Export `items.json` and its own atlas: the flat sprite stacks for items that
+   * are not blocks, which is what a world viewer draws a dropped stack of a lead
+   * or a handful of charcoal from. On by default.
+   */
+  items?: boolean;
+  /**
+   * Export `entities.json`: every entity type the namespaces register, with a display name and the
+   * mean colour of its sheet. On by default. No geometry — no jar has any — but it is what lets a
+   * consumer name and tint the stand-in box it draws for a mob.
+   */
+  entities?: boolean;
+  /**
+   * Reads class files, for recovering entity geometry from the client's own code.
+   *
+   * Entity models are Java at every version, so without this a pack carries entity names and marker
+   * colours but no shapes. Absent for an `--assets` run, which has no code to read — the honest
+   * answer there is no geometry rather than a silent gap.
+   */
+  classes?: ClassSource;
+  /** Where mappings cache; the jar cache directory. */
+  cacheDir?: string;
   onProgress?: (stage: string, done: number, total: number) => void;
 }
 interface BlockPackFailure {
@@ -27,7 +50,7 @@ interface BlockPackFailure {
    * `intentional` is not a failure: it marks a block that is empty because the
    * game draws nothing for it. Filter it out to get the real gaps.
    */
-  kind: 'blockstate' | 'model' | 'texture' | 'sprite' | 'geometry' | 'tint' | 'biome' | 'intentional';
+  kind: 'blockstate' | 'model' | 'texture' | 'sprite' | 'geometry' | 'tint' | 'biome' | 'item' | 'entity' | 'intentional';
   reason: string;
 }
 interface BlockPackResult {
@@ -37,6 +60,12 @@ interface BlockPackResult {
   pages: number;
   /** Biomes described in `biomes.json`; `0` means the file was not written. */
   biomes: number;
+  /** Flat items described in `items.json`; `0` means the file was not written. */
+  items: number;
+  /** Entity types described in `entities.json`; `0` means the file was not written. */
+  entities: number;
+  /** Distinct entity models in `entity-models.json`; `0` means the file was not written. */
+  entityModels: number;
   /** Files actually written — the only trustworthy success signal. */
   writtenFiles: number;
   failures: BlockPackFailure[];

package/dist/{export-kMoMes_a.js → export-DT_drDoI.js}

@@ -1,10 +1,14 @@
-import { t as packAtlas } from "./atlas-pack-CoOih7By.js";
 import { r as buildBiomeClimates } from "./biomes-5ZwYxMYe.js";
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
 import { n as blockEntityGeometry, r as synthesizeVariants, t as INVISIBLE_BLOCKS } from "./block-entities-xv3bQpEX.js";
 import { a as parseBlockState, n as collectModels } from "./blockstate-eval-BRQ3NWY2.js";
+import { t as collectEntities } from "./entities-DvmA9fEV.js";
+import { t as collectEntityGeometry } from "./entity-models-B6-0r2gR.js";
+import { n as discoverItems } from "./discovery-CD0QqxSF.js";
 import { a as salvageJson, i as resolveTexture, t as ModelLoader } from "./loader-C-NuJaEi.js";
-import { n as buildObjMesh } from "./obj-mesh-rnYbSbpv.js";
+import { t as collectItemSprites } from "./item-sprites-G-yikdfV.js";
+import { n as buildObjMesh } from "./obj-mesh-JwPkZEWL.js";
+import { n as buildSpriteSheet, t as MISSING_SPRITE } from "./sprite-sheet-LQAEtGkp.js";
 import { n as buildBlockTints, t as UNREGISTERED_TINTS } from "./tints-Cl0r-Ol3.js";
 import { t as loadAtlasResolver } from "./registry-DlduyjtM.js";
 import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
@@ -37,12 +41,6 @@ const RENDER_TYPES = {
 	translucent: "translucent",
 	translucent_moving_block: "translucent"
 };
-/**
-* A sprite whose strip is longer than this exports as its first frame only.
-* A broken `.mcmeta` can claim thousands of frames, and packing them would
-* blow the atlas out for one texture.
-*/
-const MAX_FRAMES_PER_SPRITE = 256;
 const FACE_DIRECTIONS = /* @__PURE__ */ new Set([
 	"down",
 	"up",
@@ -57,15 +55,6 @@ const CULLFACE_ALIASES = {
 	top: "up"
 };
 /**
-* Vanilla's own id for the missing-texture sprite. A face whose texture does
-* not resolve is drawn by the game in black and magenta rather than skipped —
-* Blockbench leaves `"texture": "#missing"` on unassigned faces and mods ship
-* models naming textures they forgot to include. Dropping those faces would
-* put holes in geometry the player can see, and would read as our bug rather
-* than the mod's.
-*/
-const MISSING_SPRITE = "minecraft:missingno";
-/**
 * Fluids are blocks in `blockstates.json` but the game meshes them in code, so
 * their models state nothing and their textures would otherwise never reach the
 * atlas — leaving a consumer that has to mesh fluids itself with no pixels to do
@@ -80,24 +69,6 @@ const MISSING_SPRITE = "minecraft:missingno";
 const FLUID_SUFFIX = /_(?:still|flow|flowing)$/;
 /** Sampled where water meets a non-opaque neighbour; matches no suffix. */
 const EXTRA_FLUID_SPRITES = ["minecraft:block/water_overlay"];
-/** `MissingTextureAtlasSprite`: 16x16, black and magenta in 8px quarters. */
-function missingTexture() {
-	const size = 16;
-	const data = /* @__PURE__ */ new Uint8ClampedArray(1024);
-	for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
-		const magenta = x < 8 !== y < 8;
-		const offset = (y * size + x) * 4;
-		data[offset] = magenta ? 248 : 0;
-		data[offset + 1] = 0;
-		data[offset + 2] = magenta ? 248 : 0;
-		data[offset + 3] = 255;
-	}
-	return {
-		width: size,
-		height: size,
-		data
-	};
-}
 /**
 * Vanilla's `BlockElement.uvsByFace`: the UV a face gets when the model states
 * none. Deliberately not `render/geometry.ts`'s auto-UVs — those are in the
@@ -144,20 +115,6 @@ function defaultFaceUv(direction, from, to) {
 		];
 	}
 }
-/**
-* Alpha decides the render layer: vanilla assets do not state cutout versus
-* translucent (`render_type` is a loader extension adopted only recently), and
-* inferring it covers mods for free.
-*/
-function inferRenderLayer(frames) {
-	let sawHole = false;
-	for (const frame of frames) for (let offset = 3; offset < frame.data.length; offset += 4) {
-		const alpha = frame.data[offset];
-		if (alpha === 0) sawHole = true;
-		else if (alpha !== 255) return "translucent";
-	}
-	return sawHole ? "cutout" : "solid";
-}
 function sortedByKey(entries) {
 	return Object.fromEntries(Object.entries(entries).toSorted(([left], [right]) => left.localeCompare(right)));
 }
@@ -261,7 +218,7 @@ async function itemModelSubstitute(blockId, resources, models) {
 	}
 	const { emitted, sprites, tintIndices } = bakeModel(item.toString(), resolved, []);
 	if (emitted.elements.length === 0) return null;
-	if ((await Promise.all([...sprites].map(async (sprite) => sprite !== MISSING_SPRITE && await resources.hasResource("texture", ResourceLocator.parse(sprite))))).includes(false)) return null;
+	if ((await Promise.all([...sprites].map(async (sprite) => sprite !== "minecraft:missingno" && await resources.hasResource("texture", ResourceLocator.parse(sprite))))).includes(false)) return null;
 	return {
 		id: item.toString(),
 		emitted,
@@ -493,7 +450,7 @@ async function exportBlockPack(options) {
 			const substituteId = `rendermite:block/${ResourceLocator.parse(id).path}${suffix && `_${suffix}`}`;
 			const { emitted, sprites, tintIndices } = bakeModel(substituteId, bound, failures);
 			if (emitted.elements.length === 0) continue;
-			if ((await Promise.all([...sprites].map(async (sprite) => sprite !== MISSING_SPRITE && await resources.hasResource("texture", ResourceLocator.parse(sprite))))).includes(false)) {
+			if ((await Promise.all([...sprites].map(async (sprite) => sprite !== "minecraft:missingno" && await resources.hasResource("texture", ResourceLocator.parse(sprite))))).includes(false)) {
 				failures.push({
 					id,
 					kind: "geometry",
@@ -618,87 +575,20 @@ async function exportBlockPack(options) {
 	}
 	for (const namespace of namespaces) for (const locator of await resources.listResources("texture", namespace)) if (FLUID_SUFFIX.test(locator.path)) spriteIds.add(locator.toString());
 	for (const extra of EXTRA_FLUID_SPRITES) if (await resources.hasResource("texture", ResourceLocator.parse(extra))) spriteIds.add(extra);
-	const loaded = [];
-	const missingSprites = /* @__PURE__ */ new Set();
-	done = 0;
-	for (const id of [...spriteIds].toSorted((left, right) => left.localeCompare(right))) {
-		report("sprites", ++done, spriteIds.size);
-		if (id === MISSING_SPRITE) continue;
-		let animated;
-		try {
-			animated = await textures.loadAnimated(ResourceLocator.parse(id));
-		} catch (err) {
-			failures.push({
-				id,
-				kind: "sprite",
-				reason: err.message
-			});
-			missingSprites.add(id);
-			continue;
-		}
-		if (!animated) {
-			failures.push({
-				id,
-				kind: "sprite",
-				reason: "texture not found"
-			});
-			missingSprites.add(id);
-			continue;
-		}
-		const overlong = animated.frameCount > MAX_FRAMES_PER_SPRITE;
-		if (overlong) failures.push({
-			id,
-			kind: "sprite",
-			reason: `${animated.frameCount} frames exceeds the ${MAX_FRAMES_PER_SPRITE} cap; exported static`
-		});
-		const starts = overlong ? [0] : animated.frameStartTicks();
-		const total = overlong ? 1 : animated.tickLength;
-		const sequence = starts.map((start, index) => {
-			return {
-				frame: animated.resolveFrame(start).frame,
-				time: (index + 1 < starts.length ? starts[index + 1] : total) - start
-			};
-		});
-		const frames = /* @__PURE__ */ new Map();
-		for (const entry of sequence) if (!frames.has(entry.frame)) frames.set(entry.frame, animated.frame(entry.frame));
-		loaded.push({
-			id,
-			frames,
-			sequence,
-			interpolate: animated.interpolated
-		});
-	}
-	spriteIds.add(MISSING_SPRITE);
-	loaded.push({
-		id: MISSING_SPRITE,
-		frames: /* @__PURE__ */ new Map([[0, missingTexture()]]),
-		sequence: [{
-			frame: 0,
-			time: 1
-		}],
-		interpolate: false
-	});
-	const packed = packAtlas(loaded.flatMap((sprite) => [...sprite.frames].map(([index, texture]) => {
-		return {
-			key: `${sprite.id}#${index}`,
-			texture
-		};
-	})), {
+	const sheet = await buildSpriteSheet(spriteIds, textures, {
 		padding: options.padding,
-		maxPageSize: options.maxPageSize
+		maxPageSize: options.maxPageSize,
+		includeMissing: true,
+		onProgress: (count, total) => report("sprites", count, total)
 	});
-	for (const key of packed.oversized) {
-		const id = key.split("#", 1)[0];
-		if (!missingSprites.has(id)) {
-			failures.push({
-				id,
-				kind: "sprite",
-				reason: "sprite is larger than one atlas page; drawn as the missing texture"
-			});
-			missingSprites.add(id);
-		}
-	}
-	if (missingSprites.has(MISSING_SPRITE)) throw new Error("the missing-texture sprite does not fit an atlas page; maxPageSize is too small");
+	for (const failure of sheet.failures) failures.push({
+		id: failure.id,
+		kind: "sprite",
+		reason: failure.reason
+	});
+	const emittedSprites = sheet.sprites;
+	const missingSprites = sheet.missing;
+	spriteIds.add(MISSING_SPRITE);
 	if (missingSprites.size > 0) for (const model of Object.values(emittedModels)) {
 		for (const element of model.elements) for (const face of Object.values(element.faces)) if (missingSprites.has(face.sprite)) face.sprite = MISSING_SPRITE;
 		for (const group of model.mesh ?? []) if (missingSprites.has(group.sprite)) group.sprite = MISSING_SPRITE;
@@ -706,7 +596,7 @@ async function exportBlockPack(options) {
 	}
 	for (const [id, model] of Object.entries(emittedModels)) {
 		const sprites = [...model.elements.flatMap((element) => Object.values(element.faces).map((face) => face.sprite)), ...(model.mesh ?? []).map((group) => group.sprite)];
-		if (sprites.length > 0 && sprites.every((sprite) => sprite === MISSING_SPRITE)) failures.push({
+		if (sprites.length > 0 && sprites.every((sprite) => sprite === "minecraft:missingno")) failures.push({
 			id,
 			kind: "texture",
 			reason: "every face uses the missing-texture sprite; the model binds none of the textures it names"
@@ -717,32 +607,6 @@ async function exportBlockPack(options) {
 			reason: "model has no drawable elements"
 		});
 	}
-	const rects = new Map(packed.rects.map((rect) => [rect.key, rect]));
-	const emittedSprites = {};
-	for (const sprite of loaded) {
-		const first = rects.get(`${sprite.id}#${sprite.sequence[0].frame}`);
-		if (!first) continue;
-		const frames = [];
-		for (const entry of sprite.sequence) {
-			const rect = rects.get(`${sprite.id}#${entry.frame}`);
-			if (rect) frames.push({
-				page: rect.page,
-				x: rect.x,
-				y: rect.y,
-				time: entry.time
-			});
-		}
-		emittedSprites[sprite.id] = {
-			page: first.page,
-			x: first.x,
-			y: first.y,
-			w: first.width,
-			h: first.height,
-			layer: inferRenderLayer(sprite.frames.values().toArray()),
-			...frames.length === sprite.sequence.length && frames.length > 1 && { frames },
-			...sprite.interpolate && { interpolate: true }
-		};
-	}
 	const tints = await buildBlockTints(resources, textures);
 	for (const [block, references] of blockModels) {
 		const used = /* @__PURE__ */ new Set();
@@ -762,6 +626,142 @@ async function exportBlockPack(options) {
 		}
 	}
 	const biomes = await buildBiomeClimates(resources, namespaces);
+	let itemPack = null;
+	let itemPages = [];
+	if (options.items ?? true) {
+		const itemIds = [];
+		for (const namespace of namespaces) for (const item of await discoverItems(resources, namespace)) itemIds.push(item.id);
+		const collected = await collectItemSprites({
+			resources,
+			models,
+			textures,
+			namespaces,
+			blocks: new Set(Object.keys(blockStates)),
+			itemIds,
+			onProgress: (count, total) => report("items", count, total)
+		});
+		for (const failure of collected.failures) failures.push({
+			id: failure.id,
+			kind: "item",
+			reason: failure.reason
+		});
+		const itemSheet = await buildSpriteSheet(collected.spriteIds, textures, {
+			padding: options.padding,
+			maxPageSize: options.maxPageSize,
+			onProgress: (count, total) => report("item sprites", count, total)
+		});
+		for (const failure of itemSheet.failures) failures.push({
+			id: failure.id,
+			kind: "sprite",
+			reason: failure.reason
+		});
+		const items = {};
+		for (const [id, entry] of Object.entries(collected.items)) {
+			const lost = entry.layers.filter((layer) => itemSheet.missing.has(layer.sprite));
+			if (lost.length > 0) {
+				failures.push({
+					id,
+					kind: "item",
+					reason: `layer sprite ${lost.map((layer) => layer.sprite).join(", ")} has no atlas rect; item dropped`
+				});
+				continue;
+			}
+			items[id] = entry;
+		}
+		if (Object.keys(items).length > 0) {
+			itemPages = itemSheet.pages;
+			itemPack = {
+				padding: itemSheet.padding,
+				pages: itemPages.map((page, index) => {
+					return {
+						file: `item-atlas-${index}.png`,
+						width: page.width,
+						height: page.height
+					};
+				}),
+				sprites: sortedByKey(itemSheet.sprites),
+				items: sortedByKey(items)
+			};
+		}
+	}
+	let entityPack = null;
+	let entityModelPack = null;
+	let entityPages = [];
+	if (options.entities ?? true) {
+		const collected = await collectEntities({
+			resources,
+			textures,
+			namespaces,
+			onProgress: (count, total) => report("entities", count, total)
+		});
+		for (const failure of collected.failures) failures.push({
+			id: failure.id,
+			kind: "entity",
+			reason: failure.reason
+		});
+		if (options.classes) {
+			const textureOf = /* @__PURE__ */ new Map();
+			for (const [id, entry] of Object.entries(collected.entities)) if (entry.texture) textureOf.set(id, entry.texture);
+			const geometry = await collectEntityGeometry({
+				version,
+				cacheDir: options.cacheDir ?? output,
+				classes: options.classes,
+				entityIds: Object.keys(collected.entities),
+				textureOf,
+				resources,
+				onProgress: (count, total) => report("entity geometry", count, total)
+			});
+			for (const failure of geometry.failures) failures.push({
+				id: failure.id,
+				kind: "entity",
+				reason: failure.reason
+			});
+			for (const [id, model] of geometry.modelOf) collected.entities[id].model = model;
+			if (Object.keys(geometry.models).length > 0) {
+				const sheet = await buildSpriteSheet(geometry.spriteIds, textures, {
+					padding: options.padding,
+					maxPageSize: options.maxPageSize,
+					onProgress: (count, total) => report("entity sprites", count, total)
+				});
+				for (const failure of sheet.failures) failures.push({
+					id: failure.id,
+					kind: "sprite",
+					reason: failure.reason
+				});
+				const sheetSizes = /* @__PURE__ */ new Map();
+				for (const [id, model] of geometry.modelOf) {
+					const sprite = sheet.sprites[collected.entities[id].texture ?? ""];
+					if (sprite) {
+						const sizes = sheetSizes.get(model) ?? /* @__PURE__ */ new Set();
+						sizes.add(`${sprite.w}x${sprite.h}`);
+						sheetSizes.set(model, sizes);
+					}
+				}
+				for (const [model, sizes] of sheetSizes) {
+					const [only] = [...sizes];
+					if (sizes.size === 1) {
+						const [width, height] = only.split("x").map(Number);
+						geometry.models[model].textureSize = [width, height];
+					}
+				}
+				entityPages = sheet.pages;
+				entityModelPack = {
+					padding: sheet.padding,
+					pages: entityPages.map((page, index) => {
+						return {
+							file: `entity-atlas-${index}.png`,
+							width: page.width,
+							height: page.height
+						};
+					}),
+					sprites: sortedByKey(sheet.sprites),
+					models: sortedByKey(geometry.models)
+				};
+				for (const [id, entry] of Object.entries(collected.entities)) if (entry.texture && sheet.missing.has(entry.texture)) delete collected.entities[id].texture;
+			}
+		}
+		if (Object.keys(collected.entities).length > 0) entityPack = sortedByKey(collected.entities);
+	}
 	await mkdir(output, { recursive: true });
 	const hashes = {};
 	let writtenFiles = 0;
@@ -774,7 +774,7 @@ async function exportBlockPack(options) {
 		writtenFiles++;
 	};
 	const pageFiles = [];
-	for (const [index, page] of packed.pages.entries()) {
+	for (const [index, page] of sheet.pages.entries()) {
 		const file = `atlas-${index}.png`;
 		const raw = Buffer.from(page.data.buffer, page.data.byteOffset, page.data.byteLength);
 		await emit(file, await sharp(raw, { raw: {
@@ -788,9 +788,28 @@ async function exportBlockPack(options) {
 			height: page.height
 		});
 	}
+	for (const [index, page] of itemPages.entries()) {
+		const raw = Buffer.from(page.data.buffer, page.data.byteOffset, page.data.byteLength);
+		await emit(`item-atlas-${index}.png`, await sharp(raw, { raw: {
+			width: page.width,
+			height: page.height,
+			channels: 4
+		} }).png({ compressionLevel: 9 }).toBuffer());
+	}
+	if (itemPack) await emit("items.json", JSON.stringify(itemPack));
+	if (entityPack) await emit("entities.json", JSON.stringify(entityPack));
+	for (const [index, page] of entityPages.entries()) {
+		const raw = Buffer.from(page.data.buffer, page.data.byteOffset, page.data.byteLength);
+		await emit(`entity-atlas-${index}.png`, await sharp(raw, { raw: {
+			width: page.width,
+			height: page.height,
+			channels: 4
+		} }).png({ compressionLevel: 9 }).toBuffer());
+	}
+	if (entityModelPack) await emit("entity-models.json", JSON.stringify(entityModelPack));
 	for (const file of tints.files) await emit(file.path, file.data);
 	await emit("atlas.json", JSON.stringify({
-		padding: packed.padding,
+		padding: sheet.padding,
 		pages: pageFiles,
 		sprites: sortedByKey(emittedSprites)
 	}));
@@ -809,8 +828,11 @@ async function exportBlockPack(options) {
 		blocks: Object.keys(blockStates).length,
 		models: Object.keys(emittedModels).length,
 		sprites: Object.keys(emittedSprites).length,
-		pages: packed.pages.length,
+		pages: sheet.pages.length,
 		biomes: Object.keys(biomes.pack).length,
+		items: Object.keys(itemPack?.items ?? {}).length,
+		entities: Object.keys(entityPack ?? {}).length,
+		entityModels: Object.keys(entityModelPack?.models ?? {}).length,
 		failures: failures.length
 	};
 	await emit("meta.json", JSON.stringify({

package/dist/geo-CmjrXu0G.d.ts

@@ -0,0 +1,59 @@
+import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
+import { a as ResourceManager } from "./manager-exOIcdyx.js";
+import { i as TextureLoader } from "./loader-DUlx29PC.js";
+import { n as FloatTexture } from "./blend-eT64Z6qm.js";
+import { n as FaceGeometry } from "./geometry-Bkur58Vi.js";
+import { i as RenderOptions } from "./renderer-C_DFi8DF.js";
+//#region src/render/geo.d.ts
+interface GeoCube {
+  origin?: number[];
+  size?: number[];
+  uv?: number[] | Record<string, {
+    uv: number[];
+    uv_size?: number[];
+  }>;
+  inflate?: number;
+  /** Bedrock mirrors a box's texture rather than its geometry, so only a consumer's UVs care. */
+  mirror?: boolean;
+  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>;
+/** Name tokens, dropping the numeric suffixes mods use for shape variants. */
+/** Tokens of a name, for the matches that need to see through a mod's own spelling of it. */
+declare function nameTokens(name: string): string[];
+/** 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 { parseGeo as a, nameTokens as i, findGeoForItem as n, renderGeo as o, geoToFaces as r, ParsedGeo as t };

package/dist/{geo-BguldlU-.js → geo-Desq-gRC.js}

@@ -1,10 +1,10 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
 import { l as toFloatTexture } from "./blend-KXMclcHk.js";
+import { t as combineFaceBuffers } from "./compose-BGsNFR12.js";
+import { i as createFaceBuffer } from "./rasterizer-DcVJzkxz.js";
 import { n as displayMatrix } from "./vector-CCxLae_T.js";
+import { n as faceMaxZ, r as renderFace, t as createShadeCache } from "./face-B2JjWT46.js";
 import { c as lightsForProfile } from "./lighting--5myudVu.js";
-import { i as createFaceBuffer } from "./rasterizer-DcVJzkxz.js";
-import { t as combineFaceBuffers } from "./compose-BGsNFR12.js";
-import { n as faceMaxZ, r as renderFace, t as createShadeCache } from "./face-CKHboPfh.js";
 //#region src/render/geo.ts
 /**
 * Bedrock-format geometry (`.geo.json`) rendering, best-effort. GeckoLib mods
@@ -317,6 +317,7 @@ async function findGeoForItem(resources, id) {
 	return null;
 }
 /** Name tokens, dropping the numeric suffixes mods use for shape variants. */
+/** Tokens of a name, for the matches that need to see through a mod's own spelling of it. */
 function nameTokens(name) {
 	return name.split(/[/_]/).filter((token) => token.length > 0 && !/^\d+$/.test(token));
 }
@@ -407,4 +408,4 @@ async function renderGeo(geo, texture, textures, options) {
 	return combineFaceBuffers(renderSize, renderSize, buffers);
 }
 //#endregion
-export { renderGeo as i, geoToFaces as n, parseGeo as r, findGeoForItem as t };
+export { renderGeo as a, parseGeo as i, geoToFaces as n, nameTokens as r, findGeoForItem as t };