@nodecraft/rendermite 1.9.0 → 1.10.1

package/README.md

@@ -84,6 +84,7 @@ blocks/1.21.8/
   tags.json            # the version's own tags, every registry, unexpanded
   advancements.json    # each advancement's criteria
   game-rules.json      # every game rule with its type and default
+  names.json           # block and item display names from the lang files
   states.json          # every property and default state (with --reports <data generator reports>)
   failures.json        # anything not fully handled, with reasons, never silent
   meta.json            # version, counts, sha256 of every other file

package/dist/{block-behaviour-9Tj_GIUC.d.ts → block-behaviour-CzK3KVLx.d.ts}

@@ -2,11 +2,12 @@ import { n as BiomeClimatePack } from "./biomes-CnnhDCnk.js";
 import { a as BlockStateMultipartCase, o as BlockStateVariantCase } from "./blockstate-eval-BzznRcVY.js";
 import { r as TagPack, t as AdvancementPack } from "./datapack-CmEg0Vko.js";
 import { n as GameRulePack } from "./game-rules-ThvdDG3B.js";
+import { t as NamePack } from "./names-D1abAVIB.js";
 import { a as FaceDirectionName, l as Vec3, o as ModelElementJson, u as Vec4 } from "./types-qlp3I8_-.js";
 import { t as MeshGroup } from "./obj-mesh-CzL0lOlJ.js";
 import { n as BlockStatesPack } from "./states-OzneeCTU.js";
 import { n as BlockTintPack } from "./tints-DwFmEkf3.js";
-import { t as ClassFile } from "./classfile-CsLXlh5z.js";
+import { t as ClassFile } from "./classfile-Dzn0gW9M.js";
 //#region src/blocks/pack-format.d.ts
 /** How a sprite's alpha classifies it, inferred because assets rarely say. */
 type BlockPackRenderLayer = 'solid' | 'cutout' | 'translucent';
@@ -167,6 +168,8 @@ type BlockPackStatesFile = BlockStatesPack;
  * (camelCase before 26.x, snake_case from it), with its type and default. Vanilla packs only.
  */
 type BlockPackGameRulesFile = GameRulePack;
