@nodecraft/rendermite 1.1.3 → 1.2.0

package/dist/blockstate-eval-Ckjlyxn4.js

@@ -0,0 +1,231 @@
+import { n as ResourceLocator } from "./locator-COMEtEn9.js";
+//#region src/blocks/blockstate-eval.ts
+/**
+* Real blockstate evaluation: given a block's actual property map, the models
+* the game would draw for it.
+*
+* `src/items/blockstate.ts` reads the same files but answers a different
+* question — "which variant looks most like a fresh block", so an item icon has
+* something to draw. A chunk renderer knows `facing=north,half=bottom` and needs
+* the model that key names, every model when several apply, and the whole
+* weighted list when the game would pick one at random.
+*
+* Everything here is parse-once: the string keys, the `a|b` alternates and the
+* `OR`/`AND` nesting are all resolved into structures, because the exported pack
+* is meant to leave the consumer nothing to resolve at runtime.
+*/
+var BlockStateError = class extends Error {};
+/** JSON writes booleans and numbers unquoted; blockstate keys write them as text. */
+function propertyValue(value) {
+	return typeof value === "string" ? value : String(value);
+}
+/**
+* The third rotation axis, which vanilla does not have. AE2 writes it as
+* `ae2:z`; the namespace is left open because a loader extension is a loader
+* extension whoever ships it, and only a numeric `z` key can match.
+*/
+function zRotation(entry) {
+	for (const [name, value] of Object.entries(entry)) if ((name === "z" || name.endsWith(":z")) && typeof value === "number") return value;
+	return 0;
+}
+/** Null for an explicit `weight: 0`, which the game can never pick. */
+function parseVariant(namespace, raw, context) {
+	if (typeof raw !== "object" || raw === null) throw new BlockStateError(`${context}: variant is not an object`);
+	const entry = raw;
+	if (typeof entry.model !== "string" || entry.model.length === 0) throw new BlockStateError(`${context}: variant states no model`);
+	const model = ResourceLocator.tryParse(entry.model, namespace);
+	if (model === null) throw new BlockStateError(`${context}: unparseable model ${entry.model}`);
+	const weight = typeof entry.weight === "number" ? entry.weight : 1;
+	if (!Number.isFinite(weight) || weight <= 0) return null;
+	return {
+		model: model.toString(),
+		x: typeof entry.x === "number" ? entry.x : 0,
+		y: typeof entry.y === "number" ? entry.y : 0,
+		z: zRotation(raw),
+		uvlock: entry.uvlock === true,
+		weight
+	};
+}
+function parseApply(namespace, raw, context) {
+	const entries = Array.isArray(raw) ? raw : [raw];
+	if (entries.length === 0) throw new BlockStateError(`${context}: empty variant list`);
+	const variants = entries.map((entry) => parseVariant(namespace, entry, context)).filter((variant) => variant !== null);
+	if (variants.length === 0) throw new BlockStateError(`${context}: every variant has weight 0`);
+	return variants;
+}
+/** `facing=north,half=bottom` → `{ facing: 'north', half: 'bottom' }`; `''` → `{}`. */
+function parseVariantKey(key, context) {
+	const when = {};
+	if (key.length === 0) return when;
+	for (const pair of key.split(",")) {
+		const separator = pair.indexOf("=");
+		if (separator <= 0) throw new BlockStateError(`${context}: variant key segment "${pair}" states no property; a bare key is the pre-1.13 format, below this exporter's floor`);
+		when[pair.slice(0, separator)] = pair.slice(separator + 1);
+	}
+	return when;
+}
+function parseCondition(raw, context) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new BlockStateError(`${context}: "when" is not an object`);
+	const terms = [];
+	const properties = {};
+	for (const [name, value] of Object.entries(raw)) {
+		if (name === "OR" || name === "AND") {
+			if (!Array.isArray(value)) throw new BlockStateError(`${context}: "${name}" is not an array`);
+			terms.push({
+				op: name === "OR" ? "or" : "and",
+				terms: value.map((entry) => parseCondition(entry, context))
+			});
+			continue;
+		}
+		properties[name] = propertyValue(value).split("|");
+	}
+	if (Object.keys(properties).length > 0) terms.push({
+		op: "match",
+		properties
+	});
+	if (terms.length === 0) throw new BlockStateError(`${context}: empty "when"`);
+	return terms.length === 1 ? terms[0] : {
+		op: "and",
+		terms
+	};
+}
+/**
+* NeoForge 1.21.6+ lets a mod register a blockstate *definition* loader the way
+* it can register a model loader, and the file then carries the loader's own
+* shape instead of variants. Only the fallback is recoverable from assets:
+* `base_model` is what the block looks like before whatever the loader does at
+* runtime — for FramedBlocks' 233 camouflage blocks, the uncamouflaged cube.
+*/
+function parseDefinitionLoader(namespace, json, context) {
+	const entries = json;
+	const loader = Object.entries(entries).find(([name]) => name === "definition_type" || name.endsWith(":definition_type"))?.[1];
+	if (typeof loader !== "string") return null;
+	const base = entries.base_model;
+	const model = typeof base === "string" ? base : base?.model;
+	if (typeof model !== "string") throw new BlockStateError(`${context}: definition loader ${loader} states no base_model`);
+	return {
+		kind: "variants",
+		cases: [{
+			when: {},
+			apply: parseApply(namespace, { model }, context)
+		}]
+	};
+}
+/** Parse the cases of one form, dropping unusable ones when tolerated. */
+function parseCases(entries, build, context, options) {
+	const cases = [];
+	for (const [key, value] of entries) try {
+		cases.push(build(key, value));
+	} catch (err) {
+		if (!options.onCaseError) throw err;
+		options.onCaseError(err.message);
+	}
+	if (cases.length === 0) throw new BlockStateError(`${context}: no usable cases`);
+	return cases;
+}
+/**
+* Parse a blockstate file. `namespace` is the block's own, which is what an
+* unqualified model reference resolves against.
+*/
+function parseBlockState(namespace, json, context = namespace, options = {}) {
+	if (typeof json !== "object" || json === null) throw new BlockStateError(`${context}: blockstate is not an object`);
+	const { variants, multipart } = json;
+	if (variants !== void 0 && multipart !== void 0) throw new BlockStateError(`${context}: states both variants and multipart`);
+	if (variants !== void 0) {
+		if (typeof variants !== "object" || variants === null || Array.isArray(variants)) throw new BlockStateError(`${context}: "variants" is not an object`);
+		const entries = Object.entries(variants);
+		if (entries.length === 0) throw new BlockStateError(`${context}: empty "variants"`);
+		return {
+			kind: "variants",
+			cases: parseCases(entries, (key, value) => {
+				return {
+					when: parseVariantKey(key, context),
+					apply: parseApply(namespace, value, `${context} [${key}]`)
+				};
+			}, context, options)
+		};
+	}
+	if (Array.isArray(multipart)) {
+		if (multipart.length === 0) throw new BlockStateError(`${context}: empty "multipart"`);
+		return {
+			kind: "multipart",
+			cases: parseCases(multipart.map((part, index) => [String(index), part]), (key, value) => {
+				const entry = value;
+				return {
+					when: entry.when === void 0 ? null : parseCondition(entry.when, `${context} [part ${key}]`),
+					apply: parseApply(namespace, entry.apply, `${context} [part ${key}]`)
+				};
+			}, context, options)
+		};
+	}
+	const viaLoader = parseDefinitionLoader(namespace, json, context);
+	if (viaLoader !== null) {
+		options.onNote?.("a loader defines this blockstate; exported as its base_model, which is what the block shows before the loader runs");
+		return viaLoader;
+	}
+	throw new BlockStateError(`${context}: states neither variants nor multipart`);
+}
+function matchesCondition(condition, properties) {
+	switch (condition.op) {
+		case "match": return Object.entries(condition.properties).every(([name, accepted]) => accepted.includes(properties[name]));
+		case "and": return condition.terms.every((term) => matchesCondition(term, properties));
+		case "or": return condition.terms.some((term) => matchesCondition(term, properties));
+	}
+}
+/**
+* The models the game draws for a block in this state, as one weighted list per
+* contributing part — a fence is several models at once, and each of them may
+* itself be a random pick. Empty when nothing matches, which is a real answer:
+* a blockstate that covers only some of a block's states draws nothing for the
+* rest.
+*/
+function evaluateBlockState(definition, properties) {
+	if (definition.kind === "multipart") return definition.cases.filter((part) => part.when === null || matchesCondition(part.when, properties)).map((part) => part.apply);
+	let best = null;
+	for (const variant of definition.cases) {
+		const entries = Object.entries(variant.when);
+		if (!entries.every(([name, value]) => properties[name] === value)) continue;
+		if (best === null || entries.length > Object.keys(best.when).length) best = variant;
+	}
+	return best === null ? [] : [best.apply];
+}
+/** Every model a blockstate can name, for deciding what to export. */
+function collectModels(definition) {
+	const models = /* @__PURE__ */ new Set();
+	for (const part of definition.cases) for (const variant of part.apply) models.add(variant.model);
+	return [...models];
+}
+const JAVA_MULTIPLIER = 25214903917n;
+const JAVA_MASK = (1n << 48n) - 1n;
+/**
+* Vanilla's per-position pick from a weighted variant list, so the consumer's
+* grass rotations land where the game puts them instead of somewhere merely
+* deterministic.
+*
+* This is `Mth.getSeed(x, y, z)` seeding a `java.util.Random`, then
+* `WeightedBakedModel`'s `abs((int) nextLong()) % totalWeight`. Both halves are
+* stable across 1.13–1.21.3; 1.21.4 reworked the model system and parity there
+* is unverified, which costs a variant rotation and nothing else.
+*/
+function weightedVariantIndex(weights, blockX, blockY, blockZ) {
+	if (weights.length <= 1) return 0;
+	const total = weights.reduce((sum, weight) => sum + weight, 0);
+	let seed = BigInt(blockX) * 3129871n ^ BigInt(blockZ) * 116129781n ^ BigInt(blockY);
+	seed = seed * seed * 42317861n + seed * 11n;
+	seed = BigInt.asIntN(64, seed) >> 16n;
+	let state = (BigInt.asUintN(64, seed) ^ JAVA_MULTIPLIER) & JAVA_MASK;
+	const next = () => {
+		state = state * JAVA_MULTIPLIER + 11n & JAVA_MASK;
+		return BigInt.asIntN(32, state >> 16n);
+	};
+	next();
+	const truncated = Number(next());
+	let remaining = (truncated === -2147483648 ? truncated : Math.abs(truncated)) % total;
+	for (const [index, weight] of weights.entries()) {
+		remaining -= weight;
+		if (remaining < 0) return index;
+	}
+	return weights.length - 1;
+}
+//#endregion
+export { parseBlockState as a, matchesCondition as i, collectModels as n, weightedVariantIndex as o, evaluateBlockState as r, BlockStateError as t };

