@nodecraft/rendermite 1.4.1 → 1.6.0

package/README.md

@@ -75,6 +75,9 @@ 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
+  entities.json        # entity names, marker colours, and which model each uses
+  entity-models.json   # entity geometry recovered from the client's own bytecode + its atlas
   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-BSKnXBPr.js";
 export { runBlocksCli };

package/dist/blocks/entities.d.ts

@@ -0,0 +1,30 @@
+import { a as ResourceManager } from "../manager-exOIcdyx.js";
+import { i as TextureLoader } from "../loader-DUlx29PC.js";
+import { x as EntityPackEntry } from "../pack-format-QcVFxG_b.js";
+//#region src/blocks/entities.d.ts
+interface EntityPackResult {
+  entities: Record<string, EntityPackEntry>;
+  failures: Array<{
+    id: string;
+    reason: string;
+  }>;
+}
+/**
+ * Every entity type a namespace registers, by its lang keys.
+ *
+ * Keys with more segments than `<prefix>.<ns>.<name>` are dropped: those are a variant's own label
+ * (`entity.minecraft.villager.farmer`) or a death message, never a type.
+ */
+declare function entityTypesOf(resources: ResourceManager, namespace: string): Promise<Array<{
+  id: string;
+  name: string;
+}>>;
+interface CollectEntitiesOptions {
+  resources: ResourceManager;
+  textures: TextureLoader;
+  namespaces: readonly string[];
+  onProgress?: (done: number, total: number) => void;
+}
+declare function collectEntities(options: CollectEntitiesOptions): Promise<EntityPackResult>;
+//#endregion
+export { CollectEntitiesOptions, EntityPackResult, collectEntities, entityTypesOf };

package/dist/blocks/entities.js

@@ -0,0 +1,2 @@
+import { n as entityTypesOf, t as collectEntities } from "../entities-DvmA9fEV.js";
+export { collectEntities, entityTypesOf };

package/dist/blocks/entity-geo.d.ts

@@ -0,0 +1,18 @@
+import { a as ResourceManager } from "../manager-exOIcdyx.js";
+import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
+//#region src/blocks/entity-geo.d.ts
+interface GeoEntityModel {
+  /** Model id: the resource that produced it, which is also what makes it unique in the pack. */
+  id: string;
+  model: ExtractedModel;
+}
+/**
+ * The geometry for one entity, or null when the mod does not ship any under that name.
+ *
+ * `namespace` and `name` come from the entity id, so `occultism:afrit` looks for
+ * `assets/occultism/geo/entity/afrit.geo.json` and its neighbours. Nothing is inferred from the
+ * *class* here: a GeckoLib mob has no model class to inspect.
+ */
+declare function findGeoForEntity(resources: ResourceManager, namespace: string, name: string): Promise<GeoEntityModel | null>;
+//#endregion
+export { GeoEntityModel, findGeoForEntity };

package/dist/blocks/entity-geo.js

@@ -0,0 +1,2 @@
+import { t as findGeoForEntity } from "../entity-geo-B2CkuMWx.js";
+export { findGeoForEntity };

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

@@ -0,0 +1,2 @@
+import { i as collectEntityGeometry, n as CollectEntityGeometryOptions, r as EntityGeometryResult, t as ClassSource } from "../entity-models-c2HpfdWV.js";
+export { ClassSource, CollectEntityGeometryOptions, EntityGeometryResult, collectEntityGeometry };

package/dist/blocks/entity-models.js

