@nodecraft/rendermite 1.4.0 → 1.5.0

package/README.md

@@ -75,6 +75,7 @@ blocks/1.21.8/
   blockstates.json     # block id -> variants/multipart, keys and predicates pre-parsed
   tints.json           # plains tints, colormaps, ramps, per-block tint semantics
   colormap/*.png       # the version's own grass/foliage/dry_foliage maps
+  items.json           # flat item sprite stacks + their own atlas, for drawing dropped stacks
   failures.json        # anything not fully handled, with reasons, never silent
   meta.json            # version, counts, sha256 of every other file
 ```

package/dist/blocks/cli.js

@@ -1,2 +1,2 @@
-import { t as runBlocksCli } from "../cli-DqJtT-Ms.js";
+import { t as runBlocksCli } from "../cli-DMTaIbDI.js";
 export { runBlocksCli };

package/dist/blocks/export.d.ts

@@ -1,2 +1,2 @@
-import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "../export-Bllg8Fw7.js";
+import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "../export-wvt0Fryo.js";
 export { BlockPackFailure, BlockPackResult, ExportBlockPackOptions, exportBlockPack };

package/dist/blocks/export.js

@@ -1,2 +1,2 @@
-import { t as exportBlockPack } from "../export-kMoMes_a.js";
+import { t as exportBlockPack } from "../export-sadR0pWp.js";
 export { exportBlockPack };

package/dist/blocks/item-sprites.d.ts

@@ -0,0 +1,34 @@
+import { a as ResourceManager } from "../manager-exOIcdyx.js";
+import { i as TextureLoader } from "../loader-DUlx29PC.js";
+import { t as ModelLoader } from "../loader-DSir1-P0.js";
+import { _ as ItemPackEntry } from "../pack-format-oRExIeD3.js";
+//#region src/blocks/item-sprites.d.ts
+interface ItemSpriteFailure {
+  id: string;
+  reason: string;
+}
+interface ItemSpriteResult {
+  /** Flat items only, by item id; anything absent is the consumer's block-model job. */
+  items: Record<string, ItemPackEntry>;
+  /** Sprite ids to pack, which is every layer of every entry. */
+  spriteIds: Set<string>;
+  failures: ItemSpriteFailure[];
+}
+interface CollectItemSpritesOptions {
+  resources: ResourceManager;
+  models: ModelLoader;
+  textures: TextureLoader;
+  namespaces: readonly string[];
+  /**
+   * Ids the pack describes as blocks. Only used to decide whether a non-flat item
+   * is worth reporting: a stone block item drawing from `blockstates.json` is the
+   * design, while one nothing describes is a gap somebody should hear about.
+   */
+  blocks: ReadonlySet<string>;
+  /** Item ids to consider, as `discoverItems` yields them. */
+  itemIds: readonly string[];
+  onProgress?: (done: number, total: number) => void;
+}
+declare function collectItemSprites(options: CollectItemSpritesOptions): Promise<ItemSpriteResult>;
+//#endregion
+export { CollectItemSpritesOptions, ItemSpriteFailure, ItemSpriteResult, collectItemSprites };

package/dist/blocks/item-sprites.js

@@ -0,0 +1,2 @@
+import { t as collectItemSprites } from "../item-sprites-G-yikdfV.js";
+export { collectItemSprites };

package/dist/blocks/obj-mesh.js

@@ -1,2 +1,2 @@
-import { n as buildObjMesh, t as ObjMeshError } from "../obj-mesh-rnYbSbpv.js";
+import { n as buildObjMesh, t as ObjMeshError } from "../obj-mesh-CazmV8ya.js";
 export { ObjMeshError, buildObjMesh };

package/dist/blocks/pack-format.d.ts

@@ -1,2 +1,2 @@
-import { a as BlockPackBlockStatesFile, c as BlockPackMetaFile, d as BlockPackRenderLayer, f as BlockPackSprite, h as BlockPackVariant, i as BlockPackBlockState, l as BlockPackModel, m as BlockPackTintsFile, n as BlockPackAtlasPage, o as BlockPackElement, p as BlockPackSpriteFrame, r as BlockPackBiomesFile, s as BlockPackFace, t as BlockPackAtlasFile, u as BlockPackModelsFile } from "../pack-format-BVC_B-ZW.js";
-export { BlockPackAtlasFile, BlockPackAtlasPage, BlockPackBiomesFile, BlockPackBlockState, BlockPackBlockStatesFile, BlockPackElement, BlockPackFace, BlockPackMetaFile, BlockPackModel, BlockPackModelsFile, BlockPackRenderLayer, BlockPackSprite, BlockPackSpriteFrame, BlockPackTintsFile, BlockPackVariant };
+import { _ as ItemPackEntry, a as BlockPackBlockStatesFile, c as BlockPackItemsFile, d as BlockPackModelsFile, f as BlockPackRenderLayer, g as BlockPackVariant, h as BlockPackTintsFile, i as BlockPackBlockState, l as BlockPackMetaFile, m as BlockPackSpriteFrame, n as BlockPackAtlasPage, o as BlockPackElement, p as BlockPackSprite, r as BlockPackBiomesFile, s as BlockPackFace, t as BlockPackAtlasFile, u as BlockPackModel, v as ItemPackLayer } from "../pack-format-oRExIeD3.js";
+export { BlockPackAtlasFile, BlockPackAtlasPage, BlockPackBiomesFile, BlockPackBlockState, BlockPackBlockStatesFile, BlockPackElement, BlockPackFace, BlockPackItemsFile, BlockPackMetaFile, BlockPackModel, BlockPackModelsFile, BlockPackRenderLayer, BlockPackSprite, BlockPackSpriteFrame, BlockPackTintsFile, BlockPackVariant, ItemPackEntry, ItemPackLayer };

