@nodecraft/rendermite 1.5.0 → 1.6.1

package/README.md

@@ -76,6 +76,8 @@ blocks/1.21.8/
   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-DMTaIbDI.js";
+import { t as runBlocksCli } from "../cli-D2KJc_yl.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,45 @@
+import { a as ResourceManager } from "../manager-exOIcdyx.js";
+import { S as EntityPackModel } from "../pack-format-QcVFxG_b.js";
+import { t as ClassSource } from "../jar-classes-CSRrPAUy.js";
+//#region src/blocks/entity-models.d.ts
+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 { CollectEntityGeometryOptions, EntityGeometryResult, collectEntityGeometry };

package/dist/blocks/entity-models.js

@@ -0,0 +1,2 @@
+import { t as collectEntityGeometry } from "../entity-models-_EZ3PVtN.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-wvt0Fryo.js";
+import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "../export-B8tPsf4K.js";
 export { BlockPackFailure, BlockPackResult, ExportBlockPackOptions, exportBlockPack };

package/dist/blocks/export.js

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

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

@@ -1,7 +1,7 @@
 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";
+import { w as ItemPackEntry } from "../pack-format-QcVFxG_b.js";
 //#region src/blocks/item-sprites.d.ts
 interface ItemSpriteFailure {
   id: string;

package/dist/blocks/obj-mesh.js

@@ -1,2 +1,2 @@
-import { n as buildObjMesh, t as ObjMeshError } from "../obj-mesh-CazmV8ya.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 { _ 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 };
+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

@@ -1,6 +1,6 @@
 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";
+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

package/dist/classfile-BdLIk4Pe.d.ts

@@ -0,0 +1,67 @@
+//#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;
+  /** A `methodHandle`'s target: an index of a `methodref`, not of a `nameAndType`. */
+  referenceIndex?: number;
+  /** An `invokeDynamic`'s row in the `BootstrapMethods` attribute. */
+  bootstrapIndex?: 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;
+  /**
+   * The method a lambda actually runs, for an `invokedynamic`'s pool index.
+   *
+   * A lambda compiles to a call through `LambdaMetafactory` with the real body in a synthetic method,
+   * so this is two hops: the pool entry names a row of the `BootstrapMethods` attribute, and that
+   * row's second argument is a method handle pointing at the body.
+   */
+  lambdaTarget: (index: number) => {
+    owner: string;
+    name: string;
+    descriptor: string;
+  } | 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-Bo7FUrrD.js

@@ -0,0 +1,287 @@
+//#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,
+					referenceIndex: reader.u2()
+				});
+				break;
+			case "methodType":
+				constants.push({
+					tag,
+					descriptorIndex: reader.u2()
+				});
+				break;
+			case "dynamic":
+			case "invokeDynamic": constants.push({
+				tag,
+				bootstrapIndex: reader.u2(),
+				nameAndTypeIndex: reader.u2()
+			});
+		}
+	}
+	return constants;
+}
+/**
+* Skips an attribute table, keeping the two that say what a method does: `Code`, and the class-level
+* `BootstrapMethods` that a lambda's real body is reachable through.
+*/
+function readAttributes(reader, utf8, bootstraps) {
+	let code;
+	const count = reader.u2();
+	for (let index = 0; index < count; index++) {
+		const name = utf8(reader.u2());
+		const length = reader.u4();
+		if (name === "BootstrapMethods" && bootstraps) {
+			const rows = reader.u2();
+			for (let row = 0; row < rows; row++) {
+				const handleIndex = reader.u2();
+				const argumentCount = reader.u2();
+				const argumentIndexes = [];
+				for (let argument = 0; argument < argumentCount; argument++) argumentIndexes.push(reader.u2());
+				bootstraps.push({
+					handleIndex,
+					argumentIndexes
+				});
+			}
+			continue;
+		}
+		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 bootstraps = [];
+	readAttributes(reader, utf8, bootstraps);
+	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;
+	};
+	const lambdaTarget = (index) => {
+		const entry = constants[index];
+		const row = entry?.bootstrapIndex === void 0 ? void 0 : bootstraps[entry.bootstrapIndex];
+		if (!row) return null;
+		for (const argument of row.argumentIndexes) {
+			const handle = constants[argument];
+			if (handle?.tag === "methodHandle" && handle.referenceIndex !== void 0) {
+				const target = reference(handle.referenceIndex);
+				if (target) return target;
+			}
+		}
+		return null;
+	};
+	return {
+		thisClass,
+		superClass,
+		constants,
+		methods,
+		utf8,
+		reference,
+		literal,
+		lambdaTarget
+	};
+}
+//#endregion
+export { parseClassFile as t };

package/dist/{cli-DMTaIbDI.js → cli-D2KJc_yl.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-sadR0pWp.js";
-import { n as prepareModResources } from "./prepare-B_tRy9lB.js";
+import { t as exportBlockPack } from "./export-BfEIwSxY.js";
+import { n as layeredClasses, t as JarClassReader } from "./jar-classes-DCtELr1i.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";
@@ -35,6 +36,8 @@ Options:
       --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)
 `;
 /**
@@ -98,6 +101,14 @@ async function runBlocksCli(argv) {
 				type: "boolean",
 				default: false
 			},
+			"no-entities": {
+				type: "boolean",
+				default: false
+			},
+			"no-entity-geometry": {
+				type: "boolean",
+				default: false
+			},
 			"help": {
 				type: "boolean",
 				short: "h",
@@ -120,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);
@@ -141,6 +155,10 @@ async function runBlocksCli(argv) {
 		closeMods = () => prepared.close();
 		for (const { jar, reason } of prepared.rejected) console.error(`Rejected mod jar ${jar}: ${reason}`);
 		namespaces = values.namespace?.length ? values.namespace : prepared.namespaces;
+		if (!values["no-entity-geometry"]) {
+			const modClasses = values.mod.map((jar) => new JarClassReader(jar));
+			classes = layeredClasses(classes ? [classes, ...modClasses] : modClasses);
+		}
 	}
 	try {
 		const result = await exportBlockPack({
@@ -152,17 +170,23 @@ async function runBlocksCli(argv) {
 			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 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 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-DMTaIbDI.js";
-import { t as run } from "./run-UKgVb-kW.js";
+import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS } from "./prepare-D49Gu4Lv.js";
+import { t as runBlocksCli } from "./cli-D2KJc_yl.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/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-BdLIk4Pe.js";
+export { ClassFile, Constant, ConstantTag, MethodInfo, parseClassFile };

package/dist/entities/classfile.js

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

package/dist/entities/geo-model.d.ts

@@ -0,0 +1,13 @@
+import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
+import { t as ParsedGeo } from "../geo-CmjrXu0G.js";
+//#region src/entities/geo-model.d.ts
+/**
+ * Converts one parsed `.geo.json` into a model.
+ *
+ * Bones are a flat list joined by `parent` name, so the tree is rebuilt here. A bone whose parent is
+ * missing becomes a root rather than being dropped, and a cube carrying its own rotation becomes a part
+ * of its own: `Cube` has nowhere to put a rotation, and 18% of the corpus's cubes have one.
+ */
+declare function geoToModel(geo: ParsedGeo): ExtractedModel;
+//#endregion
+export { geoToModel };

package/dist/entities/geo-model.js

@@ -0,0 +1,2 @@
+import { t as geoToModel } from "../geo-model-Bo1gpEwX.js";
+export { geoToModel };