@@ -0,0 +1,2 @@
+import { t as collectEntityGeometry } from "../entity-models-B6-0r2gR.js";
+export { collectEntityGeometry };

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-D8fLC1wS.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-DT_drDoI.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 { w as ItemPackEntry } from "../pack-format-QcVFxG_b.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-JwPkZEWL.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 { C as EntityPackPart, S as EntityPackModel, T as ItemPackLayer, _ as BlockPackTintsFile, a as BlockPackBlockStatesFile, b as EntityPackCubeFace, c as BlockPackEntityModelsFile, d as BlockPackMetaFile, f as BlockPackModel, g as BlockPackSpriteFrame, h as BlockPackSprite, i as BlockPackBlockState, l as BlockPackFace, m as BlockPackRenderLayer, n as BlockPackAtlasPage, o as BlockPackElement, p as BlockPackModelsFile, r as BlockPackBiomesFile, s as BlockPackEntitiesFile, t as BlockPackAtlasFile, u as BlockPackItemsFile, v as BlockPackVariant, w as ItemPackEntry, x as EntityPackEntry, y as EntityPackCube } from "../pack-format-QcVFxG_b.js";
+export { BlockPackAtlasFile, BlockPackAtlasPage, BlockPackBiomesFile, BlockPackBlockState, BlockPackBlockStatesFile, BlockPackElement, BlockPackEntitiesFile, BlockPackEntityModelsFile, BlockPackFace, BlockPackItemsFile, BlockPackMetaFile, BlockPackModel, BlockPackModelsFile, BlockPackRenderLayer, BlockPackSprite, BlockPackSpriteFrame, BlockPackTintsFile, BlockPackVariant, EntityPackCube, EntityPackCubeFace, EntityPackEntry, EntityPackModel, EntityPackPart, 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 { h as BlockPackSprite, m as BlockPackRenderLayer } from "../pack-format-QcVFxG_b.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/classfile-BwaQjnUM.d.ts

@@ -0,0 +1,51 @@
+//#region src/entities/classfile.d.ts
+/**
+ * A minimal JVM class-file reader: constant pool, methods, and each method's `Code`.
+ *
+ * Written rather than taken from npm because the whole of what is needed is the constant pool and one
+ * attribute — every published class-file library is an order of magnitude more than that, and this
+ * runs in a package whose entire dependency list is three entries.
+ *
+ * It exists because entity models are Java code at every version (see docs/entity-geometry.md), so
+ * the only automatic way to recover their geometry is to read the code.
+ *
+ * Spec: https://docs.oracle.com/javase/specs/jvms/se21/html/jvms-4.html
+ */
+type ConstantTag = 'utf8' | 'integer' | 'float' | 'long' | 'double' | 'class' | 'string' | 'fieldref' | 'methodref' | 'interfaceMethodref' | 'nameAndType' | 'methodHandle' | 'methodType' | 'dynamic' | 'invokeDynamic' | 'module' | 'package';
+interface Constant {
+  tag: ConstantTag;
+  /** Utf8 text, or the numeric value of an integer/float/long/double. */
+  value?: string | number | bigint;
+  /** Indexes into the pool, by whatever the tag needs. */
+  nameIndex?: number;
+  classIndex?: number;
+  nameAndTypeIndex?: number;
+  descriptorIndex?: number;
+  stringIndex?: number;
+}
+interface MethodInfo {
+  name: string;
+  descriptor: string;
+  accessFlags: number;
+  /** Raw bytecode of the `Code` attribute, absent on an abstract or native method. */
+  code?: Uint8Array;
+}
+interface ClassFile {
+  thisClass: string;
+  superClass: string | null;
+  constants: Array<Constant | null>;
+  methods: MethodInfo[];
+  /** A pool entry as text, for a `utf8` or anything that resolves to one. */
+  utf8: (index: number) => string;
+  /** `owner.name:descriptor` for a field or method reference. */
+  reference: (index: number) => {
+    owner: string;
+    name: string;
+    descriptor: string;
+  } | null;
+  /** The value an `ldc` of this index pushes: a number for numeric constants, a string for `string`. */
+  literal: (index: number) => string | number | bigint | null;
+}
+declare function parseClassFile(bytes: Uint8Array): ClassFile;
+//#endregion
+export { parseClassFile as a, MethodInfo as i, Constant as n, ConstantTag as r, ClassFile as t };

package/dist/classfile-CAhS5qNf.js

@@ -0,0 +1,255 @@
+//#region src/entities/classfile.ts
+var Reader = class {
+	at = 0;
+	bytes;
+	view;
+	constructor(bytes) {
+		this.bytes = bytes;
+		this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	}
+	u1() {
+		return this.view.getUint8(this.at++);
+	}
+	u2() {
+		const value = this.view.getUint16(this.at);
+		this.at += 2;
+		return value;
+	}
+	u4() {
+		const value = this.view.getUint32(this.at);
+		this.at += 4;
+		return value;
+	}
+	i4() {
+		const value = this.view.getInt32(this.at);
+		this.at += 4;
+		return value;
+	}
+	f4() {
+		const value = this.view.getFloat32(this.at);
+		this.at += 4;
+		return value;
+	}
+	f8() {
+		const value = this.view.getFloat64(this.at);
+		this.at += 8;
+		return value;
+	}
+	i8() {
+		const value = this.view.getBigInt64(this.at);
+		this.at += 8;
+		return value;
+	}
+	utf8(length) {
+		const text = new TextDecoder("utf-8").decode(this.bytes.subarray(this.at, this.at + length));
+		this.at += length;
+		return text;
+	}
+	skip(count) {
+		this.at += count;
+	}
+	take(count) {
+		const slice = this.bytes.subarray(this.at, this.at + count);
+		this.at += count;
+		return slice;
+	}
+};
+/** Pool tags, by their spec number. `null` marks the two that take two slots. */
+const TAGS = {
+	1: "utf8",
+	3: "integer",
+	4: "float",
+	5: "long",
+	6: "double",
+	7: "class",
+	8: "string",
+	9: "fieldref",
+	10: "methodref",
+	11: "interfaceMethodref",
+	12: "nameAndType",
+	15: "methodHandle",
+	16: "methodType",
+	17: "dynamic",
+	18: "invokeDynamic",
+	19: "module",
+	20: "package"
+};
+function readConstantPool(reader) {
+	const count = reader.u2();
+	const constants = [null];
+	for (let index = 1; index < count; index++) {
+		const raw = reader.u1();
+		const tag = TAGS[raw];
+		if (!tag) throw new Error(`Unknown constant pool tag ${raw} at ${index}`);
+		switch (tag) {
+			case "utf8":
+				constants.push({
+					tag,
+					value: reader.utf8(reader.u2())
+				});
+				break;
+			case "integer":
+				constants.push({
+					tag,
+					value: reader.i4()
+				});
+				break;
+			case "float":
+				constants.push({
+					tag,
+					value: reader.f4()
+				});
+				break;
+			case "long":
+				constants.push({
+					tag,
+					value: reader.i8()
+				});
+				constants.push(null);
+				index++;
+				break;
+			case "double":
+				constants.push({
+					tag,
+					value: reader.f8()
+				});
+				constants.push(null);
+				index++;
+				break;
+			case "class":
+			case "module":
+			case "package":
+				constants.push({
+					tag,
+					nameIndex: reader.u2()
+				});
+				break;
+			case "string":
+				constants.push({
+					tag,
+					stringIndex: reader.u2()
+				});
+				break;
+			case "fieldref":
+			case "methodref":
+			case "interfaceMethodref":
+				constants.push({
+					tag,
+					classIndex: reader.u2(),
+					nameAndTypeIndex: reader.u2()
+				});
+				break;
+			case "nameAndType":
+				constants.push({
+					tag,
+					nameIndex: reader.u2(),
+					descriptorIndex: reader.u2()
+				});
+				break;
+			case "methodHandle":
+				reader.skip(1);
+				constants.push({
+					tag,
+					nameAndTypeIndex: reader.u2()
+				});
+				break;
+			case "methodType":
+				constants.push({
+					tag,
+					descriptorIndex: reader.u2()
+				});
+				break;
+			case "dynamic":
+			case "invokeDynamic":
+				reader.skip(2);
+				constants.push({
+					tag,
+					nameAndTypeIndex: reader.u2()
+				});
+		}
+	}
+	return constants;
+}
+/** Skips an attribute table, returning the `Code` bytes if one of them is a Code attribute. */
+function readAttributes(reader, utf8) {
+	let code;
+	const count = reader.u2();
+	for (let index = 0; index < count; index++) {
+		const name = utf8(reader.u2());
+		const length = reader.u4();
+		if (name !== "Code") {
+			reader.skip(length);
+			continue;
+		}
+		reader.skip(4);
+		code = reader.take(reader.u4());
+		reader.skip(reader.u2() * 8);
+		readAttributes(reader, utf8);
+	}
+	return code;
+}
+function parseClassFile(bytes) {
+	const reader = new Reader(bytes);
+	if (reader.u4() !== 3405691582) throw new Error("Not a class file: bad magic");
+	reader.skip(4);
+	const constants = readConstantPool(reader);
+	const utf8 = (index) => {
+		const entry = constants[index];
+		if (!entry) return "";
+		if (entry.tag === "utf8") return String(entry.value);
+		const next = entry.nameIndex ?? entry.stringIndex ?? entry.descriptorIndex;
+		return next === void 0 ? "" : utf8(next);
+	};
+	reader.skip(2);
+	const thisClass = utf8(reader.u2());
+	const superIndex = reader.u2();
+	const superClass = superIndex === 0 ? null : utf8(superIndex);
+	reader.skip(reader.u2() * 2);
+	const fieldCount = reader.u2();
+	for (let index = 0; index < fieldCount; index++) {
+		reader.skip(6);
+		readAttributes(reader, utf8);
+	}
+	const methods = [];
+	const methodCount = reader.u2();
+	for (let index = 0; index < methodCount; index++) {
+		const accessFlags = reader.u2();
+		const name = utf8(reader.u2());
+		const descriptor = utf8(reader.u2());
+		const code = readAttributes(reader, utf8);
+		methods.push({
+			name,
+			descriptor,
+			accessFlags,
+			code
+		});
+	}
+	const reference = (index) => {
+		const entry = constants[index];
+		if (!entry || entry.classIndex === void 0 || entry.nameAndTypeIndex === void 0) return null;
+		const nameAndType = constants[entry.nameAndTypeIndex];
+		if (!nameAndType?.nameIndex || !nameAndType.descriptorIndex) return null;
+		return {
+			owner: utf8(entry.classIndex),
+			name: utf8(nameAndType.nameIndex),
+			descriptor: utf8(nameAndType.descriptorIndex)
+		};
+	};
+	const literal = (index) => {
+		const entry = constants[index];
+		if (!entry) return null;
+		if (entry.tag === "string") return utf8(index);
+		return entry.value ?? null;
+	};
+	return {
+		thisClass,
+		superClass,
+		constants,
+		methods,
+		utf8,
+		reference,
+		literal
+	};
+}
+//#endregion
+export { parseClassFile as t };

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

@@ -1,9 +1,10 @@
 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-DT_drDoI.js";
+import { t as JarClassReader } from "./jar-classes-Bj15hjdr.js";
+import { n as prepareModResources } from "./prepare-Myd_ec4v.js";
 import { t as downloadClientJar } from "./download-1wAfrGKx.js";
-import { a as prepareVersionResources, r as compareVersions } from "./prepare-8LswFoS-.js";
+import { a as prepareVersionResources, r as compareVersions } from "./prepare-D49Gu4Lv.js";
 import path from "node:path";
 import os from "node:os";
 import { parseArgs } from "node:util";
@@ -34,6 +35,9 @@ 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)
+      --no-entities        do not export entities.json (entity names and marker colours)
+      --no-entity-geometry do not read the jar's code for entity model geometry
       --cache-dir <dir>    jar download cache (default ~/.rendermite)
 `;
 /**
@@ -93,6 +97,18 @@ async function runBlocksCli(argv) {
 				type: "boolean",
 				default: false
 			},
+			"no-items": {
+				type: "boolean",
+				default: false
+			},
+			"no-entities": {
+				type: "boolean",
+				default: false
+			},
+			"no-entity-geometry": {
+				type: "boolean",
+				default: false
+			},
 			"help": {
 				type: "boolean",
 				short: "h",
@@ -115,12 +131,15 @@ async function runBlocksCli(argv) {
 	}
 	const cacheDir = values["cache-dir"] ?? path.join(os.homedir(), ".rendermite");
 	let resources;
+	let classes = null;
 	if (values.version) {
 		console.log(`Fetching client jar for ${values.version}…`);
+		const jar = await downloadClientJar(values.version, cacheDir);
 		resources = await prepareVersionResources({
 			version: values.version,
-			jar: await downloadClientJar(values.version, cacheDir)
+			jar
 		});
+		if (!values["no-entity-geometry"]) classes = new JarClassReader(jar);
 	} else {
 		const managers = (values.assets ?? []).map((root) => new FolderResourceManager(root));
 		resources = managers.length === 1 ? managers[0] : new LayeredResourceManager(managers);
@@ -146,16 +165,24 @@ async function runBlocksCli(argv) {
 			namespaces,
 			padding: sizes.padding,
 			maxPageSize: sizes.maxPageSize,
+			items: !values["no-items"],
+			entities: !values["no-entities"],
+			classes: classes ?? void 0,
+			cacheDir,
 			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.entities > 0 ? `${result.entities} entity types described in entities.json.` : "No entity types exported.");
+		console.log(result.entityModels > 0 ? `${result.entityModels} entity models recovered from the jar's own code.` : "No entity geometry recovered.");
 		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;
 	} finally {
 		await closeMods?.();
+		await classes?.close();
 	}
 }
 //#endregion

package/dist/cli.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 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 { t as JarResourceManager } from "./jar-W2cV2ZVO.js";
+import { t as curatedModelOverrides } from "./models-CZjCOjs4.js";
+import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-BspVCz2G.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 { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS } from "./prepare-D49Gu4Lv.js";
+import { t as runBlocksCli } from "./cli-BSKnXBPr.js";
+import { t as run } from "./run-BQJkqc5f.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/entities/classfile.d.ts

@@ -0,0 +1,2 @@
+import { a as parseClassFile, i as MethodInfo, n as Constant, r as ConstantTag, t as ClassFile } from "../classfile-BwaQjnUM.js";
+export { ClassFile, Constant, ConstantTag, MethodInfo, parseClassFile };

package/dist/entities/classfile.js

@@ -0,0 +1,2 @@
+import { t as parseClassFile } from "../classfile-CAhS5qNf.js";
+export { parseClassFile };