package/dist/blocks/sprite-sheet.d.ts

@@ -0,0 +1,59 @@
+import { i as TextureLoader, r as Texture } from "../loader-DUlx29PC.js";
+import { i as PackedPage } from "../atlas-pack-D8745_wo.js";
+import { f as BlockPackRenderLayer, p as BlockPackSprite } from "../pack-format-oRExIeD3.js";
+//#region src/blocks/sprite-sheet.d.ts
+/**
+ * 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.
+ */
+declare const MISSING_SPRITE = "minecraft:missingno";
+/** `MissingTextureAtlasSprite`: 16x16, black and magenta in 8px quarters. */
+declare function missingTexture(): Texture;
+/**
+ * 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.
+ */
+declare function inferRenderLayer(frames: Texture[]): BlockPackRenderLayer;
+interface SpriteSheetFailure {
+  id: string;
+  reason: string;
+}
+interface BuildSpriteSheetOptions {
+  /** Edge-extended border per sprite side (default 4). */
+  padding?: number;
+  /** Ceiling on a page's dimensions (default 4096). */
+  maxPageSize?: number;
+  /**
+   * Pack the black-and-magenta missing-texture sprite whether or not anything
+   * named it, and throw if it does not fit. What a consumer draws for something
+   * this pack does not describe at all; a guarantee worth its 256 pixels.
+   */
+  includeMissing?: boolean;
+  onProgress?: (done: number, total: number) => void;
+}
+interface SpriteSheet {
+  pages: PackedPage[];
+  /** Ready for `atlas.json`, unsorted — the caller decides the key order. */
+  sprites: Record<string, BlockPackSprite>;
+  /**
+   * Ids that never loaded or never fit a page, so have no rect. A caller must
+   * not emit anything naming one of these; the block path rewrites those
+   * references to `MISSING_SPRITE`, and the item path drops the item.
+   */
+  missing: Set<string>;
+  failures: SpriteSheetFailure[];
+  padding: number;
+}
+/**
+ * Loads every id, packs the frames, and returns the sheet plus everything that
+ * did not make it. Ids are packed in sorted order so an unchanged input produces
+ * a byte-identical atlas.
+ */
+declare function buildSpriteSheet(ids: Iterable<string>, textures: TextureLoader, options?: BuildSpriteSheetOptions): Promise<SpriteSheet>;
+//#endregion
+export { BuildSpriteSheetOptions, MISSING_SPRITE, SpriteSheet, SpriteSheetFailure, buildSpriteSheet, inferRenderLayer, missingTexture };

package/dist/blocks/sprite-sheet.js

@@ -0,0 +1,2 @@
+import { i as missingTexture, n as buildSpriteSheet, r as inferRenderLayer, t as MISSING_SPRITE } from "../sprite-sheet-LQAEtGkp.js";
+export { MISSING_SPRITE, buildSpriteSheet, inferRenderLayer, missingTexture };

package/dist/{cli-DqJtT-Ms.js → cli-DMTaIbDI.js}

@@ -1,7 +1,7 @@
 import { n as builtinPackPath } from "./builtin-WkWjATeh.js";
 import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
-import { t as exportBlockPack } from "./export-kMoMes_a.js";
-import { n as prepareModResources } from "./prepare-C9gjqQTt.js";
+import { t as exportBlockPack } from "./export-sadR0pWp.js";
+import { n as prepareModResources } from "./prepare-B_tRy9lB.js";
 import { t as downloadClientJar } from "./download-1wAfrGKx.js";
 import { a as prepareVersionResources, r as compareVersions } from "./prepare-8LswFoS-.js";
 import path from "node:path";
@@ -34,6 +34,7 @@ Options:
       --max-page-size <px> atlas page ceiling (default 4096)
       --builtin <dir>      override the vendored geometry pack
       --no-builtin         do not substitute geometry for code-drawn blocks
