@nodecraft/rendermite 1.8.0 → 1.10.0

package/dist/{jar-CBYPMbw7.js → jar-DvofBm71.js}

@@ -1,6 +1,6 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
-import { r as ResourceKind } from "./manager-BNibYkmI.js";
-import { t as openZip } from "./zip-reader-zx3kdSq4.js";
+import { r as ResourceKind } from "./manager-D6zXmFrO.js";
+import { t as openZip } from "./zip-reader-onwEVMea.js";
 //#region src/resources/jar.ts
 /**
 * Reads resources directly out of a jar/zip — no extraction step, unlike the

package/dist/{jar-classes-CSm7qq1R.js → jar-classes-0wqWbTax.js}

@@ -1,5 +1,5 @@
-import { t as openZip } from "./zip-reader-zx3kdSq4.js";
-import { n as UnsafeJarError, r as isUnsafeEntryPath } from "./jar-CBYPMbw7.js";
+import { t as openZip } from "./zip-reader-onwEVMea.js";
+import { n as UnsafeJarError, r as isUnsafeEntryPath } from "./jar-DvofBm71.js";
 //#region src/entities/jar-classes.ts
 /**
 * Reading `.class` entries out of a jar.

package/dist/{light-CyRhYulM.js → light-CZRA1pOj.js}

@@ -1,7 +1,9 @@
-import { t as parseClassFile } from "./classfile-CiIDF3vc.js";
-import { c as resolveMappings, s as remapDescriptor, t as MappingsUnavailableError } from "./mappings-Ep6ko0rg.js";
-import { t as extractBlockLight } from "./light-bytecode-Cpyuxo9b.js";
-import { r as compareVersions } from "./prepare-C61BcwFA.js";
+import { r as compareVersions } from "./prepare-DkJkZXuQ.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-DVjqeSkv.js";
+import { i as overrideOf, n as constantFluidOf, t as alwaysInvisible } from "./block-overrides-XtxICunI.js";
+import { t as extractBlockLight } from "./light-bytecode-BqpQWqP7.js";
 //#region src/blocks/light.ts
 /**
 * Block light emission for the exported pack: `light.json`.
@@ -188,7 +190,7 @@ function findLightGetters(roots, propsClasses, resolve, notes) {
 	return getters;
 }
 /** Reference renaming through the mappings: a mod's original names onto an obfuscated client's. */
-function remapper(mappings) {
+function remapper(mappings, superOf = () => null) {
 	const remapClass = (internalName) => {
 		const mapped = mappings.obfuscatedOf.get(internalName.replaceAll("/", "."));
 		return mapped ? mapped.replaceAll(".", "/") : internalName;
@@ -204,9 +206,20 @@ function remapper(mappings) {
 			descriptor: remapDescriptor(reference.descriptor, mappings.obfuscatedOf)
 		};
 	};
+	const nameOf = (reference, field) => {
+		let owner = reference.owner;
+		for (let hops = 0; owner && hops < 8; hops++) {
+			const dotted = owner.replaceAll("/", ".");
+			const found = mappings.nameOf?.get(field ? `${dotted}.${reference.name}` : `${dotted}.${reference.name}${reference.descriptor}`);
+			if (found) return found;
+			owner = superOf(owner);
+		}
+		return reference.name;
+	};
 	return {
 		remap,
-		remapClass
+		remapClass,
+		nameOf
 	};
 }
 async function collectBlockLight(options) {
@@ -228,6 +241,7 @@ async function collectBlockLight(options) {
 		notes.push(err.message);
 	}
 	const { remap, remapClass } = remapper(mappings);
+	const isClearJar = names.some((name) => name.replaceAll(".", "/") === "net/minecraft/world/level/block/Blocks");
 	const bytes = /* @__PURE__ */ new Map();
 	for (const name of names) {
 		const read = await classes.read(name);
@@ -248,6 +262,7 @@ async function collectBlockLight(options) {
 		}
 		return parsed.get(internal) ?? null;
 	};
+	const { nameOf } = remapper(mappings, (name) => resolve(name)?.superClass ?? null);
 	const wanted = /* @__PURE__ */ new Set();
 	for (const id of blockIds) {
 		wanted.add(id);
@@ -275,7 +290,9 @@ async function collectBlockLight(options) {
 		});
 		return {
 			light: {},
+			behaviour: {},
 			failures,
+			behaviourFailures: [],
 			notes
 		};
 	}
@@ -284,6 +301,7 @@ async function collectBlockLight(options) {
 		resolve,
 		remap,
 		remapClass,
+		nameOf,
 		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/")
@@ -315,9 +333,33 @@ async function collectBlockLight(options) {
 			}
 		}
 	}