package/dist/blockstate-eval-DDArZs1P.d.ts

@@ -0,0 +1,107 @@
+//#region src/blocks/blockstate-eval.d.ts
+/**
+ * Real blockstate evaluation: given a block's actual property map, the models
+ * the game would draw for it.
+ *
+ * `src/items/blockstate.ts` reads the same files but answers a different
+ * question — "which variant looks most like a fresh block", so an item icon has
+ * something to draw. A chunk renderer knows `facing=north,half=bottom` and needs
+ * the model that key names, every model when several apply, and the whole
+ * weighted list when the game would pick one at random.
+ *
+ * Everything here is parse-once: the string keys, the `a|b` alternates and the
+ * `OR`/`AND` nesting are all resolved into structures, because the exported pack
+ * is meant to leave the consumer nothing to resolve at runtime.
+ */
+/** A placed block's properties, stringified the way blockstate keys write them. */
+type BlockProperties = Readonly<Record<string, string>>;
+interface BlockModelVariant {
+  /** Fully-qualified model locator (`minecraft:block/oak_stairs`). */
+  model: string;
+  /** Blockstate rotation in degrees about X, applied to the baked model. */
+  x: number;
+  /** Blockstate rotation in degrees about Y. */
+  y: number;
+  /**
+   * Rotation about Z, applied after X and Y. Vanilla has no third axis; AE2
+   * adds one as `ae2:z` so a drive or charger can spin on the wall it faces.
+   */
+  z: number;
+  /** Hold UVs still while the model rotates. */
+  uvlock: boolean;
+  /** Relative weight within its list; the game picks one per block position. */
+  weight: number;
+}
+/** One entry of a `variants` map, with its `a=b,c=d` key already parsed. */
+interface BlockStateVariantCase {
+  /** Properties this case constrains; unstated ones are wildcards. */
+  when: Record<string, string>;
+  apply: BlockModelVariant[];
+}
+/**
+ * A `multipart` predicate. `match` holds one or more accepted values per
+ * property (the `a|b|c` form), and every property in it must match.
+ */
+type MultipartCondition = {
+  op: 'match';
+  properties: Record<string, string[]>;
+} | {
+  op: 'and';
+  terms: MultipartCondition[];
+} | {
+  op: 'or';
+  terms: MultipartCondition[];
+};
+interface BlockStateMultipartCase {
+  /** null for an unconditional part, which always applies. */
+  when: MultipartCondition | null;
+  apply: BlockModelVariant[];
+}
+type BlockStateDefinition = {
+  kind: 'variants';
+  cases: BlockStateVariantCase[];
+} | {
+  kind: 'multipart';
+  cases: BlockStateMultipartCase[];
+};
+declare class BlockStateError extends Error {}
+interface ParseBlockStateOptions {
+  /**
+   * Called instead of throwing when one case is unusable, so the rest of the
+   * block survives it. AE2's `crafting_monitor` states no model for
+   * `formed=true` because the game draws that state itself — without this,
+   * one such case takes all eleven others with it.
+   */
+  onCaseError?: (message: string) => void;
+  /** Called when the blockstate parsed, but not as the vanilla format. */
+  onNote?: (message: string) => void;
+}
+/**
+ * Parse a blockstate file. `namespace` is the block's own, which is what an
+ * unqualified model reference resolves against.
+ */
+declare function parseBlockState(namespace: string, json: unknown, context?: string, options?: ParseBlockStateOptions): BlockStateDefinition;
+declare function matchesCondition(condition: MultipartCondition, properties: BlockProperties): boolean;
+/**
+ * The models the game draws for a block in this state, as one weighted list per
+ * contributing part — a fence is several models at once, and each of them may
+ * itself be a random pick. Empty when nothing matches, which is a real answer:
+ * a blockstate that covers only some of a block's states draws nothing for the
+ * rest.
+ */
+declare function evaluateBlockState(definition: BlockStateDefinition, properties: BlockProperties): BlockModelVariant[][];
+/** Every model a blockstate can name, for deciding what to export. */
+declare function collectModels(definition: BlockStateDefinition): string[];
+/**
+ * Vanilla's per-position pick from a weighted variant list, so the consumer's
+ * grass rotations land where the game puts them instead of somewhere merely
+ * deterministic.
+ *
+ * This is `Mth.getSeed(x, y, z)` seeding a `java.util.Random`, then
+ * `WeightedBakedModel`'s `abs((int) nextLong()) % totalWeight`. Both halves are
+ * stable across 1.13–1.21.3; 1.21.4 reworked the model system and parity there
+ * is unverified, which costs a variant rotation and nothing else.
+ */
+declare function weightedVariantIndex(weights: readonly number[], blockX: number, blockY: number, blockZ: number): number;
+//#endregion
+export { BlockStateMultipartCase as a, ParseBlockStateOptions as c, matchesCondition as d, parseBlockState as f, BlockStateError as i, collectModels as l, BlockProperties as n, BlockStateVariantCase as o, weightedVariantIndex as p, BlockStateDefinition as r, MultipartCondition as s, BlockModelVariant as t, evaluateBlockState as u };