+/** `names.json`: English display names by id, for blocks and items, from each namespace's `en_us`. */
+type BlockPackNamesFile = NamePack;
 /** One flat sprite of an item's layer stack, in the order the client draws them. */
 interface ItemPackLayer {
   sprite: string;
@@ -347,6 +350,8 @@ interface EquipmentPack {
   }>;
   /** Materials whose sheet is greyscale and takes the item's own dye colour. */
   dyeable: string[];
+  /** The colour a dyeable material takes when nothing dyed it, read from the game's own constant. */
+  undyed?: Record<string, string>;
   /** Worn armour-trim sheets generated from the version's armour-trim atlas. */
   trims: {
     /** Sprite ids per pattern and material, into this file's own `sprites`. */
@@ -385,6 +390,8 @@ interface BlockPackMetaFile {
     states: number;
     /** Rules in `game-rules.json`; `0` means the file is absent. */
     gameRules: number;
+    /** Block and item names in `names.json`; `0` means the file is absent. */
+    names: number;
     failures: number;
   };
   /** sha256 per file, enough to verify a cached copy without refetching it. */
@@ -413,6 +420,8 @@ interface LightCodeSource {
    * Absent, or answering the name it was given, where the jar already speaks original names.
    */
   nameOf?: (reference: MemberReference, field: boolean) => string;
+  /** A block's default state by full id, from the data generator's report when the export has one. */
+  defaultStateOf?: (blockId: string) => Readonly<Record<string, string>> | null;
   /** Classes that are a block `Properties` builder, in every spelling the jars use. */
   propsClasses: ReadonlySet<string>;
   /**
@@ -575,6 +584,12 @@ interface LightExtraction {
   } | {
     failure: string;
   };
+  /** The same, for a method a block's class declares, run on the block its registration made. */
+  tabulateMethod: (registration: Registration, method: MemberReference, read: (value: Value) => number | null) => {
+    value: BlockPackLight;
+  } | {
+    failure: string;
+  };
   /** What was recorded for a block, for a person chasing a failure. */
   describe: (blockId: string) => string;
 }
@@ -618,15 +633,43 @@ interface BlockBehaviour {
   friction?: number;
   speedFactor?: number;
   jumpFactor?: number;
+  /**
+   * The block's shape decides how light crosses its faces (`useShapeForLightOcclusion`): stairs,
+   * slabs, snow layers. `true` in every state, or cases of 1 where a state does (a double slab does not).
+   */
+  lightShape?: true | Exclude<BlockPackLight, number>;
+  /**
+   * Light lost passing through the block, where its class answers for itself (`getLightBlock`): 15
+   * for tinted glass, whose faces are see-through. Absent means the game's default rule.
+   */
+  lightBlock?: BlockPackLight;
+  /** The fluid the block holds in every state, as kelp and seagrass are always under water. */
+  fluid?: 'water' | 'lava';
+  /**
+   * The block model renderer draws nothing for it (`RenderShape.INVISIBLE`): a barrier, a light block, a
+   * structure void, and the blocks something else draws, a fluid or an end portal.
+   */
+  invisible?: true;
+  /**
+   * Its class decides whether a face against a neighbour draws (`skipRendering`): glass hides the faces
+   * it shares with glass, although its texture reads as plain cutout.
+   */
+  hidesSharedFaces?: true;
 }
 /**
  * The colour a block's `Properties` state: a `mapColor` call, the colour a pre-1.20 `Properties` was
  * constructed with, or its `Material`'s, latest first. A constant or a function of state.
  */
 declare function statedMapColor(props: Handle): Value | undefined;
-declare function blockBehaviour(registration: Registration, extraction: Pick<LightExtraction, 'tabulate'>): {
+declare function blockBehaviour(registration: Registration, extraction: Pick<LightExtraction, 'tabulate' | 'tabulateMethod'>,
+/** The block's class's overrides, if it can be read: see `block-overrides.ts`. */
+overrides?: {
+  of: (names: readonly string[]) => MemberReference | null;
+  fluid: (method: MemberReference) => 'water' | 'lava' | null;
+  invisible: (method: MemberReference) => boolean;
+} | null): {
   behaviour: BlockBehaviour;
   failures: string[];
 } | null;
 //#endregion
-export { BlockPackItemsFile as A, BlockPackTagsFile as B, BlockPackBlockState as C, BlockPackEntityModelsFile as D, BlockPackEntitiesFile as E, BlockPackModelsFile as F, EntityPackCubeFace as G, BlockPackVariant as H, BlockPackRenderLayer as I, EntityPackPart as J, EntityPackEntry as K, BlockPackSprite as L, BlockPackLightFile as M, BlockPackMetaFile as N, BlockPackFace as O, BlockPackModel as P, ItemPackLayer as Q, BlockPackSpriteFrame as R, BlockPackBiomesFile as S, BlockPackElement as T, EQUIPMENT_SLOTS as U, BlockPackTintsFile as V, EntityPackCube as W, EquipmentSlot as X, EquipmentPack as Y, ItemPackEntry as Z, extractBlockLight as _, Handle as a, BlockPackAtlasPage as b, LightExtraction as c, MemberReference as d, PropertyDomain as f, Value as g, StateProbe as h, statedMapColor as i, BlockPackLight as j, BlockPackGameRulesFile as k, LightGetter as l, Registration as m, PushReactionName as n, LambdaValue as o, PropsCall as p, EntityPackModel as q, blockBehaviour as r, LightCodeSource as s, BlockBehaviour as t, LightSpec as u, BlockPackAdvancementsFile as v, BlockPackBlockStatesFile as w, BlockPackBehaviourFile as x, BlockPackAtlasFile as y, BlockPackStatesFile as z };
+export { ItemPackLayer as $, BlockPackItemsFile as A, BlockPackStatesFile as B, BlockPackBlockState as C, BlockPackEntityModelsFile as D, BlockPackEntitiesFile as E, BlockPackModelsFile as F, EntityPackCube as G, BlockPackTintsFile as H, BlockPackNamesFile as I, EntityPackModel as J, EntityPackCubeFace as K, BlockPackRenderLayer as L, BlockPackLightFile as M, BlockPackMetaFile as N, BlockPackFace as O, BlockPackModel as P, ItemPackEntry as Q, BlockPackSprite as R, BlockPackBiomesFile as S, BlockPackElement as T, BlockPackVariant as U, BlockPackTagsFile as V, EQUIPMENT_SLOTS as W, EquipmentPack as X, EntityPackPart as Y, EquipmentSlot as Z, extractBlockLight as _, Handle as a, BlockPackAtlasPage as b, LightExtraction as c, MemberReference as d, PropertyDomain as f, Value as g, StateProbe as h, statedMapColor as i, BlockPackLight as j, BlockPackGameRulesFile as k, LightGetter as l, Registration as m, PushReactionName as n, LambdaValue as o, PropsCall as p, EntityPackEntry as q, blockBehaviour as r, LightCodeSource as s, BlockBehaviour as t, LightSpec as u, BlockPackAdvancementsFile as v, BlockPackBlockStatesFile as w, BlockPackBehaviourFile as x, BlockPackAtlasFile as y, BlockPackSpriteFrame as z };

package/dist/{block-behaviour-D-SG2Xfp.js → block-behaviour-DVjqeSkv.js}

@@ -61,7 +61,10 @@ function float32(value) {
 	}
 	return value;
 }
-function blockBehaviour(registration, extraction) {
+function flag(value) {
+	return value.kind === "number" ? value.value === 0 ? 0 : 1 : null;
+}
+function blockBehaviour(registration, extraction, overrides = null) {
 	const props = registration.props;
 	if (!props) return null;
 	const failures = [];
@@ -146,6 +149,28 @@ function blockBehaviour(registration, extraction) {
 		if (id === null) failures.push("map colour is a value the interpreter could not identify");
 		else behaviour.mapColor = id;
 	}
+	const answer = (names, read) => {
+		const method = overrides?.of(names) ?? null;
+		if (!method) return null;
+		const folded = extraction.tabulateMethod(registration, method, read);
+		if ("failure" in folded) {
+			failures.push(`${names[0]}: ${folded.failure}`);
+			return null;
+		}
+		return folded.value;
+	};
+	const shape = answer(["useShapeForLightOcclusion"], flag);
+	if (shape === 1) behaviour.lightShape = true;
+	else if (shape !== null && typeof shape === "object") behaviour.lightShape = shape;
+	const lightBlock = answer(["getLightBlock", "getLightDampening"], (value) => value.kind === "number" ? value.value : null);
+	if (lightBlock !== null) behaviour.lightBlock = lightBlock;
+	const fluidMethod = overrides?.of(["getFluidState"]);
+	const fluid = fluidMethod && overrides ? overrides.fluid(fluidMethod) : null;
+	if (fluid) behaviour.fluid = fluid;
+	const renderShape = overrides?.of(["getRenderShape"]);
+	if (renderShape && overrides?.invisible(renderShape)) behaviour.invisible = true;
+	if (overrides?.of(["skipRendering"])) behaviour.hidesSharedFaces = true;
+	if (answer(["isAir"], flag) === 1) behaviour.air = true;
 	return {
 		behaviour,
 		failures

package/dist/block-overrides-XtxICunI.js

@@ -0,0 +1,77 @@
+import { n as instructions } from "./entity-sizes-DspxgSUA.js";
+//#region src/blocks/block-overrides.ts
+/**
+* Where a block's own class answers a question itself, rather than leaving it to its `Properties`.
+*
+* Some of what a block does is a method override, not a builder call: a stair or a slab tests its
+* shape for light (`useShapeForLightOcclusion`), tinted glass stops all light (`getLightBlock`), kelp is
+* always under water (`getFluidState`), and before 1.16.2 an air block said so by overriding `isAir`.
+* The override is found by walking the block's class chain for a method of that original name, and it
+* only counts where a class below the base declares it: the base's own is the default answer.
+*/
+/** `getstatic`, `invokevirtual` and `invokeinterface`: the instructions whose target says what code reads. */
+const READS = /* @__PURE__ */ new Set([
+	178,
+	182,
+	185
+]);
+/** How far up a block's class chain to look; vanilla's deepest is well under this. */
+const MAX_DEPTH = 16;
+/** The nearest override of one of `names` above `blockType`, or null where only the base declares it. */
+function overrideOf(source, blockType, names) {
+	const declarations = [];
+	let at = source.resolve(blockType);
+	for (let depth = 0; at && depth < MAX_DEPTH; depth++) {
+		const owner = at.thisClass;
+		const method = at.methods.find((candidate) => candidate.code && names.includes(source.nameOf({
+			owner,
+			name: candidate.name,
+			descriptor: candidate.descriptor
+		}, false)));
+		if (method) declarations.push({
+			owner,
+			name: method.name,
+			descriptor: method.descriptor
+		});
+		at = at.superClass ? source.resolve(at.superClass) : null;
+	}
+	return declarations.length > 1 ? declarations[0] : null;
+}
+/**
+* The constants an override reads, by original name, and whether it reads a block property: enough to
+* answer from its code without running it. Kelp's `getFluidState` reads `Fluids.WATER` and nothing
+* else; a barrier's `getRenderShape` reads `RenderShape.INVISIBLE`. One that reads a property
+* (`waterlogged`) answers per state, which the state already says.
+*/
+function constantsReadBy(source, method) {
+	const classFile = source.resolve(method.owner);
+	const code = classFile?.methods.find((candidate) => candidate.name === method.name && candidate.descriptor === method.descriptor)?.code;
+	if (!classFile || !code) return null;
+	const statics = /* @__PURE__ */ new Set();
+	let readsState = false;
+	for (const { op, index } of instructions(code)) {
+		const reference = READS.has(op) ? classFile.reference(index) : null;
+		if (!reference) continue;
+		const name = source.nameOf(reference, op === 178);
+		if (op === 178) statics.add(name);
+		else if (name === "getValue") readsState = true;
+	}
+	return {
+		statics,
+		readsState
+	};
+}
+/** The fluid an override of `getFluidState` holds in every state, or null where it depends on one. */
+function constantFluidOf(source, method) {
+	const read = constantsReadBy(source, method);
+	if (!read || read.readsState) return null;
+	if (read.statics.has("WATER")) return "water";
+	return read.statics.has("LAVA") ? "lava" : null;
+}
+/** Whether an override of `getRenderShape` always answers `INVISIBLE`, as a barrier's and a light block's do. */
+function alwaysInvisible(source, method) {
+	const read = constantsReadBy(source, method);
+	return read !== null && !read.readsState && read.statics.has("INVISIBLE") && !read.statics.has("MODEL");
+}
+//#endregion
+export { overrideOf as i, constantFluidOf as n, constantsReadBy as r, alwaysInvisible as t };

package/dist/blocks/block-behaviour.d.ts

@@ -1,2 +1,2 @@
-import { i as statedMapColor, n as PushReactionName, r as blockBehaviour, t as BlockBehaviour } from "../block-behaviour-9Tj_GIUC.js";
+import { i as statedMapColor, n as PushReactionName, r as blockBehaviour, t as BlockBehaviour } from "../block-behaviour-CzK3KVLx.js";
 export { BlockBehaviour, PushReactionName, blockBehaviour, statedMapColor };

package/dist/blocks/block-behaviour.js

@@ -1,2 +1,2 @@
-import { n as statedMapColor, t as blockBehaviour } from "../block-behaviour-D-SG2Xfp.js";
+import { n as statedMapColor, t as blockBehaviour } from "../block-behaviour-DVjqeSkv.js";
 export { blockBehaviour, statedMapColor };

package/dist/blocks/block-overrides.d.ts

@@ -0,0 +1,26 @@
+import { d as MemberReference } from "../block-behaviour-CzK3KVLx.js";
+import { t as ClassFile } from "../classfile-Dzn0gW9M.js";
+//#region src/blocks/block-overrides.d.ts
+interface OverrideSource {
+  resolve: (internalName: string) => ClassFile | null;
+  /** A member's original name, for a jar that spells the game's own obfuscated. */
+  nameOf: (reference: MemberReference, field: boolean) => string;
+}
+/** The nearest override of one of `names` above `blockType`, or null where only the base declares it. */
+declare function overrideOf(source: OverrideSource, blockType: string, names: readonly string[]): MemberReference | null;
+/**
+ * The constants an override reads, by original name, and whether it reads a block property: enough to
+ * answer from its code without running it. Kelp's `getFluidState` reads `Fluids.WATER` and nothing
+ * else; a barrier's `getRenderShape` reads `RenderShape.INVISIBLE`. One that reads a property
+ * (`waterlogged`) answers per state, which the state already says.
+ */
+declare function constantsReadBy(source: OverrideSource, method: MemberReference): {
+  statics: Set<string>;
+  readsState: boolean;
+} | null;
+/** The fluid an override of `getFluidState` holds in every state, or null where it depends on one. */
+declare function constantFluidOf(source: OverrideSource, method: MemberReference): 'water' | 'lava' | null;
+/** Whether an override of `getRenderShape` always answers `INVISIBLE`, as a barrier's and a light block's do. */
+declare function alwaysInvisible(source: OverrideSource, method: MemberReference): boolean;
+//#endregion
+export { OverrideSource, alwaysInvisible, constantFluidOf, constantsReadBy, overrideOf };

package/dist/blocks/block-overrides.js

@@ -0,0 +1,2 @@
+import { i as overrideOf, n as constantFluidOf, r as constantsReadBy, t as alwaysInvisible } from "../block-overrides-XtxICunI.js";
+export { alwaysInvisible, constantFluidOf, constantsReadBy, overrideOf };

package/dist/blocks/cli.js

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

package/dist/blocks/ender-storage.d.ts

@@ -1,5 +1,5 @@
 import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
-import { P as BlockPackModel } from "../block-behaviour-9Tj_GIUC.js";
+import { P as BlockPackModel } from "../block-behaviour-CzK3KVLx.js";
 //#region src/blocks/ender-storage.d.ts
 /**
  * Ender Storage feeds this OBJ through CodeChickenLib's `swapYZ`, translates it almost exactly onto

package/dist/blocks/entities.d.ts

@@ -1,6 +1,6 @@
 import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
 import { i as TextureLoader } from "../loader-C4gsX_wO.js";
-import { K as EntityPackEntry } from "../block-behaviour-9Tj_GIUC.js";
+import { q as EntityPackEntry } from "../block-behaviour-CzK3KVLx.js";
 //#region src/blocks/entities.d.ts
 interface EntityPackResult {
   entities: Record<string, EntityPackEntry>;

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

@@ -1,8 +1,8 @@
 import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
 import { t as ClassSource } from "../jar-classes-CSRrPAUy.js";
-import { Y as EquipmentPack, q as EntityPackModel } from "../block-behaviour-9Tj_GIUC.js";
+import { J as EntityPackModel, X as EquipmentPack } from "../block-behaviour-CzK3KVLx.js";
 import { t as Mappings } from "../mappings-DhOPQTgV.js";
-import { t as ModelCode } from "../model-code-Csc3bs3h.js";
+import { t as ModelCode } from "../model-code-BclYt1do.js";
 //#region src/blocks/entity-models.d.ts
 interface EntityGeometryResult {
   /** Model id (the class it came from) → geometry. */
@@ -53,15 +53,6 @@ declare function collectEntityGeometry(options: CollectEntityGeometryOptions): P
  * lowest to highest precedence, matching atlas source resolution when packs extend the vanilla file.
  */
 declare function collectArmourTrims(resources: ResourceManager, spriteIds: Set<string>): Promise<EquipmentPack['trims']>;
-/**
- * Worn armour for the pack: one humanoid mesh, the sheets each material is drawn with, and which
- * item is which.
- *
- * Materials are discovered from the sheets the version actually ships rather than listed, so a
- * version that adds one — copper, in the 26 line — needs no edit here. The item ids are the one part
- * the assets cannot answer, since nothing in them maps `iron_helmet` to `iron`: they follow the
- * game's own naming, and each is confirmed against a real item model before being claimed.
- */
 declare function collectEquipment(names: readonly string[], mappings: Mappings, read: (internal: string) => Promise<Uint8Array | null>, code: ModelCode, resources: ResourceManager | undefined, models: Record<string, EntityPackModel>, spriteIds: Set<string>): Promise<EquipmentPack | null>;
 //#endregion
 export { CollectEntityGeometryOptions, EntityGeometryResult, collectArmourTrims, collectEntityGeometry, collectEquipment };

package/dist/blocks/entity-models.js

@@ -1,2 +1,2 @@
-import { n as collectEntityGeometry, r as collectEquipment, t as collectArmourTrims } from "../entity-models-BYAxrTsk.js";
+import { n as collectEntityGeometry, r as collectEquipment, t as collectArmourTrims } from "../entity-models-vFl_EwfA.js";
 export { collectArmourTrims, collectEntityGeometry, collectEquipment };

package/dist/blocks/entity-sizes.js

@@ -1,2 +1,2 @@
-import { n as instructions, t as collectEntitySizes } from "../entity-sizes-CpO1gA7p.js";
+import { n as instructions, t as collectEntitySizes } from "../entity-sizes-DspxgSUA.js";
 export { collectEntitySizes, instructions };

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-HEoqcV-Y.js";
+import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "../export-CqeTinYL.js";
 export { BlockPackFailure, BlockPackResult, ExportBlockPackOptions, exportBlockPack };

package/dist/blocks/export.js

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

package/dist/blocks/game-rules.js

@@ -1,2 +1,2 @@
-import { t as collectGameRules } from "../game-rules-DuLlFc7o.js";
+import { t as collectGameRules } from "../game-rules-BDPTopVW.js";
 export { collectGameRules };

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

@@ -1,5 +1,5 @@
 import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
-import { P as BlockPackModel } from "../block-behaviour-9Tj_GIUC.js";
+import { P as BlockPackModel } from "../block-behaviour-CzK3KVLx.js";
 //#region src/blocks/geo-blocks.d.ts
 interface GeoBlockOverride {
   model: BlockPackModel;

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

@@ -1,7 +1,7 @@
 import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
 import { i as TextureLoader } from "../loader-C4gsX_wO.js";
 import { t as ModelLoader } from "../loader-BYyPIs9f.js";
-import { Z as ItemPackEntry } from "../block-behaviour-9Tj_GIUC.js";
+import { Q as ItemPackEntry } from "../block-behaviour-CzK3KVLx.js";
 //#region src/blocks/item-sprites.d.ts
 interface ItemSpriteFailure {
   id: string;

package/dist/blocks/light-bytecode.d.ts

@@ -1,2 +1,2 @@
-import { _ as extractBlockLight, a as Handle, c as LightExtraction, d as MemberReference, f as PropertyDomain, g as Value, h as StateProbe, l as LightGetter, m as Registration, o as LambdaValue, p as PropsCall, s as LightCodeSource, u as LightSpec } from "../block-behaviour-9Tj_GIUC.js";
+import { _ as extractBlockLight, a as Handle, c as LightExtraction, d as MemberReference, f as PropertyDomain, g as Value, h as StateProbe, l as LightGetter, m as Registration, o as LambdaValue, p as PropsCall, s as LightCodeSource, u as LightSpec } from "../block-behaviour-CzK3KVLx.js";
 export { Handle, LambdaValue, LightCodeSource, LightExtraction, LightGetter, LightSpec, MemberReference, PropertyDomain, PropsCall, Registration, StateProbe, Value, extractBlockLight };

package/dist/blocks/light-bytecode.js

@@ -1,2 +1,2 @@
-import { t as extractBlockLight } from "../light-bytecode-DYxb6pJk.js";
+import { t as extractBlockLight } from "../light-bytecode-hhkkjMVi.js";
 export { extractBlockLight };

package/dist/blocks/light-eval.d.ts

@@ -1,2 +1,2 @@
-import { t as blockLightLevel } from "../light-eval-DMjK6xnb.js";
+import { t as blockLightLevel } from "../light-eval-B4q-aVcf.js";
 export { blockLightLevel };

package/dist/blocks/light.d.ts

@@ -1,5 +1,5 @@
 import { t as ClassSource } from "../jar-classes-CSRrPAUy.js";
-import { j as BlockPackLight, t as BlockBehaviour } from "../block-behaviour-9Tj_GIUC.js";
+import { j as BlockPackLight, t as BlockBehaviour } from "../block-behaviour-CzK3KVLx.js";
 //#region src/blocks/light.d.ts
 interface CollectBlockLightOptions {
   version: string;
@@ -8,6 +8,8 @@ interface CollectBlockLightOptions {
   classes: ClassSource;
   /** Every block the pack describes, fully qualified; each gets an answer or a failure. */
   blockIds: readonly string[];
+  /** A block's default state, from the data generator's report, for a colour that is a function of state. */
+  defaultStateOf?: (blockId: string) => Readonly<Record<string, string>> | null;
   /** Blocks to describe in `notes` — what was registered and with which light — for chasing a failure. */
   trace?: readonly string[];
   onProgress?: (done: number, total: number) => void;

package/dist/blocks/light.js

@@ -1,2 +1,2 @@
-import { n as collectBlockLight, r as vanillaLightAt, t as VANILLA_LIGHT } from "../light-CC3VMsjl.js";
+import { n as collectBlockLight, r as vanillaLightAt, t as VANILLA_LIGHT } from "../light-BnaYFouC.js";
 export { VANILLA_LIGHT, collectBlockLight, vanillaLightAt };

package/dist/blocks/names.d.ts

@@ -0,0 +1,2 @@
+import { n as collectNames, t as NamePack } from "../names-D1abAVIB.js";
+export { NamePack, collectNames };

package/dist/blocks/names.js

@@ -0,0 +1,2 @@
+import { t as collectNames } from "../names-GLa5TyL7.js";
+export { collectNames };

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

@@ -1,2 +1,2 @@
-import { A as BlockPackItemsFile, B as BlockPackTagsFile, C as BlockPackBlockState, D as BlockPackEntityModelsFile, E as BlockPackEntitiesFile, F as BlockPackModelsFile, G as EntityPackCubeFace, H as BlockPackVariant, I as BlockPackRenderLayer, J as EntityPackPart, K as EntityPackEntry, L as BlockPackSprite, M as BlockPackLightFile, N as BlockPackMetaFile, O as BlockPackFace, P as BlockPackModel, Q as ItemPackLayer, R as BlockPackSpriteFrame, S as BlockPackBiomesFile, T as BlockPackElement, U as EQUIPMENT_SLOTS, V as BlockPackTintsFile, W as EntityPackCube, X as EquipmentSlot, Y as EquipmentPack, Z as ItemPackEntry, b as BlockPackAtlasPage, j as BlockPackLight, k as BlockPackGameRulesFile, q as EntityPackModel, v as BlockPackAdvancementsFile, w as BlockPackBlockStatesFile, x as BlockPackBehaviourFile, y as BlockPackAtlasFile, z as BlockPackStatesFile } from "../block-behaviour-9Tj_GIUC.js";
-export { BlockPackAdvancementsFile, BlockPackAtlasFile, BlockPackAtlasPage, BlockPackBehaviourFile, BlockPackBiomesFile, BlockPackBlockState, BlockPackBlockStatesFile, BlockPackElement, BlockPackEntitiesFile, BlockPackEntityModelsFile, BlockPackFace, BlockPackGameRulesFile, BlockPackItemsFile, BlockPackLight, BlockPackLightFile, BlockPackMetaFile, BlockPackModel, BlockPackModelsFile, BlockPackRenderLayer, BlockPackSprite, BlockPackSpriteFrame, BlockPackStatesFile, BlockPackTagsFile, BlockPackTintsFile, BlockPackVariant, EQUIPMENT_SLOTS, EntityPackCube, EntityPackCubeFace, EntityPackEntry, EntityPackModel, EntityPackPart, EquipmentPack, EquipmentSlot, ItemPackEntry, ItemPackLayer };
+import { $ as ItemPackLayer, A as BlockPackItemsFile, B as BlockPackStatesFile, C as BlockPackBlockState, D as BlockPackEntityModelsFile, E as BlockPackEntitiesFile, F as BlockPackModelsFile, G as EntityPackCube, H as BlockPackTintsFile, I as BlockPackNamesFile, J as EntityPackModel, K as EntityPackCubeFace, L as BlockPackRenderLayer, M as BlockPackLightFile, N as BlockPackMetaFile, O as BlockPackFace, P as BlockPackModel, Q as ItemPackEntry, R as BlockPackSprite, S as BlockPackBiomesFile, T as BlockPackElement, U as BlockPackVariant, V as BlockPackTagsFile, W as EQUIPMENT_SLOTS, X as EquipmentPack, Y as EntityPackPart, Z as EquipmentSlot, b as BlockPackAtlasPage, j as BlockPackLight, k as BlockPackGameRulesFile, q as EntityPackEntry, v as BlockPackAdvancementsFile, w as BlockPackBlockStatesFile, x as BlockPackBehaviourFile, y as BlockPackAtlasFile, z as BlockPackSpriteFrame } from "../block-behaviour-CzK3KVLx.js";
+export { BlockPackAdvancementsFile, BlockPackAtlasFile, BlockPackAtlasPage, BlockPackBehaviourFile, BlockPackBiomesFile, BlockPackBlockState, BlockPackBlockStatesFile, BlockPackElement, BlockPackEntitiesFile, BlockPackEntityModelsFile, BlockPackFace, BlockPackGameRulesFile, BlockPackItemsFile, BlockPackLight, BlockPackLightFile, BlockPackMetaFile, BlockPackModel, BlockPackModelsFile, BlockPackNamesFile, BlockPackRenderLayer, BlockPackSprite, BlockPackSpriteFrame, BlockPackStatesFile, BlockPackTagsFile, BlockPackTintsFile, BlockPackVariant, EQUIPMENT_SLOTS, EntityPackCube, EntityPackCubeFace, EntityPackEntry, EntityPackModel, EntityPackPart, EquipmentPack, EquipmentSlot, ItemPackEntry, ItemPackLayer };

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

@@ -1,6 +1,6 @@
 import { i as TextureLoader, r as Texture } from "../loader-C4gsX_wO.js";
 import { i as PackedPage } from "../atlas-pack-BUadroKy.js";
-import { I as BlockPackRenderLayer, L as BlockPackSprite } from "../block-behaviour-9Tj_GIUC.js";
+import { L as BlockPackRenderLayer, R as BlockPackSprite } from "../block-behaviour-CzK3KVLx.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-CiIDF3vc.js → classfile-BJSs3JH0.js}

@@ -173,7 +173,7 @@ function readConstantPool(reader) {
 * 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) {
+function readAttributes(reader, utf8, bootstraps, constants) {
 	let code;
 	const count = reader.u2();
 	for (let index = 0; index < count; index++) {
@@ -193,6 +193,10 @@ function readAttributes(reader, utf8, bootstraps) {
 			}
 			continue;
 		}
+		if (name === "ConstantValue" && constants) {
+			constants.push(reader.u2());
+			continue;
+		}
 		if (name !== "Code") {
 			reader.skip(length);
 			continue;
@@ -221,10 +225,19 @@ function parseClassFile(bytes) {
 	const superIndex = reader.u2();
 	const superClass = superIndex === 0 ? null : utf8(superIndex);
 	reader.skip(reader.u2() * 2);
+	const fieldEntries = [];
 	const fieldCount = reader.u2();
 	for (let index = 0; index < fieldCount; index++) {
-		reader.skip(6);
-		readAttributes(reader, utf8);
+		reader.skip(2);
+		const name = utf8(reader.u2());
+		const descriptor = utf8(reader.u2());
+		const constant = [];
+		readAttributes(reader, utf8, void 0, constant);
+		fieldEntries.push({
+			name,
+			descriptor,
+			constant: constant[0]
+		});
 	}
 	const methods = [];
 	const methodCount = reader.u2();
@@ -297,6 +310,13 @@ function parseClassFile(bytes) {
 		superClass,
 		constants,
 		methods,
+		fields: fieldEntries.map((field) => {
+			return {
+				name: field.name,
+				descriptor: field.descriptor,
+				constant: field.constant === void 0 ? null : literal(field.constant)
+			};
+		}),
 		utf8,
 		reference,
 		literal,

package/dist/{classfile-CsLXlh5z.d.ts → classfile-Dzn0gW9M.d.ts}

@@ -39,6 +39,12 @@ interface ClassFile {
   superClass: string | null;
   constants: Array<Constant | null>;
   methods: MethodInfo[];
+  /** Each field, with its value where it is a compile-time constant (`static final int`). */
+  fields: Array<{
+    name: string;
+    descriptor: string;
+    constant: string | number | bigint | null;
+  }>;
   /** 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. */

package/dist/{cli-xBcMuKA3.js → cli-2mzPC8cy.js}

@@ -1,7 +1,7 @@
 import { n as builtinPackPath } from "./builtin-WkWjATeh.js";
 import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-D6zXmFrO.js";
 import { a as prepareVersionResources, r as compareVersions } from "./prepare-DkJkZXuQ.js";
-import { t as exportBlockPack } from "./export-CbG2Rx3i.js";
+import { t as exportBlockPack } from "./export-DgB0e5sB.js";
 import { n as layeredClasses, t as JarClassReader } from "./jar-classes-0wqWbTax.js";
 import { n as prepareModResources } from "./prepare-sj36BP90.js";
 import { t as downloadClientJar } from "./download-1wAfrGKx.js";

package/dist/cli.js

@@ -6,7 +6,7 @@ import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_V
 import { t as curatedModelOverrides } from "./models-BsYA-NZg.js";
 import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-CZeyKzMv.js";
 import { t as downloadClientJar } from "./download-1wAfrGKx.js";
-import { t as runBlocksCli } from "./cli-xBcMuKA3.js";
+import { t as runBlocksCli } from "./cli-2mzPC8cy.js";
 import { t as run } from "./run-5yX5KRiI.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-CsLXlh5z.js";
+import { a as parseClassFile, i as MethodInfo, n as Constant, r as ConstantTag, t as ClassFile } from "../classfile-Dzn0gW9M.js";
 export { ClassFile, Constant, ConstantTag, MethodInfo, parseClassFile };

package/dist/entities/classfile.js

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

package/dist/entities/inherit.d.ts

@@ -1,6 +1,6 @@
-import { t as ClassFile } from "../classfile-CsLXlh5z.js";
+import { t as ClassFile } from "../classfile-Dzn0gW9M.js";
 import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
-import { t as ModelCode } from "../model-code-Csc3bs3h.js";
+import { t as ModelCode } from "../model-code-BclYt1do.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-BUn0Cve9.js";
+import { n as extractInheritedModel, t as ancestryOf } from "../inherit-DJ45bOB_.js";
 export { ancestryOf, extractInheritedModel };

package/dist/entities/link.d.ts

@@ -1,4 +1,4 @@
-import { t as ClassFile } from "../classfile-CsLXlh5z.js";
+import { t as ClassFile } from "../classfile-Dzn0gW9M.js";
 import { t as Mappings } from "../mappings-DhOPQTgV.js";
 //#region src/entities/link.d.ts
 /**

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-Cuhyrz07.js";
+import { a as linkEntityModel, i as classReader, n as RENDERER_ALIASES, o as normaliseModelName, r as buildModelNameIndex, t as NO_MODEL } from "../link-IDjVJ2Ij.js";
 export { NO_MODEL, RENDERER_ALIASES, buildModelNameIndex, classReader, linkEntityModel, normaliseModelName };

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

@@ -1,4 +1,4 @@
-import { t as ClassFile } from "../classfile-CsLXlh5z.js";
+import { t as ClassFile } from "../classfile-Dzn0gW9M.js";
 import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
 //#region src/entities/model-bytecode.d.ts
 /** Argument slot count and shape of a descriptor's parameter list. */

package/dist/entities/model-bytecode.js

@@ -1,2 +1,2 @@
-import { n as extractModel, r as parseDescriptor, t as extractArmourMesh } from "../model-bytecode-VaLUQfGO.js";
+import { n as extractModel, r as parseDescriptor, t as extractArmourMesh } from "../model-bytecode-CXYAZ5dX.js";
 export { extractArmourMesh, extractModel, parseDescriptor };

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

@@ -1,2 +1,2 @@
-import { n as isModelCode, r as loadModelCode, t as ModelCode } from "../model-code-Csc3bs3h.js";
+import { n as isModelCode, r as loadModelCode, t as ModelCode } from "../model-code-BclYt1do.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-DbN2uVhp.js";
+import { n as loadModelCode, t as isModelCode } from "../model-code-BmA5ilgt.js";
 export { isModelCode, loadModelCode };

package/dist/{entity-models-BYAxrTsk.js → entity-models-vFl_EwfA.js}

@@ -1,11 +1,12 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
 import { t as findGeoForEntity } from "./entity-geo-DbTtMlPL.js";
 import { t as EQUIPMENT_SLOTS } from "./pack-format-BP5dJMYY.js";
-import { n as extractModel, t as extractArmourMesh } from "./model-bytecode-VaLUQfGO.js";
-import { n as extractInheritedModel, t as ancestryOf } from "./inherit-BUn0Cve9.js";
-import { a as linkEntityModel, i as classReader, r as buildModelNameIndex } from "./link-Cuhyrz07.js";
+import { t as parseClassFile } from "./classfile-BJSs3JH0.js";
+import { n as extractModel, t as extractArmourMesh } from "./model-bytecode-CXYAZ5dX.js";
+import { n as extractInheritedModel, t as ancestryOf } from "./inherit-DJ45bOB_.js";
+import { a as linkEntityModel, i as classReader, r as buildModelNameIndex } from "./link-IDjVJ2Ij.js";
 import { c as resolveMappings, t as MappingsUnavailableError } from "./mappings-DEl_7xxQ.js";
-import { n as loadModelCode } from "./model-code-DbN2uVhp.js";
+import { n as loadModelCode } from "./model-code-BmA5ilgt.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
@@ -345,6 +346,22 @@ async function armourGeometry(names, mappings, read, code) {
 * the assets cannot answer, since nothing in them maps `iron_helmet` to `iron`: they follow the
 * game's own naming, and each is confirmed against a real item model before being claimed.
 */
+/**
+* Where the game keeps the colour an undyed leather piece takes, newest first: 1.20.5 moved it from
+* the item class to the dyed-colour component. A `static final int`, so it is read off the field
+* itself, since javac copies the value into every place that uses it.
+*/
+const LEATHER_COLOUR_FIELDS = [["net.minecraft.world.item.component.DyedItemColor", "LEATHER_COLOR"], ["net.minecraft.world.item.DyeableLeatherItem", "DEFAULT_LEATHER_COLOR"]];
+async function undyedLeather(mappings, read) {
+	for (const [owner, field] of LEATHER_COLOUR_FIELDS) {
+		const bytes = await read((mappings.obfuscatedOf.get(owner) ?? owner).replaceAll(".", "/"));
+		if (!bytes) continue;
+		const name = mappings.fieldOf.get(`${owner}.${field}`) ?? field;
+		const value = parseClassFile(bytes).fields.find((candidate) => candidate.name === name)?.constant;
+		if (typeof value === "number") return `#${(value & 16777215).toString(16).padStart(6, "0")}`;
+	}
+	return null;
+}
 async function collectEquipment(names, mappings, read, code, resources, models, spriteIds) {
 	if (!resources) return null;
 	const found = await armourGeometry(names, mappings, read, code);
@@ -385,6 +402,7 @@ async function collectEquipment(names, mappings, read, code, resources, models,
 		}
 	}
 	const trims = await collectArmourTrims(resources, spriteIds);
+	const leather = dyeable.includes("minecraft:leather") ? await undyedLeather(mappings, read) : null;
 	const modelKey = `${found.className}#armor`;
 	models[modelKey] = {
 		textureSize: [...found.model.textureSize],
@@ -399,6 +417,7 @@ async function collectEquipment(names, mappings, read, code, resources, models,
 		materials,
 		items,
 		dyeable,
+		...leather && { undyed: { "minecraft:leather": leather } },
 		trims
 	};
 }

package/dist/{entity-sizes-CpO1gA7p.js → entity-sizes-DspxgSUA.js}

@@ -1,4 +1,4 @@
-import { t as parseClassFile } from "./classfile-CiIDF3vc.js";
+import { t as parseClassFile } from "./classfile-BJSs3JH0.js";
 import { c as resolveMappings, t as MappingsUnavailableError } from "./mappings-DEl_7xxQ.js";
 //#region src/blocks/entity-sizes.ts
 /**

package/dist/{export-HEoqcV-Y.d.ts → export-CqeTinYL.d.ts}

@@ -83,6 +83,8 @@ interface BlockPackResult {
   states: number;
   /** Rules in `game-rules.json`; `0` means the file was not written. */
   gameRules: number;
+  /** Block and item names in `names.json`; `0` means the file was not written. */
+  names: number;
   /** Files actually written — the only trustworthy success signal. */
   writtenFiles: number;
   failures: BlockPackFailure[];

package/dist/{export-CbG2Rx3i.js → export-DgB0e5sB.js}

@@ -7,13 +7,14 @@ import { t as collectDatapack } from "./datapack-D6eH46ay.js";
 import { a as salvageJson, i as resolveTexture, t as ModelLoader } from "./loader-qOH0Jynq.js";
 import { t as enderStorageBlockModel } from "./ender-storage-Dgomp6r2.js";
 import { t as collectEntities } from "./entities-rQ4TZjEo.js";
-import { n as collectEntityGeometry } from "./entity-models-BYAxrTsk.js";
-import { t as collectEntitySizes } from "./entity-sizes-CpO1gA7p.js";
-import { t as collectGameRules } from "./game-rules-DuLlFc7o.js";
+import { n as collectEntityGeometry } from "./entity-models-vFl_EwfA.js";
+import { t as collectEntitySizes } from "./entity-sizes-DspxgSUA.js";
+import { t as collectGameRules } from "./game-rules-BDPTopVW.js";
 import { t as geoBlockModel } from "./geo-blocks-W79q5A0f.js";
 import { n as discoverItems } from "./discovery-CD0QqxSF.js";
 import { t as collectItemSprites } from "./item-sprites-CwiEBEAJ.js";
-import { n as collectBlockLight } from "./light-CC3VMsjl.js";
+import { n as collectBlockLight } from "./light-BnaYFouC.js";
+import { t as collectNames } from "./names-GLa5TyL7.js";
 import { n as buildObjMesh } from "./obj-mesh-BFhtTBXX.js";
 import { n as buildSpriteSheet, t as MISSING_SPRITE } from "./sprite-sheet-LQAEtGkp.js";
 import { t as readBlockStates } from "./states-BvoZA-ql.js";
@@ -698,6 +699,7 @@ async function exportBlockPack(options) {
 			});
 		}
 	}
+	const states = options.reports === void 0 ? null : await readBlockStates(options.reports);
 	let lightPack = {};
 	let behaviourPack = {};
 	if (options.classes) {
@@ -706,6 +708,7 @@ async function exportBlockPack(options) {
 			cacheDir: options.cacheDir ?? output,
 			classes: options.classes,
 			blockIds: [.../* @__PURE__ */ new Set([...blockLocators.map((locator) => locator.toString()), ...Object.keys(blockStates)])],
+			defaultStateOf: (id) => states?.[id]?.default ?? null,
 			onProgress: (count, total) => report("light", count, total)
 		});
 		lightPack = sortedByKey(collected.light);
@@ -730,8 +733,9 @@ async function exportBlockPack(options) {
 		reason: "datapack file is unreadable or not in the shape its folder implies; left out"
 	});
 	const tagCount = Object.values(datapack.tags).reduce((sum, registry) => sum + Object.keys(registry).length, 0);
+	const names = await collectNames(resources, namespaces);
+	const nameCount = Object.keys(names.block).length + Object.keys(names.item).length;
 	const gameRules = options.classes && namespaces.includes("minecraft") ? await collectGameRules(options.classes) : {};
-	const states = options.reports === void 0 ? null : await readBlockStates(options.reports);
 	const statesPack = states === null ? null : Object.fromEntries(Object.entries(states).filter(([id]) => namespaces.includes(id.split(":", 1)[0])));
 	let itemPack = null;
 	let itemPages = [];
@@ -946,6 +950,10 @@ async function exportBlockPack(options) {
 		const tags = Object.fromEntries(Object.entries(datapack.tags).map(([registry, entries]) => [registry, sortedByKey(entries)]));
 		await emit("tags.json", JSON.stringify(sortedByKey(tags)));
 	}
+	if (nameCount > 0) await emit("names.json", JSON.stringify({
+		block: sortedByKey(names.block),
+		item: sortedByKey(names.item)
+	}));
 	if (Object.keys(gameRules).length > 0) await emit("game-rules.json", JSON.stringify(sortedByKey(gameRules)));
 	if (statesPack !== null && Object.keys(statesPack).length > 0) await emit("states.json", JSON.stringify(sortedByKey(statesPack)));
 	if (Object.keys(datapack.advancements).length > 0) await emit("advancements.json", JSON.stringify(sortedByKey(datapack.advancements)));
@@ -971,6 +979,7 @@ async function exportBlockPack(options) {
 		advancements: Object.keys(datapack.advancements).length,
 		states: Object.keys(statesPack ?? {}).length,
 		gameRules: Object.keys(gameRules).length,
+		names: nameCount,
 		failures: failures.length
 	};
 	await emit("meta.json", JSON.stringify({

package/dist/{game-rules-DuLlFc7o.js → game-rules-BDPTopVW.js}

@@ -1,5 +1,5 @@
-import { t as parseClassFile } from "./classfile-CiIDF3vc.js";
-import { n as instructions } from "./entity-sizes-CpO1gA7p.js";
+import { t as parseClassFile } from "./classfile-BJSs3JH0.js";
+import { n as instructions } from "./entity-sizes-DspxgSUA.js";
 //#region src/blocks/game-rules.ts
 /**
 * The version's game rules: each one's name, whether it is on/off or a number, and its default.

package/dist/index.d.ts

@@ -8,7 +8,7 @@ import { a as BlockStateMultipartCase, d as matchesCondition, f as parseBlockSta
 import { a as resolveTexture, n as ModelResolutionError, o as salvageJson, r as ResolvedModel, t as ModelLoader } from "./loader-BYyPIs9f.js";
 import { i as buildObjMesh, n as ObjMesh, r as ObjMeshError, t as MeshGroup } from "./obj-mesh-CzL0lOlJ.js";
 import { a as buildBlockTints, i as UNREGISTERED_TINTS, n as BlockTintPack, t as BlockTint } from "./tints-DwFmEkf3.js";
-import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "./export-HEoqcV-Y.js";
+import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "./export-CqeTinYL.js";
 import { s as builtinDynamicResources } from "./generators-hu_vk10m.js";
 import { d as toFloatTexture, n as FloatTexture, u as toByteTexture } from "./blend-mJAeQB3C.js";
 import { a as LightingProfileName, i as LightingProfile, r as LightSource, u as lightsForProfile } from "./lighting-3FGRC3Af.js";

package/dist/index.js

@@ -16,7 +16,7 @@ import { t as packAtlas } from "./atlas-pack-CoOih7By.js";
 import { n as buildBlockTints, t as UNREGISTERED_TINTS } from "./tints-Cl0r-Ol3.js";
 import { o as createAtlasResolver, s as parseAtlasSources, t as AtlasSourceError } from "./sources-DYY5Qu-t.js";
 import { n as TextureLoader, r as TextureResolutionError, t as AnimatedTexture } from "./loader-CsgtBuBo.js";
-import { t as exportBlockPack } from "./export-CbG2Rx3i.js";
+import { t as exportBlockPack } from "./export-DgB0e5sB.js";
 import { n as prepareModResources } from "./prepare-sj36BP90.js";
 import { n as encodeIcon, t as encodeAnimatedIcon } from "./encode-LR9wxigC.js";
 import { a as builtinDynamicResources } from "./generators-D6giKoab.js";

package/dist/{inherit-BUn0Cve9.js → inherit-DJ45bOB_.js}

@@ -1,6 +1,6 @@
-import { t as parseClassFile } from "./classfile-CiIDF3vc.js";
+import { t as parseClassFile } from "./classfile-BJSs3JH0.js";
 import { a as mergeModels, i as dedupeCubes } from "./merge-DeHruviG.js";
-import { n as extractModel } from "./model-bytecode-VaLUQfGO.js";
+import { n as extractModel } from "./model-bytecode-CXYAZ5dX.js";
 //#region src/entities/inherit.ts
 /**
 * A model class read together with its ancestors.

package/dist/{light-CC3VMsjl.js → light-BnaYFouC.js}

@@ -1,8 +1,9 @@
 import { r as compareVersions } from "./prepare-DkJkZXuQ.js";
-import { t as parseClassFile } from "./classfile-CiIDF3vc.js";
+import { t as parseClassFile } from "./classfile-BJSs3JH0.js";
 import { c as resolveMappings, s as remapDescriptor, t as MappingsUnavailableError } from "./mappings-DEl_7xxQ.js";
-import { t as blockBehaviour } from "./block-behaviour-D-SG2Xfp.js";
-import { t as extractBlockLight } from "./light-bytecode-DYxb6pJk.js";
+import { t as blockBehaviour } from "./block-behaviour-DVjqeSkv.js";
+import { i as overrideOf, n as constantFluidOf, t as alwaysInvisible } from "./block-overrides-XtxICunI.js";
+import { t as extractBlockLight } from "./light-bytecode-hhkkjMVi.js";
 //#region src/blocks/light.ts
 /**
 * Block light emission for the exported pack: `light.json`.
@@ -301,6 +302,7 @@ async function collectBlockLight(options) {
 		remap,
 		remapClass,
 		nameOf,
+		defaultStateOf: options.defaultStateOf,
 		propsClasses,
 		lightGetters: findLightGetters(roots, propsClasses, resolve, notes),
 		isVanillaClass: (name) => mappings.originalOf.size === 0 || mappings.originalOf.has(name.replaceAll("/", ".")) || name.startsWith("net/minecraft/") || name.startsWith("com/mojang/")
@@ -336,7 +338,16 @@ async function collectBlockLight(options) {
 	const behaviourFailures = [];
 	if (mappings.originalOf.size > 0 || isClearJar) for (const id of blockIds) {
 		const registration = NOT_BLOCKS.has(id) ? null : extraction.registrationOf(id);
-		const read = registration ? blockBehaviour(registration, extraction) : null;
+		const blockType = registration?.blockType ?? registration?.block?.type ?? null;
+		const overrides = {
+			resolve,
+			nameOf
+		};
+		const read = registration ? blockBehaviour(registration, extraction, {
+			of: (names) => blockType ? overrideOf(overrides, blockType, names) : null,
+			fluid: (method) => constantFluidOf(overrides, method),
+			invisible: (method) => alwaysInvisible(overrides, method)
+		}) : null;
 		if (read) {
 			behaviour[id] = read.behaviour;
 			for (const reason of read.failures) behaviourFailures.push({

package/dist/{light-bytecode-DYxb6pJk.js → light-bytecode-hhkkjMVi.js}

@@ -1,5 +1,6 @@
-import { r as parseDescriptor } from "./model-bytecode-VaLUQfGO.js";
-import { n as statedMapColor } from "./block-behaviour-D-SG2Xfp.js";
+import { r as parseDescriptor } from "./model-bytecode-CXYAZ5dX.js";
+import { n as instructions } from "./entity-sizes-DspxgSUA.js";
+import { n as statedMapColor } from "./block-behaviour-DVjqeSkv.js";
 //#region src/blocks/light-bytecode.ts
 /**
 * Block light emission, read out of the code that registers blocks.
@@ -426,6 +427,63 @@ var Interpreter = class Interpreter {
 		const parent = this.shared.source.resolve(handle.type)?.superClass ?? null;
 		return parent === "java/lang/Enum" || parent !== null && this.shared.source.resolve(parent)?.superClass === "java/lang/Enum";
 	}
+	/**
+	* A function of state run at a registered block's default state, which only the data generator's
+	* report states: a sign takes its log's colour, and a log is `axis=y` until placed otherwise.
+	*/
+	atDefaultState(block, fn) {
+		const { source, registrations } = this.shared;
+		let values = null;
+		for (const [name, registration] of registrations) {
+			if (registration.block !== block || values) continue;
+			const id = name.includes(":") ? name : registration.vanilla ? `minecraft:${name}` : null;
+			values = id ? source.defaultStateOf?.(id) ?? null : null;
+		}
+		if (!values) return null;
+		const saved = {
+			steps: this.shared.steps,
+			frames: this.shared.frames,
+			probe: this.shared.probe
+		};
+		const probe = {
+			values: new Map(Object.entries(values)),
+			domains: /* @__PURE__ */ new Map(),
+			reads: /* @__PURE__ */ new Set(),
+			failure: null
+		};
+		this.shared.probe = probe;
+		this.shared.steps = Math.min(saved.steps, CTOR_BUDGET);
+		try {
+			const result = this.invokeLambda(fn, [{
+				kind: "state",
+				probe
+			}]);
+			return probe.failure ? null : result;
+		} finally {
+			this.shared.steps = saved.steps - Math.max(0, Math.min(saved.steps, CTOR_BUDGET) - this.shared.steps);
+			this.shared.frames = saved.frames;
+			this.shared.probe = saved.probe;
+		}
+	}
+	/**
+	* The class a factory lambda constructs, read off its body rather than run: `props -> new
+	* StairBlock(base, props)` builds a `StairBlock`. What a stair overrides lives on that class.
+	*/
+	constructedIn(lambda) {
+		const reference = this.shared.source.remap({
+			owner: lambda.owner,
+			name: lambda.name,
+			descriptor: lambda.descriptor
+		}, false);
+		const target = findMethod(this.shared.source, reference.owner, reference.name, reference.descriptor);
+		if (!target) return null;
+		for (const { op, index } of instructions(target.code)) {
+			if (op !== 187) continue;
+			const name = target.classFile.utf8(index);
+			if (!name.startsWith("java/") && !this.isPropsType(name)) return this.shared.source.remapClass(name);
+		}
+		return null;
+	}
 	detectRegistration(args, site) {
 		const names = [];
 		for (const arg of args) if (arg.kind === "string") names.push(arg.value);
@@ -435,16 +493,17 @@ var Interpreter = class Interpreter {
 		}
 		const ids = names.filter((name) => looksLikeId(name));
 		if (ids.length === 0) return null;
-		const known = ids.map((name) => this.shared.registrations.get(name)).find((entry) => entry !== void 0);
+		const known = ids.map((name) => this.shared.registrations.get(name)).findLast((entry) => entry !== void 0);
 		if (known && ids.every((name) => this.shared.registrations.has(name))) return known.block ?? this.blockFor(known);
 		let props = null;
 		let block = null;
 		let blockType = null;
 		for (const arg of args) if (arg.kind === "object" && arg.handle.isProps) props ??= arg.handle;
-		else if (arg.kind === "object" && arg.handle.props) block ??= arg.handle;
+		else if (arg.kind === "object" && arg.handle.props && !this.shared.registeredBlocks.has(arg.handle)) block ??= arg.handle;
 		else if (arg.kind === "lambda" && arg.name === "<init>") blockType ??= this.shared.source.remapClass(arg.owner);
+		else if (arg.kind === "lambda") blockType ??= this.constructedIn(arg);
 		if (!props && !block) for (const arg of args) {
-			if (arg.kind !== "lambda") continue;
+			if (arg.kind !== "lambda" || parseDescriptor(arg.descriptor).args.length > arg.captured.length) continue;
 			const made = this.invokeLambda(arg, []);
 			if (made?.kind === "object" && made.handle.props) {
 				block = made.handle;
@@ -460,7 +519,9 @@ var Interpreter = class Interpreter {
 			vanilla: this.caller !== null && this.shared.source.isVanillaClass(this.caller)
 		};
 		for (const name of ids) if (!this.shared.registrations.has(name)) this.shared.registrations.set(name, registration);
-		return block ?? this.blockFor(registration);
+		const registered = block ?? this.blockFor(registration);
+		this.shared.registeredBlocks.add(registered);
+		return registered;
 	}
 	/**
 	* The block a registration stands for, when the call was handed properties and a factory rather than
@@ -840,7 +901,7 @@ var Interpreter = class Interpreter {
 				return;
 			}
 		}
-		const registered = this.detectRegistration(args, `${remapped.owner}.${remapped.name}${remapped.descriptor}`);
+		const registered = returns.startsWith("L") && source.resolve(returns.slice(1, -1))?.superClass === "java/lang/Record" ? null : this.detectRegistration(args, `${remapped.owner}.${remapped.name}${remapped.descriptor}`);
 		if (registered) {
 			this.push(returns === "V" ? null : returns.startsWith("L") ? {
 				kind: "object",
@@ -853,8 +914,9 @@ var Interpreter = class Interpreter {
 			const named = source.nameOf?.(reference, false) ?? remapped.name;
 			if (target.props && args.length === 0 && (named === "defaultMapColor" || named === "defaultMaterialColor")) {
 				const colour = statedMapColor(target.props);
-				if (colour && colour.kind !== "lambda") {
-					this.push(colour);
+				const answer = colour?.kind === "lambda" ? this.atDefaultState(target, colour) : colour;
+				if (answer) {
+					this.push(answer);
 					return;
 				}
 			}
@@ -1580,6 +1642,27 @@ var Interpreter = class Interpreter {
 			this.shared.probe = null;
 		}
 	}
+	/**
+	* Runs a block class's own method of a state (`getLightValue(state)`, `useShapeForLightOcclusion(state)`)
+	* on the block, the state first and anything after it unknown; null where the interpreter lost it.
+	*/
+	evaluateMethod(owner, name, descriptor, receiver, probe, typedArguments = false) {
+		const method = findMethod(this.shared.source, owner, name, descriptor);
+		if (!method) return null;
+		const self = {
+			kind: "object",
+			handle: receiver ?? this.handle(owner)
+		};
+		const rest = parseDescriptor(descriptor).args.slice(1).map((shape) => typedArguments && shape.startsWith("L") ? {
+			kind: "object",
+			handle: this.handle(shape.slice(1, -1))
+		} : UNKNOWN);
+		const inlined = this.inline(method.classFile.thisClass, name, descriptor, self, [{
+			kind: "state",
+			probe
+		}, ...rest]);
+		return inlined.ok ? inlined.value : null;
+	}
 	/** Evaluates a light spec against one state; null where the interpreter lost the value. */
 	evaluate(spec, probe) {
 		this.shared.probe = probe;
@@ -1592,20 +1675,8 @@ var Interpreter = class Interpreter {
 			};
 			let result;
 			if (spec.kind === "function") result = this.invokeLambda(spec.fn, [state]);
-			else if (spec.kind === "method") {
-				const method = findMethod(this.shared.source, spec.owner, spec.getter.name, spec.getter.descriptor);
-				if (!method) return null;
-				const receiver = spec.receiver ? {
-					kind: "object",
-					handle: spec.receiver
-				} : {
-					kind: "object",
-					handle: this.handle(spec.owner)
-				};
-				const extra = parseDescriptor(spec.getter.descriptor).args.length - 1;
-				const inlined = this.inline(method.classFile.thisClass, spec.getter.name, spec.getter.descriptor, receiver, [state, ...Array.from({ length: extra }, () => UNKNOWN)]);
-				result = inlined.ok ? inlined.value : null;
-			} else return spec.kind === "constant" ? spec.level : null;
+			else if (spec.kind === "method") result = this.evaluateMethod(spec.owner, spec.getter.name, spec.getter.descriptor, spec.receiver, probe);
+			else return spec.kind === "constant" ? spec.level : null;
 			if (probe.failure || result?.kind !== "number" || !Number.isFinite(result.value)) return null;
 			return Math.max(0, Math.min(15, Math.round(result.value)));
 		} finally {
@@ -1679,6 +1750,7 @@ function extractBlockLight(roots, source) {
 		statics: /* @__PURE__ */ new Map(),
 		initialised: /* @__PURE__ */ new Set(),
 		registrations: /* @__PURE__ */ new Map(),
+		registeredBlocks: /* @__PURE__ */ new Set(),
 		steps: STEP_BUDGET,
 		frames: FRAME_BUDGET,
 		notes: [],
@@ -1744,6 +1816,20 @@ function extractBlockLight(roots, source) {
 			return value === null ? null : read(value);
 		}, "state function");
 	};
+	const tabulateMethod = (registration, method, read) => {
+		const evaluator = new Interpreter(shared);
+		return tabulateStates(shared, (probe) => {
+			shared.probe = probe;
+			shared.steps = STEP_BUDGET;
+			shared.frames = FRAME_BUDGET;
+			try {
+				const value = evaluator.evaluateMethod(method.owner, method.name, method.descriptor, registration.block, probe, true);
+				return value === null || probe.failure ? null : read(value);
+			} finally {
+				shared.probe = null;
+			}
+		}, `${method.name} override`);
+	};
 	const describe = (blockId) => {
 		const registration = registrationOf(blockId);
 		if (!registration) return `${blockId}: not registered`;
@@ -1756,6 +1842,7 @@ function extractBlockLight(roots, source) {
 		lightOf,
 		registrationOf,
 		tabulate,
+		tabulateMethod,
 		describe
 	};
 }

package/dist/{light-eval-DMjK6xnb.d.ts → light-eval-B4q-aVcf.d.ts}

@@ -1,5 +1,5 @@
 import { n as BlockProperties } from "./blockstate-eval-BzznRcVY.js";
-import { j as BlockPackLight } from "./block-behaviour-9Tj_GIUC.js";
+import { j as BlockPackLight } from "./block-behaviour-CzK3KVLx.js";
 //#region src/blocks/light-eval.d.ts
 /**
  * The light a block emits in the given state, 0–15.

package/dist/{link-Cuhyrz07.js → link-IDjVJ2Ij.js}

@@ -1,4 +1,4 @@
-import { t as parseClassFile } from "./classfile-CiIDF3vc.js";
+import { t as parseClassFile } from "./classfile-BJSs3JH0.js";
 //#region src/entities/link.ts
 /**
 * Which class holds a given entity's geometry.

package/dist/{model-bytecode-VaLUQfGO.js → model-bytecode-CXYAZ5dX.js}

@@ -1,4 +1,4 @@
-import { t as parseClassFile } from "./classfile-CiIDF3vc.js";
+import { t as parseClassFile } from "./classfile-BJSs3JH0.js";
 import { a as mergeModels, r as cubesOf, t as buildsOwnMesh } from "./merge-DeHruviG.js";
 //#region src/entities/model-bytecode.ts
 /**

package/dist/{model-code-Csc3bs3h.d.ts → model-code-BclYt1do.d.ts}

@@ -1,4 +1,4 @@
-import { t as ClassFile } from "./classfile-CsLXlh5z.js";
+import { t as ClassFile } from "./classfile-Dzn0gW9M.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/dist/{model-code-DbN2uVhp.js → model-code-BmA5ilgt.js}

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

package/dist/names-D1abAVIB.d.ts

@@ -0,0 +1,10 @@
+import { a as ResourceManager } from "./manager-Ct0dEOMg.js";
+//#region src/blocks/names.d.ts
+/** `names.json`: display names by id, one table per registry. */
+interface NamePack {
+  block: Record<string, string>;
+  item: Record<string, string>;
+}
+declare function collectNames(resources: ResourceManager, namespaces: readonly string[]): Promise<NamePack>;
+//#endregion
+export { collectNames as n, NamePack as t };

package/dist/names-GLa5TyL7.js

@@ -0,0 +1,36 @@
+import { n as ResourceLocator } from "./locator-COMEtEn9.js";
+//#region src/blocks/names.ts
+/**
+* Block and item display names, from each namespace's own `en_us` lang file.
+*
+* `block.minecraft.tnt` is "TNT" and `block.minecraft.short_grass` is "Short Grass" (before 1.20.3,
+* "Grass"): the version's own English, which a consumer would otherwise guess by title-casing an id.
+* Keys with more segments than `<kind>.<ns>.<name>` are a description or a variant's label, never an
+* id, and are left out.
+*/
+const NAME_KEY_SEGMENTS = 3;
+async function collectNames(resources, namespaces) {
+	const names = {
+		block: {},
+		item: {}
+	};
+	for (const namespace of namespaces) {
+		const raw = await resources.getResource("lang", new ResourceLocator(namespace, "en_us"));
+		if (!raw) continue;
+		let lang;
+		try {
+			lang = JSON.parse(raw.toString("utf8"));
+		} catch {
+			continue;
+		}
+		for (const [key, value] of Object.entries(lang)) {
+			const parts = key.split(".");
+			const [kind, keyNamespace, name] = parts;
+			if (parts.length !== NAME_KEY_SEGMENTS || keyNamespace !== namespace || typeof value !== "string") continue;
+			if (kind === "block" || kind === "item") names[kind][`${namespace}:${name}`] = value;
+		}
+	}
+	return names;
+}
+//#endregion
+export { collectNames as t };

package/dist/pack.d.ts

@@ -3,6 +3,6 @@ import { a as BlockStateMultipartCase, d as matchesCondition, n as BlockProperti
 import { t as GameRule } from "./game-rules-ThvdDG3B.js";
 import { n as ObjMesh, t as MeshGroup } from "./obj-mesh-CzL0lOlJ.js";
 import { n as BlockTintPack, t as BlockTint } from "./tints-DwFmEkf3.js";
-import { B as BlockPackTagsFile, C as BlockPackBlockState, F as BlockPackModelsFile, H as BlockPackVariant, I as BlockPackRenderLayer, L as BlockPackSprite, M as BlockPackLightFile, N as BlockPackMetaFile, O as BlockPackFace, P as BlockPackModel, R as BlockPackSpriteFrame, S as BlockPackBiomesFile, T as BlockPackElement, V as BlockPackTintsFile, b as BlockPackAtlasPage, j as BlockPackLight, k as BlockPackGameRulesFile, n as PushReactionName, t as BlockBehaviour, v as BlockPackAdvancementsFile, w as BlockPackBlockStatesFile, x as BlockPackBehaviourFile, y as BlockPackAtlasFile, z as BlockPackStatesFile } from "./block-behaviour-9Tj_GIUC.js";
-import { t as blockLightLevel } from "./light-eval-DMjK6xnb.js";
-export { type BiomeClimate, type BiomeClimatePack, type BlockBehaviour, type BlockModelVariant, type BlockPackAdvancementsFile, type BlockPackAtlasFile, type BlockPackAtlasPage, type BlockPackBehaviourFile, type BlockPackBiomesFile, type BlockPackBlockState, type BlockPackBlockStatesFile, type BlockPackElement, type BlockPackFace, type BlockPackGameRulesFile, type BlockPackLight, type BlockPackLightFile, type BlockPackMetaFile, type BlockPackModel, type BlockPackModelsFile, type BlockPackRenderLayer, type BlockPackSprite, type BlockPackSpriteFrame, type BlockPackStatesFile, type BlockPackTagsFile, type BlockPackTintsFile, type BlockPackVariant, type BlockProperties, type BlockStateDefinition, type BlockStateMultipartCase, type BlockStateVariantCase, type BlockTint, type BlockTintPack, type GameRule, type MeshGroup, type MultipartCondition, type ObjMesh, type PushReactionName, blockLightLevel, evaluateBlockState, matchesCondition, weightedVariantIndex };
+import { B as BlockPackStatesFile, C as BlockPackBlockState, F as BlockPackModelsFile, H as BlockPackTintsFile, I as BlockPackNamesFile, L as BlockPackRenderLayer, M as BlockPackLightFile, N as BlockPackMetaFile, O as BlockPackFace, P as BlockPackModel, R as BlockPackSprite, S as BlockPackBiomesFile, T as BlockPackElement, U as BlockPackVariant, V as BlockPackTagsFile, b as BlockPackAtlasPage, j as BlockPackLight, k as BlockPackGameRulesFile, n as PushReactionName, t as BlockBehaviour, v as BlockPackAdvancementsFile, w as BlockPackBlockStatesFile, x as BlockPackBehaviourFile, y as BlockPackAtlasFile, z as BlockPackSpriteFrame } from "./block-behaviour-CzK3KVLx.js";
+import { t as blockLightLevel } from "./light-eval-B4q-aVcf.js";
+export { type BiomeClimate, type BiomeClimatePack, type BlockBehaviour, type BlockModelVariant, type BlockPackAdvancementsFile, type BlockPackAtlasFile, type BlockPackAtlasPage, type BlockPackBehaviourFile, type BlockPackBiomesFile, type BlockPackBlockState, type BlockPackBlockStatesFile, type BlockPackElement, type BlockPackFace, type BlockPackGameRulesFile, type BlockPackLight, type BlockPackLightFile, type BlockPackMetaFile, type BlockPackModel, type BlockPackModelsFile, type BlockPackNamesFile, type BlockPackRenderLayer, type BlockPackSprite, type BlockPackSpriteFrame, type BlockPackStatesFile, type BlockPackTagsFile, type BlockPackTintsFile, type BlockPackVariant, type BlockProperties, type BlockStateDefinition, type BlockStateMultipartCase, type BlockStateVariantCase, type BlockTint, type BlockTintPack, type GameRule, type MeshGroup, type MultipartCondition, type ObjMesh, type PushReactionName, blockLightLevel, evaluateBlockState, matchesCondition, weightedVariantIndex };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nodecraft/rendermite",
-	"version": "1.9.0",
+	"version": "1.10.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",