@nodecraft/rendermite 1.7.4 → 1.8.0

package/dist/blocks/cli.js

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

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

@@ -1,5 +1,5 @@
 import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { f as BlockPackModel } from "../pack-format-Baoc_aSZ.js";
+import { m as BlockPackModel } from "../pack-format-BqWf-DNc.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-exOIcdyx.js";
 import { i as TextureLoader } from "../loader-59_eMa8e.js";
-import { S as EntityPackEntry } from "../pack-format-Baoc_aSZ.js";
+import { w as EntityPackEntry } from "../pack-format-BqWf-DNc.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-exOIcdyx.js";
-import { C as EntityPackModel, T as EquipmentPack } from "../pack-format-Baoc_aSZ.js";
+import { D as EquipmentPack, T as EntityPackModel } from "../pack-format-BqWf-DNc.js";
 import { t as ClassSource } from "../jar-classes-CSRrPAUy.js";
-import { t as Mappings } from "../mappings-DxX4KoZl.js";
-import { t as ModelCode } from "../model-code-BY44ao27.js";
+import { t as Mappings } from "../mappings-USwcjtcH.js";
+import { t as ModelCode } from "../model-code-Csc3bs3h.js";
 //#region src/blocks/entity-models.d.ts
 interface EntityGeometryResult {
   /** Model id (the class it came from) → geometry. */

package/dist/blocks/entity-models.js

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

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

package/dist/blocks/export.js

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

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

@@ -1,5 +1,5 @@
 import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { f as BlockPackModel } from "../pack-format-Baoc_aSZ.js";
+import { m as BlockPackModel } from "../pack-format-BqWf-DNc.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-exOIcdyx.js";
 import { i as TextureLoader } from "../loader-59_eMa8e.js";
 import { t as ModelLoader } from "../loader-DSir1-P0.js";
-import { D as ItemPackEntry } from "../pack-format-Baoc_aSZ.js";
+import { k as ItemPackEntry } from "../pack-format-BqWf-DNc.js";
 //#region src/blocks/item-sprites.d.ts
 interface ItemSpriteFailure {
   id: string;

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

@@ -0,0 +1,174 @@
+import { d as BlockPackLight } from "../pack-format-BqWf-DNc.js";
+import { t as ClassFile } from "../classfile-CsLXlh5z.js";
+//#region src/blocks/light-bytecode.d.ts
+/** A member reference as the constant pool spells it. */
+interface MemberReference {
+  owner: string;
+  name: string;
+  descriptor: string;
+}
+/** What the caller supplies: how to find code, and how to rename a reference before looking. */
+interface LightCodeSource {
+  /** The parsed class, or null for anything outside the jars (the JDK, a loader). */
+  resolve: (internalName: string) => ClassFile | null;
+  /**
+   * A reference as the jar spells it. A mod names the game's classes and members by their original
+   * names; against an obfuscated client those have to be renamed before they can be found.
+   */
+  remap: (reference: MemberReference, field: boolean) => MemberReference;
+  remapClass: (internalName: string) => string;
+  /** Classes that are a block `Properties` builder, in every spelling the jars use. */
+  propsClasses: ReadonlySet<string>;
+  /**
+   * Whether a class is the game's rather than a mod's. A mod export runs the game's own `Blocks` too,
+   * for the properties mods copy, and its registrations must not answer for a mod block that happens
+   * to share a name — `immersiveengineering:lantern` is not `minecraft:lantern`.
+   */
+  isVanillaClass: (internalName: string) => boolean;
+  /**
+   * Methods a block class may override to answer its own light: the game's `getLightValue(state)`
+   * before 1.16, when a lit furnace was an override rather than a lambda, and a loader's
+   * `getLightEmission(state, level, pos)`. `root` is the class whose implementation is the plain
+   * property read, so a call resolving there — `super.getLightValue(state)` — is answered from the
+   * block's `Properties`.
+   */
+  lightGetters: ReadonlyArray<LightGetter>;
+}
+interface LightGetter {
+  name: string;
+  /** Empty to match by name alone: a loader method whose parameter types the jar does not spell. */
+  descriptor: string;
+  root: string | null;
+}
+/** How a block's light is stated, before it is evaluated. */
+type LightSpec = {
+  kind: 'constant';
+  level: number;
+} |
+/** A `ToIntFunction<BlockState>`, to be run per state. */
+{
+  kind: 'function';
+  fn: LambdaValue;
+} |
+/** A block class's own light method: a 1.13–1.15 `getLightValue` override, or a loader's `getLightEmission`. */
+{
+  kind: 'method';
+  owner: string;
+  getter: LightGetter;
+  receiver: Handle | null;
+} |
+/** A light function the interpreter could not identify — one built from a value it never saw. */
+{
+  kind: 'opaque';
+  reason: string;
+};
+interface Handle {
+  id: number;
+  /** Internal class name, from `new` or the declared return type of the opaque call that made it. */
+  type: string | null;
+  /** Strings that flowed into this object: the name a registration key or a property was made from. */
+  strings: string[];
+  numbers: number[];
+  /** Class literals that flowed in: the value class of an enum property. */
+  classes: string[];
+  fields: Map<string, Value>;
+  isProps: boolean;
+  light: LightSpec | null;
+  /** For a block: the `Properties` it was constructed with. */
+  props: Handle | null;
+  ctorArgs: Value[] | null;
+  /** `StringBuilder` parts, for the pre-Java 9 way of building a name. */
+  builder?: Array<string | number>;
+  origin?: string;
+  /** Entries of a map the code filled, for a lookup table of properties by direction. */
+  map?: Array<{
+    key: Value;
+    value: Value;
+  }>;
+  /** Elements of a list or set the code filled, for a table of names a mod registers in a loop. */
+  items?: Value[];
+  /** An iterator over a list: what it walks and where it is. */
+  iterator?: {
+    items: Value[];
+    at: number;
+  };
+}
+interface LambdaValue {
+  kind: 'lambda';
+  owner: string;
+  name: string;
+  descriptor: string;
+  captured: Value[];
+}
+/** A `BlockState` during evaluation of a light function: a bag of property values being read. */
+interface StateProbe {
+  values: Map<string, string>;
+  domains: Map<string, PropertyDomain>;
+  reads: Set<string>;
+  failure: string | null;
+}
+interface PropertyDomain {
+  name: string;
+  values: string[];
+  /** The enum constant per serialized value, for a property whose values are an enum. */
+  constants?: Map<string, Handle>;
+}
+type Value = LambdaValue | {
+  kind: 'number';
+  value: number;
+  wide?: boolean;
+} | {
+  kind: 'string';
+  value: string;
+} | {
+  kind: 'object';
+  handle: Handle;
+} | {
+  kind: 'array';
+  items: Value[];
+} | {
+  kind: 'class';
+  name: string;
+} | {
+  kind: 'null';
+} | {
+  kind: 'state';
+  probe: StateProbe;
+} | {
+  kind: 'unknown';
+};
+/** One registration this found: which `Properties` a name was registered with, and the block if seen. */
+interface Registration {
+  props: Handle | null;
+  block: Handle | null;
+  /** The block's class, when a factory method reference named it. */
+  blockType: string | null;
+  /** The call that registered it, for a person chasing a wrong answer. */
+  site: string;
+  /** Made by the game's own code, which a mod's block of the same bare name must not inherit. */
+  vanilla: boolean;
+}
+/** What one run over a set of registry classes found. */
+interface LightExtraction {
+  registrations: Map<string, Registration>;
+  notes: string[];
+  /** The light a block emits, or why it could not be worked out. */
+  lightOf: (blockId: string) => {
+    light: BlockPackLight;
+  } | {
+    failure: string;
+  };
+  /** What was recorded for a block, for a person chasing a failure. */
+  describe: (blockId: string) => string;
+}
+/**
+ * Runs the registry code of a set of classes and answers, per block, what it emits.
+ *
+ * `roots` are the classes whose methods register blocks; every method of each is run, because where
+ * the registrations sit differs by era and mod — `<clinit>` for a modern registry, a static
+ * `registerBlocks()` in 1.13, an instance `init()` in a mod. The order is `<clinit>` first, since the
+ * others read what it set up.
+ */
+declare function extractBlockLight(roots: readonly ClassFile[], source: LightCodeSource): LightExtraction;
+//#endregion
+export { LightCodeSource, LightExtraction, LightGetter, LightSpec, MemberReference, PropertyDomain, Registration, StateProbe, extractBlockLight };

package/dist/blocks/light-bytecode.js

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

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

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

package/dist/blocks/light-eval.js

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

package/dist/blocks/light.d.ts

@@ -0,0 +1,38 @@
+import { d as BlockPackLight } from "../pack-format-BqWf-DNc.js";
+import { t as ClassSource } from "../jar-classes-CSRrPAUy.js";
+//#region src/blocks/light.d.ts
+interface CollectBlockLightOptions {
+  version: string;
+  /** Where mappings cache; the jar cache directory. */
+  cacheDir: string;
+  classes: ClassSource;
+  /** Every block the pack describes, fully qualified; each gets an answer or a failure. */
+  blockIds: readonly string[];
+  /** 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;
+}
+interface BlockLightResult {
+  /** Only the blocks that emit; absent is 0. */
+  light: Record<string, BlockPackLight>;
+  failures: Array<{
+    id: string;
+    reason: string;
+  }>;
+  /** What the interpreter gave up on along the way, for a person reading a failure. */
+  notes: string[];
+}
+declare function collectBlockLight(options: CollectBlockLightOptions): Promise<BlockLightResult>;
+/**
+ * Vanilla's emitters, transcribed from `Blocks.java` across 1.13 → 26.2 and checked against the wiki.
+ *
+ * By path, as a superset across versions: a block a version does not have never comes up in one of its
+ * worlds, and none of these levels has changed since the block was added. Cases are in the folded form
+ * the extractor emits — the commonest level as `default`, the rest as the fewest properties that
+ * decide them — so the two can be compared directly.
+ */
+declare const VANILLA_LIGHT: Record<string, BlockPackLight>;
+/** The vanilla table as it stood at a version: `VANILLA_LIGHT` with the history applied. */
+declare function vanillaLightAt(version: string): Record<string, BlockPackLight>;
+//#endregion
+export { BlockLightResult, CollectBlockLightOptions, VANILLA_LIGHT, collectBlockLight, vanillaLightAt };

package/dist/blocks/light.js

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

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

@@ -1,2 +1,2 @@
-import { C as EntityPackModel, D as ItemPackEntry, E as EquipmentSlot, O as ItemPackLayer, S as EntityPackEntry, T as EquipmentPack, _ as BlockPackTintsFile, a as BlockPackBlockStatesFile, b as EntityPackCube, c as BlockPackEntityModelsFile, d as BlockPackMetaFile, f as BlockPackModel, g as BlockPackSpriteFrame, h as BlockPackSprite, i as BlockPackBlockState, l as BlockPackFace, m as BlockPackRenderLayer, n as BlockPackAtlasPage, o as BlockPackElement, p as BlockPackModelsFile, r as BlockPackBiomesFile, s as BlockPackEntitiesFile, t as BlockPackAtlasFile, u as BlockPackItemsFile, v as BlockPackVariant, w as EntityPackPart, x as EntityPackCubeFace, y as EQUIPMENT_SLOTS } from "../pack-format-Baoc_aSZ.js";
-export { BlockPackAtlasFile, BlockPackAtlasPage, BlockPackBiomesFile, BlockPackBlockState, BlockPackBlockStatesFile, BlockPackElement, BlockPackEntitiesFile, BlockPackEntityModelsFile, BlockPackFace, BlockPackItemsFile, BlockPackMetaFile, BlockPackModel, BlockPackModelsFile, BlockPackRenderLayer, BlockPackSprite, BlockPackSpriteFrame, BlockPackTintsFile, BlockPackVariant, EQUIPMENT_SLOTS, EntityPackCube, EntityPackCubeFace, EntityPackEntry, EntityPackModel, EntityPackPart, EquipmentPack, EquipmentSlot, ItemPackEntry, ItemPackLayer };
+import { A as ItemPackLayer, C as EntityPackCubeFace, D as EquipmentPack, E as EntityPackPart, O as EquipmentSlot, S as EntityPackCube, T as EntityPackModel, _ as BlockPackSprite, a as BlockPackBlockStatesFile, b as BlockPackVariant, c as BlockPackEntityModelsFile, d as BlockPackLight, f as BlockPackLightFile, g as BlockPackRenderLayer, h as BlockPackModelsFile, i as BlockPackBlockState, k as ItemPackEntry, l as BlockPackFace, m as BlockPackModel, n as BlockPackAtlasPage, o as BlockPackElement, p as BlockPackMetaFile, r as BlockPackBiomesFile, s as BlockPackEntitiesFile, t as BlockPackAtlasFile, u as BlockPackItemsFile, v as BlockPackSpriteFrame, w as EntityPackEntry, x as EQUIPMENT_SLOTS, y as BlockPackTintsFile } from "../pack-format-BqWf-DNc.js";
+export { BlockPackAtlasFile, BlockPackAtlasPage, BlockPackBiomesFile, BlockPackBlockState, BlockPackBlockStatesFile, BlockPackElement, BlockPackEntitiesFile, BlockPackEntityModelsFile, BlockPackFace, BlockPackItemsFile, BlockPackLight, BlockPackLightFile, BlockPackMetaFile, BlockPackModel, BlockPackModelsFile, BlockPackRenderLayer, BlockPackSprite, BlockPackSpriteFrame, 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-59_eMa8e.js";
 import { i as PackedPage } from "../atlas-pack-C56gzqAg.js";
-import { h as BlockPackSprite, m as BlockPackRenderLayer } from "../pack-format-Baoc_aSZ.js";
+import { _ as BlockPackSprite, g as BlockPackRenderLayer } from "../pack-format-BqWf-DNc.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-Bo7FUrrD.js → classfile-CiIDF3vc.js}

@@ -272,6 +272,26 @@ function parseClassFile(bytes) {
 		}
 		return null;
 	};
+	const bootstrap = (index) => {
+		const entry = constants[index];
+		const row = entry?.bootstrapIndex === void 0 ? void 0 : bootstraps[entry.bootstrapIndex];
+		if (!row) return null;
+		const handle = constants[row.handleIndex];
+		return {
+			factory: handle?.tag === "methodHandle" && handle.referenceIndex !== void 0 ? reference(handle.referenceIndex) : null,
+			args: row.argumentIndexes.map((argument) => literal(argument))
+		};
+	};
+	const invokeDynamic = (index) => {
+		const entry = constants[index];
+		if (entry?.tag !== "invokeDynamic" || entry.nameAndTypeIndex === void 0) return null;
+		const nameAndType = constants[entry.nameAndTypeIndex];
+		if (!nameAndType?.nameIndex || !nameAndType.descriptorIndex) return null;
+		return {
+			name: utf8(nameAndType.nameIndex),
+			descriptor: utf8(nameAndType.descriptorIndex)
+		};
+	};
 	return {
 		thisClass,
 		superClass,
@@ -280,7 +300,9 @@ function parseClassFile(bytes) {
 		utf8,
 		reference,
 		literal,
-		lambdaTarget
+		lambdaTarget,
+		bootstrap,
+		invokeDynamic
 	};
 }
 //#endregion

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

@@ -61,6 +61,29 @@ interface ClassFile {
     name: string;
     descriptor: string;
   } | null;
+  /**
+   * An `invokedynamic`'s bootstrap row: the factory it calls and the constant arguments it was given.
+   *
+   * A lambda is one shape of this; string concatenation is another. `makeConcatWithConstants` takes
+   * a recipe string with a placeholder per operand, and a name built as `prefix + "_stairs"` is only
+   * recoverable by reading that recipe back.
+   */
+  bootstrap: (index: number) => {
+    factory: {
+      owner: string;
+      name: string;
+      descriptor: string;
+    } | null;
+    args: Array<string | number | bigint | null>;
+  } | null;
+  /**
+   * An `invokedynamic`'s own name and descriptor: what it pops (the values the lambda captured) and
+   * what it leaves. `reference` cannot answer for one, since the pool entry names no owner class.
+   */
+  invokeDynamic: (index: number) => {
+    name: string;
+    descriptor: string;
+  } | null;
 }
 declare function parseClassFile(bytes: Uint8Array): ClassFile;
 //#endregion

package/dist/{cli-DBNuCnry.js → cli-Dw1Q5CPR.js}

@@ -1,10 +1,10 @@
 import { n as builtinPackPath } from "./builtin-WkWjATeh.js";
 import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
-import { t as exportBlockPack } from "./export-Ds1EelMa.js";
-import { n as layeredClasses, t as JarClassReader } from "./jar-classes-3GVCJZT7.js";
-import { n as prepareModResources } from "./prepare-Myd_ec4v.js";
+import { a as prepareVersionResources, r as compareVersions } from "./prepare-C61BcwFA.js";
+import { t as exportBlockPack } from "./export-t8X_oRws.js";
+import { n as layeredClasses, t as JarClassReader } from "./jar-classes-CSm7qq1R.js";
+import { n as prepareModResources } from "./prepare-DxPEu9mo.js";
 import { t as downloadClientJar } from "./download-1wAfrGKx.js";
-import { a as prepareVersionResources, r as compareVersions } from "./prepare-D49Gu4Lv.js";
 import path from "node:path";
 import os from "node:os";
 import { parseArgs } from "node:util";
@@ -181,6 +181,7 @@ async function runBlocksCli(argv) {
 		console.log(result.items > 0 ? `${result.items} flat items described in items.json.` : "No flat item sprites exported.");
 		console.log(result.entities > 0 ? `${result.entities} entity types described in entities.json.` : "No entity types exported.");
 		console.log(result.entityModels > 0 ? `${result.entityModels} entity models recovered from the jar's own code.` : "No entity geometry recovered.");
+		console.log(result.light > 0 ? `${result.light} light-emitting blocks described in light.json.` : "No block light read; light.json not written.");
 		console.log(result.biomes > 0 ? `${result.biomes} biomes described in biomes.json.` : "No biomes to describe; biomes.json not written.");
 		console.log(`${result.failures.length} entries in failures.json.`);
 		return 0;

package/dist/cli.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { n as builtinPackPath, t as bedCompatPath } from "./builtin-WkWjATeh.js";
 import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
-import { t as JarResourceManager } from "./jar-W2cV2ZVO.js";
+import { t as JarResourceManager } from "./jar-CBYPMbw7.js";
+import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS } from "./prepare-C61BcwFA.js";
 import { t as curatedModelOverrides } from "./models-CZjCOjs4.js";
-import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-BspVCz2G.js";
+import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-CWQz6UkM.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-DBNuCnry.js";
-import { t as run } from "./run-Ctt_1iTd.js";
+import { t as runBlocksCli } from "./cli-Dw1Q5CPR.js";
+import { t as run } from "./run-DYcem_Vv.js";
 import path from "node:path";
 import os from "node:os";
 import { parseArgs } from "node:util";

package/dist/{descriptor-JyXhfd-c.js → descriptor-CmkIkDKL.js}

@@ -1,6 +1,6 @@
-import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
-import { t as JarResourceManager } from "./jar-W2cV2ZVO.js";
 import { n as MapResourceManager, t as KindFilteredResourceManager } from "./synthetic-rc9BPT4P.js";
+import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
+import { t as JarResourceManager } from "./jar-CBYPMbw7.js";
 //#region src/resources/descriptor.ts
 /**
 * Serializable descriptions of a resource tree, so the same layered tree can be

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

package/dist/entities/classfile.js

@@ -1,2 +1,2 @@
-import { t as parseClassFile } from "../classfile-Bo7FUrrD.js";
+import { t as parseClassFile } from "../classfile-CiIDF3vc.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-BdLIk4Pe.js";
-import { t as ModelCode } from "../model-code-BY44ao27.js";
+import { t as ClassFile } from "../classfile-CsLXlh5z.js";
+import { t as ModelCode } from "../model-code-Csc3bs3h.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-BYLi3Q28.js";
+import { n as extractInheritedModel, t as ancestryOf } from "../inherit-BUn0Cve9.js";
 export { ancestryOf, extractInheritedModel };

package/dist/entities/jar-classes.js

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

package/dist/entities/link.d.ts

@@ -1,5 +1,5 @@
-import { t as Mappings } from "../mappings-DxX4KoZl.js";
-import { t as ClassFile } from "../classfile-BdLIk4Pe.js";
+import { t as Mappings } from "../mappings-USwcjtcH.js";
+import { t as ClassFile } from "../classfile-CsLXlh5z.js";
 //#region src/entities/link.d.ts
 /**
  * Entity types whose renderer or model is not named after them. Values are class simple names to look

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-5GmBLTzk.js";
+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";
 export { NO_MODEL, RENDERER_ALIASES, buildModelNameIndex, classReader, linkEntityModel, normaliseModelName };

package/dist/entities/mappings.d.ts

@@ -1,2 +1,2 @@
-import { a as isObfuscated, c as resolveMappings, i as identityMappings, n as MappingsUnavailableError, o as loadMappings, r as downloadClientMappings, s as parseMappings, t as Mappings } from "../mappings-DxX4KoZl.js";
-export { Mappings, MappingsUnavailableError, downloadClientMappings, identityMappings, isObfuscated, loadMappings, parseMappings, resolveMappings };
+import { a as isObfuscated, c as remapDescriptor, i as identityMappings, l as resolveMappings, n as MappingsUnavailableError, o as loadMappings, r as downloadClientMappings, s as parseMappings, t as Mappings } from "../mappings-USwcjtcH.js";
+export { Mappings, MappingsUnavailableError, downloadClientMappings, identityMappings, isObfuscated, loadMappings, parseMappings, remapDescriptor, resolveMappings };

package/dist/entities/mappings.js

@@ -1,2 +1,2 @@
-import { a as loadMappings, i as isObfuscated, n as downloadClientMappings, o as parseMappings, r as identityMappings, s as resolveMappings, t as MappingsUnavailableError } from "../mappings-BEPVaiwE.js";
-export { MappingsUnavailableError, downloadClientMappings, identityMappings, isObfuscated, loadMappings, parseMappings, resolveMappings };
+import { a as loadMappings, c as resolveMappings, i as isObfuscated, n as downloadClientMappings, o as parseMappings, r as identityMappings, s as remapDescriptor, t as MappingsUnavailableError } from "../mappings-Ep6ko0rg.js";
+export { MappingsUnavailableError, downloadClientMappings, identityMappings, isObfuscated, loadMappings, parseMappings, remapDescriptor, resolveMappings };

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

@@ -1,6 +1,11 @@
 import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
-import { t as ClassFile } from "../classfile-BdLIk4Pe.js";
+import { t as ClassFile } from "../classfile-CsLXlh5z.js";
 //#region src/entities/model-bytecode.d.ts
+/** Argument slot count and shape of a descriptor's parameter list. */
+declare function parseDescriptor(descriptor: string): {
+  args: string[];
+  returns: string;
+};
 /**
  * Extracts whatever geometry a class's methods build.
  *
@@ -43,4 +48,4 @@ interface Following {
 declare function extractArmourMesh(bytes: Uint8Array, following: Following): ExtractedModel;
 declare function extractModel(bytes: Uint8Array, following?: Following): ExtractedModel;
 //#endregion
-export { Following, extractArmourMesh, extractModel };
+export { Following, extractArmourMesh, extractModel, parseDescriptor };

package/dist/entities/model-bytecode.js

@@ -1,2 +1,2 @@
-import { n as extractModel, t as extractArmourMesh } from "../model-bytecode-B43uSqet.js";
-export { extractArmourMesh, extractModel };
+import { n as extractModel, r as parseDescriptor, t as extractArmourMesh } from "../model-bytecode-VaLUQfGO.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-BY44ao27.js";
+import { n as isModelCode, r as loadModelCode, t as ModelCode } from "../model-code-Csc3bs3h.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-1Vuk-zj_.js";
+import { n as loadModelCode, t as isModelCode } from "../model-code-DbN2uVhp.js";
 export { isModelCode, loadModelCode };

package/dist/{entity-models-DUKiHpn1.js → entity-models-BGiy3pey.js}

@@ -1,11 +1,11 @@
 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-B43uSqet.js";
-import { n as extractInheritedModel, t as ancestryOf } from "./inherit-BYLi3Q28.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-1Vuk-zj_.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 { c as resolveMappings, t as MappingsUnavailableError } from "./mappings-Ep6ko0rg.js";
+import { n as loadModelCode } from "./model-code-DbN2uVhp.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

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

@@ -50,7 +50,7 @@ interface BlockPackFailure {
    * `intentional` is not a failure: it marks a block that is empty because the
    * game draws nothing for it. Filter it out to get the real gaps.
    */
-  kind: 'blockstate' | 'model' | 'texture' | 'sprite' | 'geometry' | 'tint' | 'biome' | 'item' | 'entity' | 'intentional';
+  kind: 'blockstate' | 'model' | 'texture' | 'sprite' | 'geometry' | 'tint' | 'biome' | 'item' | 'entity' | 'light' | 'intentional';
   reason: string;
 }
 interface BlockPackResult {
@@ -66,6 +66,8 @@ interface BlockPackResult {
   entities: number;
   /** Distinct entity models in `entity-models.json`; `0` means the file was not written. */
   entityModels: number;
+  /** Emitting blocks in `light.json`; `0` means the file was not written. */
+  light: number;
   /** Files actually written — the only trustworthy success signal. */
   writtenFiles: number;
   failures: BlockPackFailure[];