package/dist/cli-D7_oUuPT.js

@@ -0,0 +1,161 @@
+import { n as builtinPackPath } from "./builtin-WkWjATeh.js";
+import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-CYbAkWuT.js";
+import { t as exportBlockPack } from "./export-DxREy3qA.js";
+import { n as prepareModResources } from "./prepare-B8oPdGYz.js";
+import { t as downloadClientJar } from "./download-1wAfrGKx.js";
+import { a as prepareVersionResources, r as compareVersions } from "./prepare-C95vjt_o.js";
+import path from "node:path";
+import os from "node:os";
+import { parseArgs } from "node:util";
+//#region src/blocks/cli.ts
+/**
+* `rendermite blocks` — the block pack export, mirroring the icon CLI's input
+* handling (download a version's jar, or read asset folders, plus mod jars) but
+* emitting geometry and an atlas instead of icons.
+*/
+/** The Flattening: below it a block is `35:14` and needs a numeric-id table. */
+const MINIMUM_VERSION = "1.13";
+const HELP = `rendermite blocks — Minecraft block pack export (geometry + atlas, 1.13+)
+
+Usage:
+  rendermite blocks --version <mc version> --output <dir> [options]
+  rendermite blocks --assets <dir> [--assets <dir> ...] --output <dir> [options]
+
+Input:
+  -v, --version <ver>      download + prepare a vanilla version (1.13 … latest)
+  -a, --assets <dir>       asset root (repeatable, first wins), <namespace>/ children
+  -m, --mod <jar>          mod jar layered under vanilla (repeatable)
+
+Options:
+  -n, --namespace <ns>     namespace to export (repeatable, default: minecraft,
+                           or every mod namespace when --mod is given)
+  -o, --output <dir>       pack directory to write
+      --padding <px>       edge-extended sprite border (default 4)
+      --max-page-size <px> atlas page ceiling (default 4096)
+      --builtin <dir>      override the vendored geometry pack
+      --no-builtin         do not substitute geometry for code-drawn blocks
+      --cache-dir <dir>    jar download cache (default ~/.rendermite)
+`;
+/**
+* The sizes reach the packer directly, where a `NaN` classifies every sprite as
+* oversized and writes an empty atlas — worse than a crash, and only after the
+* jar download and a full export. Checked up front instead.
+*/
+function parseSizes(padding, maxPageSize) {
+	const errors = [];
+	const size = (raw, flag, minimum) => {
+		if (raw === void 0) return;
+		const value = Number(raw);
+		if (!Number.isSafeInteger(value) || value < minimum) {
+			errors.push(`--${flag} must be a whole number of at least ${minimum}; got "${raw}".`);
+			return;
+		}
+		return value;
+	};
+	return {
+		padding: size(padding, "padding", 0),
+		maxPageSize: size(maxPageSize, "max-page-size", 16),
+		errors
+	};
+}
+async function runBlocksCli(argv) {
+	const { values } = parseArgs({
+		args: argv,
+		options: {
+			"assets": {
+				type: "string",
+				short: "a",
+				multiple: true
+			},
+			"version": {
+				type: "string",
+				short: "v"
+			},
+			"mod": {
+				type: "string",
+				short: "m",
+				multiple: true
+			},
+			"namespace": {
+				type: "string",
+				short: "n",
+				multiple: true
+			},
+			"output": {
+				type: "string",
+				short: "o"
+			},
+			"padding": { type: "string" },
+			"max-page-size": { type: "string" },
+			"cache-dir": { type: "string" },
+			"builtin": { type: "string" },
+			"no-builtin": {
+				type: "boolean",
+				default: false
+			},
+			"help": {
+				type: "boolean",
+				short: "h",
+				default: false
+			}
+		}
+	});
+	if (values.help || !values.output || !(values.assets?.length || values.version)) {
+		console.log(HELP);
+		return values.help ? 0 : 1;
+	}
+	if (values.version && compareVersions(values.version, MINIMUM_VERSION) < 0) {
+		console.error(`Block packs start at ${MINIMUM_VERSION} (the Flattening); ${values.version} needs a numeric-id table that is out of scope.`);
+		return 1;
+	}
+	const sizes = parseSizes(values.padding, values["max-page-size"]);
+	if (sizes.errors.length > 0) {
+		for (const message of sizes.errors) console.error(message);
+		return 1;
+	}
+	const cacheDir = values["cache-dir"] ?? path.join(os.homedir(), ".rendermite");
+	let resources;
+	if (values.version) {
+		console.log(`Fetching client jar for ${values.version}…`);
+		resources = await prepareVersionResources({
+			version: values.version,
+			jar: await downloadClientJar(values.version, cacheDir)
+		});
+	} else {
+		const managers = (values.assets ?? []).map((root) => new FolderResourceManager(root));
+		resources = managers.length === 1 ? managers[0] : new LayeredResourceManager(managers);
+	}
+	let namespaces = values.namespace?.length ? values.namespace : ["minecraft"];
+	let closeMods = null;
+	if (values.mod?.length) {
+		const prepared = await prepareModResources({
+			jars: values.mod,
+			vanilla: resources
+		});
+		resources = prepared.resources;
+		closeMods = () => prepared.close();
+		for (const { jar, reason } of prepared.rejected) console.error(`Rejected mod jar ${jar}: ${reason}`);
+		namespaces = values.namespace?.length ? values.namespace : prepared.namespaces;
+	}
+	try {
+		const result = await exportBlockPack({
+			resources,
+			builtin: values["no-builtin"] ? void 0 : values.builtin ?? builtinPackPath("modern"),
+			output: values.output,
+			version: values.version ?? "custom",
+			namespaces,
+			padding: sizes.padding,
+			maxPageSize: sizes.maxPageSize,
+			onProgress: (stage, done, total) => {
+				if (done === total || done % 250 === 0) console.log(`${stage}: ${done}/${total}`);
+			}
+		});
+		console.log(`\n${result.blocks} blocks, ${result.models} models, ${result.sprites} sprites across ${result.pages} atlas page(s); ${result.writtenFiles} files written.`);
+		console.log(`${result.failures.length} entries in failures.json.`);
+		return 0;
+	} finally {
+		await closeMods?.();
+	}
+}
+//#endregion
+export { runBlocksCli as t };