+      --no-items           do not export items.json (flat sprites for non-block items)
       --cache-dir <dir>    jar download cache (default ~/.rendermite)
 `;
 /**
@@ -93,6 +94,10 @@ async function runBlocksCli(argv) {
 				type: "boolean",
 				default: false
 			},
+			"no-items": {
+				type: "boolean",
+				default: false
+			},
 			"help": {
 				type: "boolean",
 				short: "h",
@@ -146,11 +151,13 @@ async function runBlocksCli(argv) {
 			namespaces,
 			padding: sizes.padding,
 			maxPageSize: sizes.maxPageSize,
+			items: !values["no-items"],
 			onProgress: (stage, done, total) => {
 				if (done === total || done % 250 === 0) console.log(`${stage}: ${done}/${total}`);
 			}
 		});
 		console.log(`\n${result.blocks} blocks, ${result.models} models, ${result.sprites} sprites across ${result.pages} atlas page(s); ${result.writtenFiles} files written.`);
+		console.log(result.items > 0 ? `${result.items} flat items described in items.json.` : "No flat item sprites exported.");
 		console.log(result.biomes > 0 ? `${result.biomes} biomes described in biomes.json.` : "No biomes to describe; biomes.json not written.");
 		console.log(`${result.failures.length} entries in failures.json.`);
 		return 0;

package/dist/cli.js

@@ -2,12 +2,12 @@
 import { n as builtinPackPath, t as bedCompatPath } from "./builtin-WkWjATeh.js";
 import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
 import { t as curatedModelOverrides } from "./models-CZjCOjs4.js";
-import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-C1tT6pKk.js";
+import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-BspVCz2G.js";
 import { t as JarResourceManager } from "./jar-W2cV2ZVO.js";
 import { t as downloadClientJar } from "./download-1wAfrGKx.js";
 import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS } from "./prepare-8LswFoS-.js";
-import { t as runBlocksCli } from "./cli-DqJtT-Ms.js";
-import { t as run } from "./run-B_JAUbXe.js";
+import { t as runBlocksCli } from "./cli-DMTaIbDI.js";
+import { t as run } from "./run-UKgVb-kW.js";
 import path from "node:path";
 import os from "node:os";
 import { parseArgs } from "node:util";

package/dist/{discovery-CsZu08re.js → discovery-CD0QqxSF.js}

@@ -99,4 +99,4 @@ async function resolveItem(resources, id, properties) {
 	throw new ItemResolutionError(`No item definition or item model for ${id}`);
 }
 //#endregion
-export { discoverItems as n, resolveItem as r, ItemResolutionError as t };
+export { resolveItem as i, discoverItems as n, langRegistry as r, ItemResolutionError as t };

package/dist/{discovery-C5ZR4aoG.d.ts → discovery-Cmir3QfC.d.ts}

@@ -17,6 +17,13 @@ interface ItemDiscoveryOptions {
   filterUntranslatedModels?: boolean;
 }
 declare function discoverItems(resources: ResourceManager, namespace: string, options?: ItemDiscoveryOptions): Promise<DiscoveredItem[]>;
+/**
+ * Item/block names with a translation key in the namespace's en_us.json — the
+ * closest thing to the game's item registry a jar contains (datagen writes a
+ * key per registered item). Null (no gating) when the namespace has no modern
+ * lang file or no item/block keys: 1.7.10-era mods use unkeyed .lang files.
+ */
+declare function langRegistry(resources: ResourceManager, namespace: string): Promise<Set<string> | null>;
 /**
  * Resolve an item id to the models to render. Definitions are evaluated with
  * static-icon properties; plain model items render the model with no tints
@@ -24,4 +31,4 @@ declare function discoverItems(resources: ResourceManager, namespace: string, op
  */
 declare function resolveItem(resources: ResourceManager, id: string, properties?: ItemProperties): Promise<ItemRenderInstruction[]>;
 //#endregion
-export { resolveItem as a, discoverItems as i, ItemDiscoveryOptions as n, ItemResolutionError as r, DiscoveredItem as t };
+export { langRegistry as a, discoverItems as i, ItemDiscoveryOptions as n, resolveItem as o, ItemResolutionError as r, DiscoveredItem as t };

package/dist/{entity-fallback-BTkM8j0V.js → entity-fallback-DutR9Hdz.js}

@@ -1,6 +1,6 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
 import { a as findChestTexture, i as findBedTexture, l as findMobTexture, n as HEAD_LAYOUTS, o as findEntityTexture, r as coversSheet, t as DYE_COLORS, u as tokens } from "./entity-textures-DFRIVdF1.js";
-import { c as renderModel } from "./obj-bvs3gwex.js";
+import { c as renderModel } from "./obj-BaGvPUbb.js";
 //#region src/render/entity-fallback.ts
 /**
 * Heuristic rendering for mod items that parent `builtin/entity` — chests,

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

@@ -1,10 +1,12 @@
-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 { 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-CazmV8ya.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 +39,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 +53,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 +67,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 +113,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 +216,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 +448,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 +573,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 +594,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 +605,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 +624,64 @@ 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)
+			};
+		}
+	}
 	await mkdir(output, { recursive: true });
 	const hashes = {};
 	let writtenFiles = 0;
@@ -774,7 +694,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 +708,18 @@ 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));
 	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 +738,9 @@ 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,
 		failures: failures.length
 	};
 	await emit("meta.json", JSON.stringify({

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

@@ -19,6 +19,12 @@ 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;
   onProgress?: (stage: string, done: number, total: number) => void;
 }
 interface BlockPackFailure {
@@ -27,7 +33,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' | 'intentional';
   reason: string;
 }
 interface BlockPackResult {
@@ -37,6 +43,8 @@ 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;
   /** Files actually written — the only trustworthy success signal. */
   writtenFiles: number;
   failures: BlockPackFailure[];

package/dist/{geo-BguldlU-.js → geo-BC8jtG5Q.js}

@@ -1,10 +1,10 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
-import { l as toFloatTexture } from "./blend-KXMclcHk.js";
 import { n as displayMatrix } from "./vector-CCxLae_T.js";
+import { l as toFloatTexture } from "./blend-KXMclcHk.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";
+import { n as faceMaxZ, r as renderFace, t as createShadeCache } from "./face-CMJ3b3Ae.js";
 //#region src/render/geo.ts
 /**
 * Bedrock-format geometry (`.geo.json`) rendering, best-effort. GeckoLib mods

package/dist/index.d.ts

@@ -6,7 +6,7 @@ import { a as PackedRect, i as PackedPage, n as PackOptions, o as packAtlas, r a
 import { a as buildBiomeClimates, i as VANILLA_BIOME_CLIMATES, n as BiomeClimatePack, o as parseBiomeClimate, r as DEFAULT_WATER_COLOR, t as BiomeClimate } from "./biomes-CJDJQqJb.js";
 import { a as resolveTexture, n as ModelResolutionError, o as salvageJson, r as ResolvedModel, t as ModelLoader } from "./loader-DSir1-P0.js";
 import { a as BlockStateMultipartCase, d as matchesCondition, f as parseBlockState, i as BlockStateError, l as collectModels, n as BlockProperties, o as BlockStateVariantCase, p as weightedVariantIndex, r as BlockStateDefinition, s as MultipartCondition, t as BlockModelVariant, u as evaluateBlockState } from "./blockstate-eval-BzznRcVY.js";
-import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "./export-Bllg8Fw7.js";
+import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "./export-wvt0Fryo.js";
 import { i as buildObjMesh, n as ObjMesh, r as ObjMeshError, t as MeshGroup } from "./obj-mesh-ydhVfLKs.js";
 import { a as buildBlockTints, i as UNREGISTERED_TINTS, n as BlockTintPack, t as BlockTint } from "./tints-DoBv5S9v.js";
 import { s as builtinDynamicResources } from "./generators-BnIzAftW.js";
@@ -14,7 +14,7 @@ import { d as toFloatTexture, n as FloatTexture, u as toByteTexture } from "./bl
 import { a as LightingProfileName, i as LightingProfile, r as LightSource, u as lightsForProfile } from "./lighting-3FGRC3Af.js";
 import { a as RenderedFrames, c as renderModel, i as RenderOptions, l as renderModelFrames, o as boxDownscale, r as ItemRenderError, s as pointResize } from "./renderer-C_DFi8DF.js";
 import { c as defaultProperties, i as ItemRenderInstruction, l as evaluateItemModel, n as InvalidItemDefinitionError, o as TintDefinition, r as ItemProperties, s as UNKNOWN_MODEL } from "./definition-ricL7Jqf.js";
-import { a as resolveItem, i as discoverItems, n as ItemDiscoveryOptions, r as ItemResolutionError, t as DiscoveredItem } from "./discovery-C5ZR4aoG.js";
+import { i as discoverItems, n as ItemDiscoveryOptions, o as resolveItem, r as ItemResolutionError, t as DiscoveredItem } from "./discovery-Cmir3QfC.js";
 import { a as resolveTint, i as parseTintValue, n as InvalidTinterDefinitionError, o as resolveTints, t as DYE_COLORS } from "./tints-6z6ysGUs.js";
 import { i as EncodedIcon, n as EncodeOptions, o as encodeAnimatedIcon, r as EncodedAnimatedIcon, s as encodeIcon, t as AnimatedEncodeOptions } from "./encode-Cf8hI5OY.js";
 import { t as minifyStylesheet } from "./minify-CIV6enbr.js";