@nodecraft/rendermite 1.5.0 → 1.6.0

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-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-wvt0Fryo.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-sadR0pWp.js";
+import { t as exportBlockPack } from "../export-DT_drDoI.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-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-DMTaIbDI.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-sadR0pWp.js";
-import { n as prepareModResources } from "./prepare-B_tRy9lB.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";
@@ -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);
@@ -152,17 +166,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-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/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 };

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 };

package/dist/entities/inherit.d.ts

@@ -0,0 +1,29 @@
+import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
+import { t as ClassFile } from "../classfile-BwaQjnUM.js";
+import { t as ModelCode } from "../model-code-B7jSFQqd.js";
+//#region src/entities/inherit.d.ts
+interface Ancestry {
+  /** The class and its ancestors by internal name, parsed. */
+  ancestors: Map<string, ClassFile>;
+  /** The same classes, most derived first, with the bytes to interpret. */
+  chain: Array<{
+    internalName: string;
+    bytes: Uint8Array;
+  }>;
+}
+/** Reads a class and everything it inherits from that the jar still holds. */
+declare function ancestryOf(internalName: string, read: (internalName: string) => Promise<Uint8Array | null>): Promise<Ancestry>;
+/**
+ * Geometry for one class, with the code it builds on available and its ancestors' parts filled in.
+ *
+ * `code` widens what a call may be followed into beyond the ancestors, which some models need: the
+ * witch's body is the villager's, and a donkey's chest comes from the saddle model. Without it those
+ * models still come out, minus the piece the other class holds.
+ *
+ * Every ancestor is merged rather than only the first with boxes, because a deep hierarchy splits
+ * several ways: 1.16.5's sheep overrides a head in `SheepFurModel` and takes its legs from
+ * `QuadrupedModel` two hops up.
+ */
+declare function extractInheritedModel(internalName: string, read: (internalName: string) => Promise<Uint8Array | null>, code?: ModelCode): Promise<ExtractedModel | null>;
+//#endregion
+export { Ancestry, ancestryOf, extractInheritedModel };

package/dist/entities/inherit.js

@@ -0,0 +1,2 @@
+import { n as extractInheritedModel, t as ancestryOf } from "../inherit-KkDsM2N_.js";
+export { ancestryOf, extractInheritedModel };

package/dist/entities/jar-classes.d.ts

@@ -0,0 +1,26 @@
+//#region src/entities/jar-classes.d.ts
+/**
+ * Reading `.class` entries out of a jar.
+ *
+ * `JarResourceManager` deliberately indexes only `assets/` and `data/` — it is a *resource* manager,
+ * and a class file is not a resource. But entity geometry lives in the code (see
+ * `docs/entity-geometry.md`), so the extractor needs the other half of the archive, and it needs it
+ * by internal class name rather than by resource locator.
+ *
+ * Same shape as the resource manager for the same reason: index the central directory once, then read
+ * entries on demand. A client jar holds around eight thousand classes and the extractor touches a
+ * hundred of them.
+ */
+/** Reads class files out of one jar, by internal name. */
+declare class JarClassReader {
+  private readonly jarPath;
+  private index;
+  constructor(jarPath: string);
+  private getIndex;
+  /** Every class in the jar, for a sweep that does not know what it is looking for. */
+  list(): Promise<string[]>;
+  read(internalName: string): Promise<Uint8Array | null>;
+  close(): Promise<void>;
+}
+//#endregion
+export { JarClassReader };

package/dist/entities/jar-classes.js

@@ -0,0 +1,2 @@
+import { t as JarClassReader } from "../jar-classes-Bj15hjdr.js";
+export { JarClassReader };