+	const behaviour = {};
+	const behaviourFailures = [];
+	if (mappings.originalOf.size > 0 || isClearJar) for (const id of blockIds) {
+		const registration = NOT_BLOCKS.has(id) ? null : extraction.registrationOf(id);
+		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({
+				id,
+				reason
+			});
+		}
+	}
 	return {
 		light,
+		behaviour,
 		failures,
+		behaviourFailures,
 		notes
 	};
 }

package/dist/{light-bytecode-Cpyuxo9b.js → light-bytecode-BqpQWqP7.js}

@@ -1,4 +1,6 @@
-import { r as parseDescriptor } from "./model-bytecode-VaLUQfGO.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.
@@ -294,6 +296,7 @@ var Interpreter = class Interpreter {
 				if (sources.length > 0) {
 					const from = sources[0].handle;
 					created.light = from.isProps ? from.light : from.props?.light ?? null;
+					created.copyOf = from.isProps ? from : from.props;
 				} else if (inputs.some((value) => value.kind === "unknown" || value.kind === "null")) created.light = {
 					kind: "opaque",
 					reason: "properties copied from a block the interpreter could not identify"
@@ -424,6 +427,25 @@ 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";
 	}
+	/**
+	* 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);
@@ -439,8 +461,9 @@ var Interpreter = class Interpreter {
 		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;
 			const made = this.invokeLambda(arg, []);
@@ -458,7 +481,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
@@ -848,6 +873,14 @@ var Interpreter = class Interpreter {
 		}
 		if (receiver?.kind === "object") {
 			const target = receiver.handle;
+			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);
+					return;
+				}
+			}
 			const getter = source.lightGetters.find((candidate) => matchesGetter(candidate, remapped.name, remapped.descriptor));
 			if (getter && target.props && args[0]?.kind === "state") {
 				const found = findGetter(source, target.type ?? remapped.owner, getter);
@@ -892,6 +925,12 @@ var Interpreter = class Interpreter {
 					return;
 				}
 				if (returns.startsWith("L") && this.isPropsType(returns.slice(1, -1))) {
+					const name = source.nameOf?.(reference, false) ?? remapped.name;
+					(target.calls ??= []).push({
+						name: name === reference.name ? remapped.name : name,
+						descriptor: remapped.descriptor,
+						args
+					});
 					this.push(receiver);
 					return;
 				}
@@ -1407,6 +1446,8 @@ var Interpreter = class Interpreter {
 					const reference = constants.reference(index);
 					if (target.kind === "object" && reference) {
 						target.handle.fields.set(reference.name, value);
+						const mapped = this.shared.source.nameOf?.(reference, true) ?? reference.name;
+						if (mapped !== reference.name) target.handle.fields.set(`mapped:${mapped}`, value);
 						if (value.kind === "object" && value.handle.isProps) target.handle.props = value.handle;
 					}
 					break;
@@ -1547,6 +1588,42 @@ var Interpreter = class Interpreter {
 			this.note(`${classFile.thisClass}: ${err.message}`);
 		}
 	}
+	/** Runs a function of a block state against one state; null where the interpreter lost the value. */
+	evaluateLambda(fn, probe) {
+		this.shared.probe = probe;
+		this.shared.steps = STEP_BUDGET;
+		this.shared.frames = FRAME_BUDGET;
+		try {
+			const result = this.invokeLambda(fn, [{
+				kind: "state",
+				probe
+			}]);
+			return probe.failure ? null : result;
+		} finally {
+			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;
@@ -1559,20 +1636,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 {
@@ -1646,6 +1711,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: [],
@@ -1700,37 +1766,30 @@ function extractBlockLight(roots, source) {
 		}
 		if (spec.kind === "constant") return { light: Math.max(0, Math.min(15, Math.round(spec.level))) };
 		if (spec.kind === "opaque") return { failure: `light could not be read: ${spec.reason}` };
-		const domains = /* @__PURE__ */ new Map();
-		let properties = [];
 		const evaluator = new Interpreter(shared);
-		for (let rounds = 0; rounds < 8; rounds++) {
-			const table = [];
-			const discovered = /* @__PURE__ */ new Set();
-			const assignments = combinations(properties.map((name) => domains.get(name)));
-			if (assignments.length > MAX_STATES) return { failure: `light function depends on ${assignments.length} states; too many to be a real block` };
-			for (const values of assignments) {
-				const probe = {
-					values,
-					domains,
-					reads: /* @__PURE__ */ new Set(),
-					failure: null
-				};
-				const before = shared.notes.length;
-				const level = evaluator.evaluate(spec, probe);
-				if (level === null) {
-					const detail = shared.notes.slice(before).join("; ");
-					return { failure: `light function ${probe.failure ?? "did not return a number"}${detail ? ` (${detail})` : ""}` };
-				}
-				table.push({
-					values,
-					level
-				});
-				for (const read of probe.reads) if (!properties.includes(read)) discovered.add(read);
+		const folded = tabulateStates(shared, (probe) => evaluator.evaluate(spec, probe), "light function");
+		return "failure" in folded ? folded : { light: folded.value };
+	};
+	const tabulate = (fn, read) => {
+		const evaluator = new Interpreter(shared);
+		return tabulateStates(shared, (probe) => {
+			const value = evaluator.evaluateLambda(fn, probe);
+			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;
 			}
-			if (discovered.size === 0) return { light: foldCases(table, properties) };
-			properties = [...properties, ...discovered];
-		}
-		return { failure: "light function reads more properties than a blockstate can have" };
+		}, `${method.name} override`);
 	};
 	const describe = (blockId) => {
 		const registration = registrationOf(blockId);
@@ -1742,8 +1801,47 @@ function extractBlockLight(roots, source) {
 		registrations: shared.registrations,
 		notes: shared.notes,
 		lightOf,
+		registrationOf,
+		tabulate,
+		tabulateMethod,
 		describe
 	};
 }
+/**
+* Runs `evaluate` over every combination of the properties it turns out to read, discovering them as
+* it goes: the first round runs with none, and each round adds whatever the last one read.
+*/
+function tabulateStates(shared, evaluate, what) {
+	const domains = /* @__PURE__ */ new Map();
+	let properties = [];
+	for (let rounds = 0; rounds < 8; rounds++) {
+		const table = [];
+		const discovered = /* @__PURE__ */ new Set();
+		const assignments = combinations(properties.map((name) => domains.get(name)));
+		if (assignments.length > MAX_STATES) return { failure: `${what} depends on ${assignments.length} states; too many to be a real block` };
+		for (const values of assignments) {
+			const probe = {
+				values,
+				domains,
+				reads: /* @__PURE__ */ new Set(),
+				failure: null
+			};
+			const before = shared.notes.length;
+			const level = evaluate(probe);
+			if (level === null) {
+				const detail = shared.notes.slice(before).join("; ");
+				return { failure: `${what} ${probe.failure ?? "did not return a number"}${detail ? ` (${detail})` : ""}` };
+			}
+			table.push({
+				values,
+				level
+			});
+			for (const read of probe.reads) if (!properties.includes(read)) discovered.add(read);
+		}
+		if (discovered.size === 0) return { value: foldCases(table, properties) };
+		properties = [...properties, ...discovered];
+	}
+	return { failure: `${what} reads more properties than a blockstate can have` };
+}
 //#endregion
 export { extractBlockLight as t };

package/dist/{light-eval-D9x0ufZx.d.ts → light-eval-C0-kt0bp.d.ts}

@@ -1,5 +1,5 @@
 import { n as BlockProperties } from "./blockstate-eval-BzznRcVY.js";
-import { d as BlockPackLight } from "./pack-format-BqWf-DNc.js";
+import { j as BlockPackLight } from "./block-behaviour-BBslelpW.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/{loader-DSir1-P0.d.ts → loader-BYyPIs9f.d.ts}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
-import { a as ResourceManager } from "./manager-exOIcdyx.js";
+import { a as ResourceManager } from "./manager-Ct0dEOMg.js";
 import { c as ModelJson, n as DisplayTransformJson, o as ModelElementJson, t as DisplayPosition } from "./types-qlp3I8_-.js";
 //#region src/models/loader.d.ts
 /**

package/dist/{loader-59_eMa8e.d.ts → loader-C4gsX_wO.d.ts}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
-import { a as ResourceManager } from "./manager-exOIcdyx.js";
+import { a as ResourceManager } from "./manager-Ct0dEOMg.js";
 //#region src/textures/loader.d.ts
 /** Structural interface for atlas resolvers (avoids a circular module edge). */
 interface AtlasResolverLike {

package/dist/{manager-exOIcdyx.d.ts → manager-Ct0dEOMg.d.ts}

@@ -81,6 +81,12 @@ declare const ResourceKind: {
     readonly directory: "worldgen/biome";
     readonly extension: ".json";
   };
+  /** Any datapack JSON under data/<ns>/: tags, advancements, whatever the version ships as data. */
+  readonly data: {
+    readonly root: "data";
+    readonly directory: "";
+    readonly extension: ".json";
+  };
 };
 type ResourceKindName = keyof typeof ResourceKind;
 interface ResourceManager {

package/dist/{manager-BNibYkmI.js → manager-D6zXmFrO.js}

@@ -58,6 +58,12 @@ const ResourceKind = {
 		root: "data",
 		directory: "worldgen/biome",
 		extension: ".json"
+	},
+	/** Any datapack JSON under data/<ns>/: tags, advancements, whatever the version ships as data. */
+	data: {
+		root: "data",
+		directory: "",
+		extension: ".json"
 	}
 };
 /**

package/dist/{mappings-Ep6ko0rg.js → mappings-DEl_7xxQ.js}

@@ -106,6 +106,8 @@ function parseMappings(text) {
 	const originalOf = /* @__PURE__ */ new Map();
 	const fieldOf = /* @__PURE__ */ new Map();
 	const methodOf = /* @__PURE__ */ new Map();
+	const methods = [];
+	const fields = [];
 	let owner = "";
 	for (const line of text.split("\n")) {
 		if (line.length === 0 || line.startsWith("#")) continue;
@@ -129,18 +131,33 @@ function parseMappings(text) {
 		const open = signature.indexOf("(");
 		if (open === -1) {
 			fieldOf.set(`${owner}.${signature}`, obfuscated);
+			fields.push({
+				owner,
+				name: signature,
+				obfuscated
+			});
 			continue;
 		}
 		const name = signature.slice(0, open);
 		const params = signature.slice(open + 1, -1);
 		const descriptor = `(${params.length === 0 ? "" : params.split(",").map((param) => typeDescriptor(param.trim())).join("")})${typeDescriptor(returnType)}`;
 		methodOf.set(`${owner}.${name}${descriptor}`, obfuscated);
+		methods.push({
+			owner,
+			name,
+			descriptor,
+			obfuscated
+		});
 	}
+	const nameOf = /* @__PURE__ */ new Map();
+	for (const field of fields) nameOf.set(`${obfuscatedOf.get(field.owner)}.${field.obfuscated}`, field.name);
+	for (const method of methods) nameOf.set(`${obfuscatedOf.get(method.owner)}.${method.obfuscated}${remapDescriptor(method.descriptor, obfuscatedOf)}`, method.name);
 	return {
 		obfuscatedOf,
 		originalOf,
 		fieldOf,
-		methodOf
+		methodOf,
+		nameOf
 	};
 }
 async function loadMappings(version, cacheDir) {

package/dist/{mappings-USwcjtcH.d.ts → mappings-DhOPQTgV.d.ts}

@@ -40,6 +40,11 @@ interface Mappings {
    */
   fieldOf: Map<string, string>;
   methodOf: Map<string, string>;
+  /**
+   * The other way: a member as the obfuscated client spells it (`eea$d.a(FF)Leea$d;`) to its original
+   * name (`strength`), for reading what the game's own code calls. Absent for an identity mapping.
+   */
+  nameOf?: Map<string, string>;
 }
 /**
  * A descriptor with every class in it renamed through the map: `(Lnet/minecraft/…/Block;)V` on an

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/models/loader.d.ts

@@ -1,2 +1,2 @@
-import { a as resolveTexture, i as flattenLoaderModel, n as ModelResolutionError, o as salvageJson, r as ResolvedModel, t as ModelLoader } from "../loader-DSir1-P0.js";
+import { a as resolveTexture, i as flattenLoaderModel, n as ModelResolutionError, o as salvageJson, r as ResolvedModel, t as ModelLoader } from "../loader-BYyPIs9f.js";
 export { ModelLoader, ModelResolutionError, ResolvedModel, flattenLoaderModel, resolveTexture, salvageJson };

package/dist/{models-CZjCOjs4.js → models-BsYA-NZg.js}

@@ -1,5 +1,5 @@
 import { r as modModelPackPath } from "./builtin-WkWjATeh.js";
-import { t as FolderResourceManager } from "./manager-BNibYkmI.js";
+import { t as FolderResourceManager } from "./manager-D6zXmFrO.js";
 //#region src/mods/models.ts
 /**
 * Geometry for mod items the game draws in code. A `builtin/entity` item model

package/dist/mods/models.d.ts

@@ -1,4 +1,4 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
 //#region src/mods/models.d.ts
 declare function curatedModelOverrides(): ResourceManager;
 //#endregion

package/dist/mods/models.js

@@ -1,2 +1,2 @@
-import { t as curatedModelOverrides } from "../models-CZjCOjs4.js";
+import { t as curatedModelOverrides } from "../models-BsYA-NZg.js";
 export { curatedModelOverrides };

package/dist/mods/prepare.d.ts

@@ -1,2 +1,2 @@
-import { i as prepareModResources, n as ModPreparation, r as PrepareModsOptions, t as LOADER_NAMESPACES } from "../prepare-OS7wL3jv.js";
+import { i as prepareModResources, n as ModPreparation, r as PrepareModsOptions, t as LOADER_NAMESPACES } from "../prepare-BPzsZI_S.js";
 export { LOADER_NAMESPACES, ModPreparation, PrepareModsOptions, prepareModResources };

package/dist/mods/prepare.js

@@ -1,2 +1,2 @@
-import { n as prepareModResources, t as LOADER_NAMESPACES } from "../prepare-DxPEu9mo.js";
+import { n as prepareModResources, t as LOADER_NAMESPACES } from "../prepare-sj36BP90.js";
 export { LOADER_NAMESPACES, prepareModResources };

package/dist/mods/synthesize.d.ts

@@ -1,5 +1,5 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { n as MapResourceManager } from "../synthetic-B3R7mW9k.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
+import { n as MapResourceManager } from "../synthetic-CWtFtAkR.js";
 //#region src/mods/synthesize.d.ts
 interface SynthesisResult {
   models: MapResourceManager;

package/dist/mods/tints.d.ts

@@ -1,5 +1,5 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { n as MapResourceManager } from "../synthetic-B3R7mW9k.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
+import { n as MapResourceManager } from "../synthetic-CWtFtAkR.js";
 //#region src/mods/tints.d.ts
 interface HarvestTintsOptions {
   /** Assets from 1.21.4+ releases of the same mods, read only for their tints. */

package/dist/mods/tints.js

@@ -1,2 +1,2 @@
-import { n as harvestTintOverrides, t as curatedTintOverrides } from "../tints-CWQz6UkM.js";
+import { n as harvestTintOverrides, t as curatedTintOverrides } from "../tints-CZeyKzMv.js";
 export { curatedTintOverrides, harvestTintOverrides };

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