@nodecraft/rendermite 1.6.0 → 1.6.1

package/dist/blocks/cli.js

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

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

@@ -1,2 +1,45 @@
-import { i as collectEntityGeometry, n as CollectEntityGeometryOptions, r as EntityGeometryResult, t as ClassSource } from "../entity-models-c2HpfdWV.js";
-export { ClassSource, CollectEntityGeometryOptions, EntityGeometryResult, collectEntityGeometry };
+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

@@ -1,2 +1,2 @@
-import { t as collectEntityGeometry } from "../entity-models-B6-0r2gR.js";
+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-D8fLC1wS.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-DT_drDoI.js";
+import { t as exportBlockPack } from "../export-BfEIwSxY.js";
 export { exportBlockPack };

package/dist/{classfile-BwaQjnUM.d.ts → classfile-BdLIk4Pe.d.ts}

@@ -22,6 +22,10 @@ interface Constant {
   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;
@@ -45,6 +49,18 @@ interface ClassFile {
   } | 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

package/dist/{classfile-CAhS5qNf.js → classfile-Bo7FUrrD.js}

@@ -150,7 +150,7 @@ function readConstantPool(reader) {
 				reader.skip(1);
 				constants.push({
 					tag,
-					nameAndTypeIndex: reader.u2()
+					referenceIndex: reader.u2()
 				});
 				break;
 			case "methodType":
@@ -160,23 +160,39 @@ function readConstantPool(reader) {
 				});
 				break;
 			case "dynamic":
-			case "invokeDynamic":
-				reader.skip(2);
-				constants.push({
-					tag,
-					nameAndTypeIndex: reader.u2()
-				});
+			case "invokeDynamic": constants.push({
+				tag,
+				bootstrapIndex: reader.u2(),
+				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) {
+/**
+* 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;
@@ -224,6 +240,8 @@ function parseClassFile(bytes) {
 			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;
@@ -241,6 +259,19 @@ function parseClassFile(bytes) {
 		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,
@@ -248,7 +279,8 @@ function parseClassFile(bytes) {
 		methods,
 		utf8,
 		reference,
-		literal
+		literal,
+		lambdaTarget
 	};
 }
 //#endregion

package/dist/{cli-BSKnXBPr.js → cli-D2KJc_yl.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-DT_drDoI.js";
-import { t as JarClassReader } from "./jar-classes-Bj15hjdr.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-D49Gu4Lv.js";
@@ -155,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({

package/dist/cli.js

@@ -6,7 +6,7 @@ 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-D49Gu4Lv.js";
-import { t as runBlocksCli } from "./cli-BSKnXBPr.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";

package/dist/entities/classfile.d.ts

@@ -1,2 +1,2 @@
-import { a as parseClassFile, i as MethodInfo, n as Constant, r as ConstantTag, t as ClassFile } from "../classfile-BwaQjnUM.js";
+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

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

package/dist/entities/inherit.d.ts

@@ -1,6 +1,6 @@
 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";
+import { t as ClassFile } from "../classfile-BdLIk4Pe.js";
+import { t as ModelCode } from "../model-code-BY44ao27.js";
 //#region src/entities/inherit.d.ts
 interface Ancestry {
   /** The class and its ancestors by internal name, parsed. */

package/dist/entities/inherit.js

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

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

@@ -1,26 +1,2 @@
-//#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 };
+import { n as JarClassReader, r as layeredClasses, t as ClassSource } from "../jar-classes-CSRrPAUy.js";
+export { ClassSource, JarClassReader, layeredClasses };

package/dist/entities/jar-classes.js

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

package/dist/entities/link.d.ts

@@ -1,4 +1,4 @@
-import { t as ClassFile } from "../classfile-BwaQjnUM.js";
+import { t as ClassFile } from "../classfile-BdLIk4Pe.js";
 import { t as Mappings } from "../mappings-DxX4KoZl.js";
 //#region src/entities/link.d.ts
 /**
@@ -38,7 +38,7 @@ interface EntityModelLink {
   /** The class to actually read the bytecode of. */
   obfuscated: string;
   /** How it was found, so a report can say how much rests on the curated table. */
-  route: 'model-name' | 'renderer' | 'alias' | 'mod-name';
+  route: 'model-name' | 'renderer' | 'alias' | 'mod-name' | 'vanilla-name';
 }
 /**
  * A class's simple name reduced to the entity it is about.

package/dist/entities/link.js

@@ -1,2 +1,2 @@
-import { a as linkEntityModel, i as classReader, n as RENDERER_ALIASES, o as normaliseModelName, r as buildModelNameIndex, t as NO_MODEL } from "../link-Bm5oQYh6.js";
+import { a as linkEntityModel, i as classReader, n as RENDERER_ALIASES, o as normaliseModelName, r as buildModelNameIndex, t as NO_MODEL } from "../link-5GmBLTzk.js";
 export { NO_MODEL, RENDERER_ALIASES, buildModelNameIndex, classReader, linkEntityModel, normaliseModelName };

package/dist/entities/merge.js

@@ -1,2 +1,2 @@
-import { a as slotsOf, i as mergeModels, n as countCubes, r as cubesOf, t as buildsOwnMesh } from "../merge-3HkeQ_6A.js";
+import { a as slotsOf, i as mergeModels, n as countCubes, r as cubesOf, t as buildsOwnMesh } from "../merge-NDYxpmL8.js";
 export { buildsOwnMesh, countCubes, cubesOf, mergeModels, slotsOf };

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

@@ -1,5 +1,5 @@
 import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
-import { t as ClassFile } from "../classfile-BwaQjnUM.js";
+import { t as ClassFile } from "../classfile-BdLIk4Pe.js";
 //#region src/entities/model-bytecode.d.ts
 /**
  * Extracts whatever geometry a class's methods build.

package/dist/entities/model-bytecode.js

@@ -1,2 +1,2 @@
-import { t as extractModel } from "../model-bytecode-C1nw2G8O.js";
+import { t as extractModel } from "../model-bytecode-gWy5_uCj.js";
 export { extractModel };

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

@@ -1,2 +1,2 @@
-import { n as isModelCode, r as loadModelCode, t as ModelCode } from "../model-code-B7jSFQqd.js";
+import { n as isModelCode, r as loadModelCode, t as ModelCode } from "../model-code-BY44ao27.js";
 export { ModelCode, isModelCode, loadModelCode };

package/dist/entities/model-code.js

@@ -1,2 +1,2 @@
-import { n as loadModelCode, t as isModelCode } from "../model-code-BKMEMXxF.js";
+import { n as loadModelCode, t as isModelCode } from "../model-code-1Vuk-zj_.js";
 export { isModelCode, loadModelCode };

package/dist/{entity-models-B6-0r2gR.js → entity-models-_EZ3PVtN.js}

@@ -1,8 +1,8 @@
 import { t as findGeoForEntity } from "./entity-geo-B2CkuMWx.js";
-import { n as extractInheritedModel } from "./inherit-KkDsM2N_.js";
-import { a as linkEntityModel, i as classReader, r as buildModelNameIndex } from "./link-Bm5oQYh6.js";
+import { n as extractInheritedModel } from "./inherit-ByHjOJX3.js";
+import { a as linkEntityModel, i as classReader, r as buildModelNameIndex } from "./link-5GmBLTzk.js";
 import { s as resolveMappings, t as MappingsUnavailableError } from "./mappings-BEPVaiwE.js";
-import { n as loadModelCode } from "./model-code-BKMEMXxF.js";
+import { n as loadModelCode } from "./model-code-1Vuk-zj_.js";
 //#region src/blocks/entity-models.ts
 /**
 * Entity geometry for the pack: link each entity to the class that builds it, read that class's
@@ -93,10 +93,14 @@ async function collectEntityGeometry(options) {
 	for (const entityId of [...entityIds].toSorted((left, right) => left.localeCompare(right))) {
 		options.onProgress?.(++done, entityIds.length);
 		const link = await linkEntityModel(entityId, context);
-		const found = link ? {
+		const guessed = link?.route === "vanilla-name";
+		const found = link && !guessed ? {
 			id: link.className,
 			model: await geometryOf(link.obfuscated)
-		} : await geoFor(entityId);
+		} : await geoFor(entityId) ?? (link ? {
+			id: link.className,
+			model: await geometryOf(link.obfuscated)
+		} : null);
 		if (!found?.model) continue;
 		const { id: modelId, model } = found;
 		if (!models[modelId]) models[modelId] = {

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

@@ -1,5 +1,5 @@
 import { a as ResourceManager } from "./manager-exOIcdyx.js";
-import { t as ClassSource } from "./entity-models-c2HpfdWV.js";
+import { t as ClassSource } from "./jar-classes-CSRrPAUy.js";
 //#region src/blocks/export.d.ts
 interface ExportBlockPackOptions {
   resources: ResourceManager;

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

@@ -3,7 +3,7 @@ import { n as ResourceLocator } from "./locator-COMEtEn9.js";
 import { n as blockEntityGeometry, r as synthesizeVariants, t as INVISIBLE_BLOCKS } from "./block-entities-xv3bQpEX.js";
 import { a as parseBlockState, n as collectModels } from "./blockstate-eval-BRQ3NWY2.js";
 import { t as collectEntities } from "./entities-DvmA9fEV.js";
-import { t as collectEntityGeometry } from "./entity-models-B6-0r2gR.js";
+import { t as collectEntityGeometry } from "./entity-models-_EZ3PVtN.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 { t as collectItemSprites } from "./item-sprites-G-yikdfV.js";

package/dist/index.d.ts

@@ -8,7 +8,7 @@ import { a as resolveTexture, n as ModelResolutionError, o as salvageJson, r as
 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 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 { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "./export-D8fLC1wS.js";
+import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "./export-B8tPsf4K.js";
 import { s as builtinDynamicResources } from "./generators-BnIzAftW.js";
 import { d as toFloatTexture, n as FloatTexture, u as toByteTexture } from "./blend-eT64Z6qm.js";
 import { a as LightingProfileName, i as LightingProfile, r as LightSource, u as lightsForProfile } from "./lighting-3FGRC3Af.js";

package/dist/index.js

@@ -14,7 +14,7 @@ import { n as buildBlockTints, t as UNREGISTERED_TINTS } from "./tints-Cl0r-Ol3.
 import { o as createAtlasResolver, s as parseAtlasSources, t as AtlasSourceError } from "./sources-BlUriDCs.js";
 import { n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "./manager-BNibYkmI.js";
 import { n as TextureLoader, r as TextureResolutionError, t as AnimatedTexture } from "./loader-C18GpurU.js";
-import { t as exportBlockPack } from "./export-DT_drDoI.js";
+import { t as exportBlockPack } from "./export-BfEIwSxY.js";
 import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "./jar-W2cV2ZVO.js";
 import { n as prepareModResources } from "./prepare-Myd_ec4v.js";
 import { a as prepareVersionResources, i as eraForVersion, r as compareVersions } from "./prepare-D49Gu4Lv.js";

package/dist/{inherit-KkDsM2N_.js → inherit-ByHjOJX3.js}

@@ -1,6 +1,6 @@
-import { t as parseClassFile } from "./classfile-CAhS5qNf.js";
-import { i as mergeModels } from "./merge-3HkeQ_6A.js";
-import { t as extractModel } from "./model-bytecode-C1nw2G8O.js";
+import { t as parseClassFile } from "./classfile-Bo7FUrrD.js";
+import { i as mergeModels } from "./merge-NDYxpmL8.js";
+import { t as extractModel } from "./model-bytecode-gWy5_uCj.js";
 //#region src/entities/inherit.ts
 /**
 * A model class read together with its ancestors.

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

@@ -0,0 +1,41 @@
+//#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.
+ */
+/** What the extractor reads code out of: one jar, or several layered into one view. */
+interface ClassSource {
+  list: () => Promise<string[]>;
+  read: (internalName: string) => Promise<Uint8Array | null>;
+  close: () => Promise<void>;
+}
+/**
+ * Several jars as one class view, first match winning — the same layering the resource managers use.
+ *
+ * A modded export needs this, and needed it before cross-jar linking did: the class source used to be
+ * the client jar alone, so a mod's own model classes were never read and its mobs came out as boxes
+ * however good the interpreter was. Layered, one view holds both, which is also what lets a mod entity
+ * link to a *vanilla* model — `ars_nouveau:summon_horse` is the game's own horse.
+ */
+declare function layeredClasses(sources: readonly ClassSource[]): ClassSource;
+/** 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 as n, layeredClasses as r, ClassSource as t };

package/dist/{jar-classes-Bj15hjdr.js → jar-classes-DCtELr1i.js}

@@ -13,6 +13,33 @@ import { n as UnsafeJarError, r as isUnsafeEntryPath } from "./jar-W2cV2ZVO.js";
 * entries on demand. A client jar holds around eight thousand classes and the extractor touches a
 * hundred of them.
 */
+/**
+* Several jars as one class view, first match winning — the same layering the resource managers use.
+*
+* A modded export needs this, and needed it before cross-jar linking did: the class source used to be
+* the client jar alone, so a mod's own model classes were never read and its mobs came out as boxes
+* however good the interpreter was. Layered, one view holds both, which is also what lets a mod entity
+* link to a *vanilla* model — `ars_nouveau:summon_horse` is the game's own horse.
+*/
+function layeredClasses(sources) {
+	return {
+		list: async () => {
+			const names = /* @__PURE__ */ new Set();
+			for (const source of sources) for (const name of await source.list()) names.add(name);
+			return [...names];
+		},
+		read: async (internalName) => {
+			for (const source of sources) {
+				const bytes = await source.read(internalName);
+				if (bytes) return bytes;
+			}
+			return null;
+		},
+		close: async () => {
+			for (const source of sources) await source.close();
+		}
+	};
+}
 /** Reads class files out of one jar, by internal name. */
 var JarClassReader = class {
 	jarPath;
@@ -72,4 +99,4 @@ var JarClassReader = class {
 	}
 };
 //#endregion
-export { JarClassReader as t };
+export { layeredClasses as n, JarClassReader as t };

package/dist/{link-Bm5oQYh6.js → link-5GmBLTzk.js}

@@ -1,4 +1,4 @@
-import { t as parseClassFile } from "./classfile-CAhS5qNf.js";
+import { t as parseClassFile } from "./classfile-Bo7FUrrD.js";
 //#region src/entities/link.ts
 /**
 * Which class holds a given entity's geometry.
@@ -257,6 +257,7 @@ function buildModelNameIndex(internalNames) {
 */
 async function linkEntityModel(entityId, context) {
 	const name = entityId.includes(":") ? entityId.slice(entityId.indexOf(":") + 1) : entityId;
+	const modded = entityId.includes(":") && !entityId.startsWith("minecraft:");
 	const { mappings } = context;
 	const accept = async (className, route) => {
 		const obfuscated = mappings.obfuscatedOf.get(className);
@@ -309,8 +310,31 @@ async function linkEntityModel(entityId, context) {
 			route: "mod-name"
 		};
 	}
+	if (modded) for (const shorter of withTokensDropped(name)) {
+		const found = await linkEntityModel(shorter, context);
+		if (found) return {
+			...found,
+			route: "vanilla-name"
+		};
+	}
 	return null;
 }
+/**
+* The name with some of its tokens dropped, longest first: `summon_horse` gives `summon` and `horse`.
+*
+* Capped at five tokens, because the subsets double with each one and no id is longer than that for a
+* reason this would help with.
+*/
+function withTokensDropped(name) {
+	const tokens = name.split("_").filter((token) => token.length > 0);
+	if (tokens.length < 2 || tokens.length > 5) return [];
+	const found = [];
+	for (let size = tokens.length - 1; size >= 1; size--) for (let mask = 0; mask < 2 ** tokens.length; mask++) {
+		const kept = tokens.filter((token, index) => (mask & 1 << index) !== 0);
+		if (kept.length === size) found.push(kept.join("_"));
+	}
+	return [...new Set(found)];
+}
 /** Reads and caches classes out of an extracted jar directory or a jar reader. */
 function classReader(load) {
 	const cache = /* @__PURE__ */ new Map();

package/dist/{merge-3HkeQ_6A.js → merge-NDYxpmL8.js}

@@ -27,13 +27,15 @@ function mergeModels(base, extra) {
 	const named = new Set(target.slots.map((part) => part.name));
 	const missing = source.slots.filter((part) => !named.has(part.name));
 	if (missing.length === 0) return base;
+	const parts = target.container ? [{
+		...target.container,
+		children: [...target.container.children, ...missing]
+	}] : [...target.slots, ...missing];
+	const notes = [.../* @__PURE__ */ new Set([...base.notes, ...extra.notes])].filter((note) => parts.length > 1 || !note.includes("disconnected roots"));
 	return {
 		textureSize: base.textureSize[0] === 64 && base.textureSize[1] === 32 ? extra.textureSize : base.textureSize,
-		parts: target.container ? [{
-			...target.container,
-			children: [...target.container.children, ...missing]
-		}] : [...target.slots, ...missing],
-		notes: [.../* @__PURE__ */ new Set([...base.notes, ...extra.notes])]
+		parts,
+		notes
 	};
 }
 function countCubes(part) {

package/dist/{model-bytecode-C1nw2G8O.js → model-bytecode-gWy5_uCj.js}

@@ -1,5 +1,5 @@
-import { t as parseClassFile } from "./classfile-CAhS5qNf.js";
-import { i as mergeModels, r as cubesOf, t as buildsOwnMesh } from "./merge-3HkeQ_6A.js";
+import { t as parseClassFile } from "./classfile-Bo7FUrrD.js";
+import { i as mergeModels, r as cubesOf, t as buildsOwnMesh } from "./merge-NDYxpmL8.js";
 //#region src/entities/model-bytecode.ts
 /**
 * Abstract interpretation of a boxy-model builder, enough to recover the geometry.
@@ -308,6 +308,12 @@ var Interpreter = class Interpreter {
 			});
 			return;
 		}
+		const lambda = taken.find((value) => value.kind === "lambda");
+		if (lambda?.kind === "lambda" && receiver?.kind === "object" && taken.length === 1) {
+			const applied = this.inline(lambda.owner, lambda.name, lambda.descriptor, null, [receiver]);
+			this.push(returns === "V" ? null : applied ?? receiver);
+			return;
+		}
 		if (args.length === 1 && args[0] === "Ljava/lang/String;" && returns.startsWith("L") && target) {
 			const name_ = taken[0].kind === "string" ? taken[0].value : "";
 			const found = target.children.find((child) => child.name === name_);
@@ -619,7 +625,11 @@ var Interpreter = class Interpreter {
 						returns: "V"
 					};
 					for (let count = 0; count < args.length; count++) this.pop();
-					this.push(returns === "V" ? null : { kind: "unknown" });
+					const target = constants.lambdaTarget(index);
+					this.push(returns === "V" ? null : target ? {
+						kind: "lambda",
+						...target
+					} : { kind: "unknown" });
 					break;
 				}
 				case op >= 153 && op <= 166: {

package/dist/{model-code-BKMEMXxF.js → model-code-1Vuk-zj_.js}

@@ -1,4 +1,4 @@
-import { t as parseClassFile } from "./classfile-CAhS5qNf.js";
+import { t as parseClassFile } from "./classfile-Bo7FUrrD.js";
 //#region src/entities/model-code.ts
 /**
 * Which classes in a jar count as model code, and their parsed form.

package/dist/{model-code-B7jSFQqd.d.ts → model-code-BY44ao27.d.ts}

@@ -1,4 +1,4 @@
-import { t as ClassFile } from "./classfile-BwaQjnUM.js";
+import { t as ClassFile } from "./classfile-BdLIk4Pe.js";
 //#region src/entities/model-code.d.ts
 interface ModelCode {
   /** The parsed class, when it is model code a call may be followed into. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nodecraft/rendermite",
-	"version": "1.6.0",
+	"version": "1.6.1",
 	"description": "Minecraft item icon renderer: renders inventory-identical item icons from vanilla and modded assets across game versions, outputting optimized PNG/WebP/AVIF plus CSS and a JSON item library.",
 	"type": "module",
 	"license": "MIT",

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

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