package/dist/cli.js

@@ -1,12 +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-CkletR5K.js";
-import { t as curatedModelOverrides } from "./models-BKxGkPS7.js";
-import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-CebmvjmP.js";
-import { t as JarResourceManager } from "./jar-D9z-X7tA.js";
-import { t as run } from "./run-BPfpBZyZ.js";
-import { t as downloadClientJar } from "./download-D9aARBFp.js";
-import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS } from "./prepare-Cc8QZ3j0.js";
+import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-CYbAkWuT.js";
+import { t as curatedModelOverrides } from "./models-CQwcTZcg.js";
+import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-nxtGrqv5.js";
+import { t as JarResourceManager } from "./jar-5aLDI0nT.js";
+import { t as downloadClientJar } from "./download-1wAfrGKx.js";
+import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS } from "./prepare-C95vjt_o.js";
+import { t as runBlocksCli } from "./cli-D7_oUuPT.js";
+import { t as run } from "./run-D2S_W5As.js";
 import path from "node:path";
 import os from "node:os";
 import { parseArgs } from "node:util";
@@ -17,6 +18,7 @@ import { parseArgs } from "node:util";
 * (donor geometry, legacy reshaping, bed compat), and picks the right builtin
 * pack — one command from nothing to icons for any version back to 1.2.5.
 */
+if (process.argv[2] === "blocks") process.exit(await runBlocksCli(process.argv.slice(3)));
 const { values } = parseArgs({ options: {
 	"assets": {
 		type: "string",

package/dist/{descriptor-DWebtkI1.js → descriptor-BVIoEpPO.js}

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

package/dist/{discovery-B9aqV_Rz.js → discovery-CsZu08re.js}

@@ -1,4 +1,4 @@
-import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import { n as ResourceLocator } from "./locator-COMEtEn9.js";
 import { o as identity } from "./vector-CCxLae_T.js";
 import { n as InvalidItemDefinitionError, o as evaluateItemModel } from "./definition-ColsvWrH.js";
 //#region src/items/discovery.ts

package/dist/dynamic/generators.js

@@ -1,2 +1,2 @@
-import { a as builtinDynamicResources, i as TRIM_MATERIALS, n as POTTERY_SHERDS, r as TRIM_DARKER_MATERIALS, t as ARMOR_ITEM_TYPES } from "../generators-BlG4KmtP.js";
+import { a as builtinDynamicResources, i as TRIM_MATERIALS, n as POTTERY_SHERDS, r as TRIM_DARKER_MATERIALS, t as ARMOR_ITEM_TYPES } from "../generators-BCZVlWig.js";
 export { ARMOR_ITEM_TYPES, POTTERY_SHERDS, TRIM_DARKER_MATERIALS, TRIM_MATERIALS, builtinDynamicResources };