@nodecraft/rendermite 0.0.1 → 1.0.0

package/dist/loader-lCkMRDH4.d.ts

@@ -0,0 +1,69 @@
+import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
+import { a as ResourceManager } from "./manager-CoZaeQTu.js";
+import { c as ModelJson, n as DisplayTransformJson, o as ModelElementJson, t as DisplayPosition } from "./types-COGbtA1t.js";
+//#region src/models/loader.d.ts
+/**
+ * A model with its parent chain flattened: textures merged child-over-parent,
+ * elements taken from the deepest model that defines any, display transforms
+ * merged per position.
+ */
+interface ResolvedModel {
+  locator: ResourceLocator;
+  /** `builtin/generated` etc. — the terminal builtin parent, when the chain ends in one. */
+  builtinParent: string | null;
+  guiLight: 'front' | 'side';
+  /**
+   * The gui_light in effect when `elements` were defined in the chain — upstream
+   * elements capture their light source at construction, so a descendant that
+   * overrides gui_light without redefining elements does not relight them.
+   */
+  elementsGuiLight: 'front' | 'side';
+  display: Partial<Record<DisplayPosition, DisplayTransformJson>>;
+  /** Texture variables fully merged (values may still be `#refs` until resolveTexture). */
+  textures: Record<string, string>;
+  elements: ModelElementJson[];
+  /** Deepest-first chain of model locators, for diagnostics. */
+  chain: string[];
+  /** Forge/NeoForge OBJ loader geometry reference, when the chain declares one. */
+  obj?: {
+    model: string;
+    flipV: boolean;
+  };
+  /** Fluid id from a fluid_container loader, for painting bucket contents. */
+  fluid?: string;
+}
+declare class ModelResolutionError extends Error {}
+/**
+ * Rewrite custom-loader models (forge/neoforge `loader` key) into drawable
+ * geometry. Left unhandled they fall back to a textureless parent and render
+ * as black squares — worse than failing, since the item still counts as having
+ * an icon (1,793 such icons in the old pipeline's modded run). Resolution
+ * order mirrors what each loader actually draws: the gui perspective IS the
+ * icon view; composite children draw first-to-last; fluid containers' real
+ * parent is loader-provided with no file behind it. OBJ loaders are left
+ * alone — their geometry is a different file format.
+ */
+declare function flattenLoaderModel(json: ModelJson, depth?: number): ModelJson;
+/**
+ * Return the first complete JSON value in a string, tolerating trailing junk the way
+ * Gson does (IntegratedDynamics ships models with garbage after the closing brace).
+ * Returns null when no complete value exists.
+ */
+declare function salvageJson(text: string): unknown | null;
+declare class ModelLoader {
+  private readonly resources;
+  private readonly cache;
+  constructor(resources: ResourceManager);
+  private readModelJson;
+  private resolve;
+  /** Load and flatten a model by locator string (e.g. `minecraft:item/stone`). */
+  load(locator: string | ResourceLocator): Promise<ResolvedModel>;
+}
+/**
+ * Resolve a texture variable (`#layer0`) through the merged texture map to a locator.
+ * Returns null for unresolved variables — the caller decides whether that fails the
+ * item or just the face.
+ */
+declare function resolveTexture(model: ResolvedModel, reference: string): ResourceLocator | null;
+//#endregion
+export { resolveTexture as a, flattenLoaderModel as i, ModelResolutionError as n, salvageJson as o, ResolvedModel as r, ModelLoader as t };

package/dist/locator-jDbdUeTd.d.ts

@@ -0,0 +1,24 @@
+//#region src/resources/locator.d.ts
+/**
+ * A Minecraft resource locator (`namespace:path`, e.g. `minecraft:item/stone`).
+ *
+ * Mirrors vanilla semantics: the namespace defaults to `minecraft` when omitted, and both
+ * halves are restricted to the character sets the game itself enforces. Mods regularly ship
+ * ids the game would reject (uppercase, spaces); we normalize case rather than fail, because
+ * a rejected id means a missing icon for an item that renders fine in game.
+ */
+declare class InvalidResourceLocatorError extends Error {}
+declare class ResourceLocator {
+  static parse(locator: string, defaultNamespace?: string): ResourceLocator;
+  /** Parse, returning null instead of throwing for ids too malformed to normalize. */
+  static tryParse(locator: string, defaultNamespace?: string): ResourceLocator | null;
+  readonly namespace: string;
+  readonly path: string;
+  constructor(namespace: string, path: string);
+  toString(): string;
+  equals(other: ResourceLocator): boolean;
+  /** New locator with the path prefixed (e.g. `prefix('models') + '.json'` for disk lookup). */
+  withPath(path: string): ResourceLocator;
+}
+//#endregion
+export { ResourceLocator as n, InvalidResourceLocatorError as t };

package/dist/locator-ycZzh_6z.js

@@ -0,0 +1,54 @@
+//#region src/resources/locator.ts
+/**
+* A Minecraft resource locator (`namespace:path`, e.g. `minecraft:item/stone`).
+*
+* Mirrors vanilla semantics: the namespace defaults to `minecraft` when omitted, and both
+* halves are restricted to the character sets the game itself enforces. Mods regularly ship
+* ids the game would reject (uppercase, spaces); we normalize case rather than fail, because
+* a rejected id means a missing icon for an item that renders fine in game.
+*/
+const NAMESPACE_PATTERN = /^[\d._a-z-]+$/;
+const PATH_PATTERN = /^[\d./_a-z-]+$/;
+var InvalidResourceLocatorError = class extends Error {};
+var ResourceLocator = class ResourceLocator {
+	static parse(locator, defaultNamespace = "minecraft") {
+		const colon = locator.indexOf(":");
+		let namespace = defaultNamespace;
+		let path = locator;
+		if (colon !== -1) {
+			namespace = locator.slice(0, colon) || defaultNamespace;
+			path = locator.slice(colon + 1);
+		}
+		namespace = namespace.trim().toLowerCase();
+		path = path.trim().toLowerCase();
+		if (!NAMESPACE_PATTERN.test(namespace)) throw new InvalidResourceLocatorError(`Invalid namespace in resource locator: ${locator}`);
+		if (!PATH_PATTERN.test(path)) throw new InvalidResourceLocatorError(`Invalid path in resource locator: ${locator}`);
+		return new ResourceLocator(namespace, path);
+	}
+	/** Parse, returning null instead of throwing for ids too malformed to normalize. */
+	static tryParse(locator, defaultNamespace = "minecraft") {
+		try {
+			return this.parse(locator, defaultNamespace);
+		} catch {
+			return null;
+		}
+	}
+	namespace;
+	path;
+	constructor(namespace, path) {
+		this.namespace = namespace;
+		this.path = path;
+	}
+	toString() {
+		return `${this.namespace}:${this.path}`;
+	}
+	equals(other) {
+		return this.namespace === other.namespace && this.path === other.path;
+	}
+	/** New locator with the path prefixed (e.g. `prefix('models') + '.json'` for disk lookup). */
+	withPath(path) {
+		return new ResourceLocator(this.namespace, path);
+	}
+};
+//#endregion
+export { ResourceLocator as n, InvalidResourceLocatorError as t };

package/dist/manager-CoZaeQTu.d.ts

@@ -0,0 +1,88 @@
+import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
+//#region src/resources/manager.d.ts
+/**
+ * A category of resource inside a pack, mapping to a directory under
+ * `assets/<namespace>/` plus a file extension.
+ */
+declare const ResourceKind: {
+  readonly model: {
+    readonly directory: "models";
+    readonly extension: ".json";
+  };
+  readonly itemDefinition: {
+    readonly directory: "items";
+    readonly extension: ".json";
+  };
+  readonly blockstate: {
+    readonly directory: "blockstates";
+    readonly extension: ".json";
+  };
+  readonly texture: {
+    readonly directory: "textures";
+    readonly extension: ".png";
+  };
+  readonly textureMeta: {
+    readonly directory: "textures";
+    readonly extension: ".png.mcmeta";
+  };
+  readonly atlas: {
+    readonly directory: "atlases";
+    readonly extension: ".json";
+  };
+  readonly lang: {
+    readonly directory: "lang";
+    readonly extension: ".json";
+  };
+  /** Arbitrary file under assets/<ns>/ (OBJ geometry, MTL material libraries). */
+  readonly raw: {
+    readonly directory: "";
+    readonly extension: "";
+  };
+};
+type ResourceKindName = keyof typeof ResourceKind;
+interface ResourceManager {
+  /** Raw bytes for a resource, or null when this manager does not have it. */
+  getResource(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer | null>;
+  /**
+   * Every copy of a resource across layers, highest precedence first. Most
+   * resources shadow, but atlas definitions merge across packs in the game —
+   * reading only the winning file drops the shadowed pack's sources.
+   */
+  getAllResources(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer[]>;
+  /** Whether this manager has the resource without reading it. */
+  hasResource(kind: ResourceKindName, locator: ResourceLocator): Promise<boolean>;
+  /** All resource paths of a kind within a namespace (locator paths, no extension). */
+  listResources(kind: ResourceKindName, namespace: string): Promise<ResourceLocator[]>;
+  /** All namespaces this manager provides. */
+  listNamespaces(): Promise<string[]>;
+}
+/**
+ * Reads a resource pack laid out on disk. Accepts both layouts in the wild:
+ * `<root>/assets/<ns>/…` (an extracted jar/pack) and `<root>/<ns>/…`
+ * (what renderchest's --assets and the ui pipeline pass).
+ */
+declare class FolderResourceManager implements ResourceManager {
+  readonly root: string;
+  constructor(root: string);
+  private resolve;
+  getResource(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer | null>;
+  hasResource(kind: ResourceKindName, locator: ResourceLocator): Promise<boolean>;
+  getAllResources(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer[]>;
+  listResources(kind: ResourceKindName, namespace: string): Promise<ResourceLocator[]>;
+  listNamespaces(): Promise<string[]>;
+}
+/**
+ * Layers several managers; earlier managers win, matching resource-pack precedence.
+ * The builtin pack goes first, then mod/version overlays, then the base assets.
+ */
+declare class LayeredResourceManager implements ResourceManager {
+  readonly layers: ResourceManager[];
+  constructor(layers: ResourceManager[]);
+  getResource(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer | null>;
+  hasResource(kind: ResourceKindName, locator: ResourceLocator): Promise<boolean>;
+  getAllResources(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer[]>;
+  listResources(kind: ResourceKindName, namespace: string): Promise<ResourceLocator[]>;
+  listNamespaces(): Promise<string[]>;
+}
+//#endregion
+export { ResourceManager as a, ResourceKindName as i, LayeredResourceManager as n, ResourceKind as r, FolderResourceManager as t };

package/dist/manager-dfI7b9N4.js

@@ -0,0 +1,150 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+//#region src/resources/manager.ts
+/**
+* A category of resource inside a pack, mapping to a directory under
+* `assets/<namespace>/` plus a file extension.
+*/
+const ResourceKind = {
+	model: {
+		directory: "models",
+		extension: ".json"
+	},
+	itemDefinition: {
+		directory: "items",
+		extension: ".json"
+	},
+	blockstate: {
+		directory: "blockstates",
+		extension: ".json"
+	},
+	texture: {
+		directory: "textures",
+		extension: ".png"
+	},
+	textureMeta: {
+		directory: "textures",
+		extension: ".png.mcmeta"
+	},
+	atlas: {
+		directory: "atlases",
+		extension: ".json"
+	},
+	lang: {
+		directory: "lang",
+		extension: ".json"
+	},
+	/** Arbitrary file under assets/<ns>/ (OBJ geometry, MTL material libraries). */
+	raw: {
+		directory: "",
+		extension: ""
+	}
+};
+/**
+* Reads a resource pack laid out on disk. Accepts both layouts in the wild:
+* `<root>/assets/<ns>/…` (an extracted jar/pack) and `<root>/<ns>/…`
+* (what renderchest's --assets and the ui pipeline pass).
+*/
+var FolderResourceManager = class {
+	root;
+	constructor(root) {
+		this.root = existsSync(path.join(root, "assets")) ? path.join(root, "assets") : root;
+	}
+	resolve(kind, locator) {
+		const { directory, extension } = ResourceKind[kind];
+		return path.join(this.root, locator.namespace, directory, `${locator.path}${extension}`);
+	}
+	async getResource(kind, locator) {
+		try {
+			return await readFile(this.resolve(kind, locator));
+		} catch (err) {
+			if (err.code === "ENOENT") return null;
+			throw err;
+		}
+	}
+	async hasResource(kind, locator) {
+		return await this.getResource(kind, locator) !== null;
+	}
+	async getAllResources(kind, locator) {
+		const resource = await this.getResource(kind, locator);
+		return resource === null ? [] : [resource];
+	}
+	async listResources(kind, namespace) {
+		const { directory, extension } = ResourceKind[kind];
+		const base = path.join(this.root, namespace, directory);
+		let entries;
+		try {
+			entries = await readdir(base, {
+				recursive: true,
+				withFileTypes: true
+			});
+		} catch (err) {
+			if (err.code === "ENOENT") return [];
+			throw err;
+		}
+		const locators = [];
+		for (const entry of entries) {
+			if (!entry.isFile() || !entry.name.endsWith(extension)) continue;
+			const full = path.join(entry.parentPath, entry.name);
+			const relative = path.relative(base, full).replaceAll("\\", "/");
+			const locator = ResourceLocator.tryParse(`${namespace}:${relative.slice(0, -extension.length)}`);
+			if (locator) locators.push(locator);
+		}
+		return locators;
+	}
+	async listNamespaces() {
+		try {
+			return (await readdir(this.root, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+		} catch (err) {
+			if (err.code === "ENOENT") return [];
+			throw err;
+		}
+	}
+};
+/**
+* Layers several managers; earlier managers win, matching resource-pack precedence.
+* The builtin pack goes first, then mod/version overlays, then the base assets.
+*/
+var LayeredResourceManager = class {
+	layers;
+	constructor(layers) {
+		this.layers = layers;
+	}
+	async getResource(kind, locator) {
+		for (const layer of this.layers) {
+			const resource = await layer.getResource(kind, locator);
+			if (resource !== null) return resource;
+		}
+		return null;
+	}
+	async hasResource(kind, locator) {
+		for (const layer of this.layers) if (await layer.hasResource(kind, locator)) return true;
+		return false;
+	}
+	async getAllResources(kind, locator) {
+		const all = [];
+		for (const layer of this.layers) all.push(...await layer.getAllResources(kind, locator));
+		return all;
+	}
+	async listResources(kind, namespace) {
+		const seen = /* @__PURE__ */ new Set();
+		const merged = [];
+		for (const layer of this.layers) for (const locator of await layer.listResources(kind, namespace)) {
+			const key = locator.toString();
+			if (!seen.has(key)) {
+				seen.add(key);
+				merged.push(locator);
+			}
+		}
+		return merged;
+	}
+	async listNamespaces() {
+		const namespaces = /* @__PURE__ */ new Set();
+		for (const layer of this.layers) for (const namespace of await layer.listNamespaces()) namespaces.add(namespace);
+		return [...namespaces].toSorted((left, right) => left.localeCompare(right));
+	}
+};
+//#endregion
+export { LayeredResourceManager as n, ResourceKind as r, FolderResourceManager as t };

package/dist/minify-CIV6enbr.d.ts

@@ -0,0 +1,11 @@
+//#region src/output/minify.d.ts
+/**
+ * Minify a stylesheet with lightningcss. On a parse failure the readable sheet
+ * is returned unchanged and reported — mods have shipped item names that break
+ * whole stylesheets, and losing every icon to one bad rule is the old
+ * pipeline's failure mode, not ours (our selectors are sanitized upstream of
+ * this, so failures here should be exceptional).
+ */
+declare function minifyStylesheet(css: string, onWarning?: (message: string) => void): string;
+//#endregion
+export { minifyStylesheet as t };

package/dist/minify-bjMRmr5J.js

@@ -0,0 +1,31 @@
+import { transform } from "lightningcss";
+//#region src/output/minify.ts
+const TARGETS = {
+	chrome: 8978432,
+	edge: 8978432,
+	firefox: 9043968,
+	safari: 18 << 16
+};
+/**
+* Minify a stylesheet with lightningcss. On a parse failure the readable sheet
+* is returned unchanged and reported — mods have shipped item names that break
+* whole stylesheets, and losing every icon to one bad rule is the old
+* pipeline's failure mode, not ours (our selectors are sanitized upstream of
+* this, so failures here should be exceptional).
+*/
+function minifyStylesheet(css, onWarning) {
+	try {
+		const result = transform({
+			filename: "icons.css",
+			code: Buffer.from(css, "utf8"),
+			minify: true,
+			targets: TARGETS
+		});
+		return Buffer.from(result.code).toString("utf8");
+	} catch (err) {
+		onWarning?.(`Stylesheet minification failed, emitting unminified: ${err.message}`);
+		return css;
+	}
+}
+//#endregion
+export { minifyStylesheet as t };

package/dist/models/loader.d.ts

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

package/dist/models/loader.js

@@ -0,0 +1,2 @@
+import { a as salvageJson, i as resolveTexture, n as ModelResolutionError, r as flattenLoaderModel, t as ModelLoader } from "../loader-C-eqwp3M.js";
+export { ModelLoader, ModelResolutionError, flattenLoaderModel, resolveTexture, salvageJson };

package/dist/models/types.d.ts

@@ -0,0 +1,2 @@
+import { a as FaceDirectionName, c as ModelJson, i as FaceDirection, l as Vec3, n as DisplayTransformJson, o as ModelElementJson, r as ElementRotationJson, s as ModelFaceJson, t as DisplayPosition, u as Vec4 } from "../types-COGbtA1t.js";
+export { DisplayPosition, DisplayTransformJson, ElementRotationJson, FaceDirection, FaceDirectionName, ModelElementJson, ModelFaceJson, ModelJson, Vec3, Vec4 };

package/dist/models/types.js

@@ -0,0 +1,11 @@
+//#region src/models/types.ts
+const FaceDirection = {
+	down: "down",
+	up: "up",
+	north: "north",
+	south: "south",
+	west: "west",
+	east: "east"
+};
+//#endregion
+export { FaceDirection };

package/dist/mods/prepare.d.ts

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

package/dist/mods/prepare.js

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

package/dist/mods/synthesize.d.ts

@@ -0,0 +1,10 @@
+import { a as ResourceManager } from "../manager-CoZaeQTu.js";
+import { n as MapResourceManager } from "../synthetic-CDsj--li.js";
+//#region src/mods/synthesize.d.ts
+interface SynthesisResult {
+  models: MapResourceManager;
+  synthesized: number;
+}
+declare function synthesizeItemModels(resources: ResourceManager, namespace: string): Promise<SynthesisResult>;
+//#endregion
+export { SynthesisResult, synthesizeItemModels };

package/dist/mods/synthesize.js

@@ -0,0 +1,2 @@
+import { t as synthesizeItemModels } from "../synthesize-CRgSEmEp.js";
+export { synthesizeItemModels };

package/dist/output/encode.d.ts

@@ -0,0 +1,2 @@
+import { a as encodeAnimatedIcon, i as EncodedIcon, n as EncodeOptions, o as encodeIcon, r as EncodedAnimatedIcon, t as AnimatedEncodeOptions } from "../encode-BDB_VIHN.js";
+export { AnimatedEncodeOptions, EncodeOptions, EncodedAnimatedIcon, EncodedIcon, encodeAnimatedIcon, encodeIcon };

package/dist/output/encode.js

@@ -0,0 +1,2 @@
+import { n as encodeIcon, t as encodeAnimatedIcon } from "../encode-BdTHbOp-.js";
+export { encodeAnimatedIcon, encodeIcon };

package/dist/output/item-styles.d.ts

@@ -0,0 +1,10 @@
+import { t as ItemStyle } from "../stylesheet-i-t_7sZ7.js";
+//#region src/output/item-styles.d.ts
+/**
+ * Build the ItemStyle for a rendered item. `renderedIds` gates variant rules to
+ * images that exist. Returns null for internal layer-source items (rc_*),
+ * which get no rules of their own.
+ */
+declare function classifyItemStyle(id: string, renderedIds: ReadonlySet<string>): ItemStyle | null;
+//#endregion
+export { classifyItemStyle };

package/dist/output/item-styles.js

@@ -0,0 +1,2 @@
+import { t as classifyItemStyle } from "../item-styles-DJ3LWZS2.js";
+export { classifyItemStyle };

package/dist/output/minify.d.ts

@@ -0,0 +1,2 @@
+import { t as minifyStylesheet } from "../minify-CIV6enbr.js";
+export { minifyStylesheet };

package/dist/output/minify.js

@@ -0,0 +1,2 @@
+import { t as minifyStylesheet } from "../minify-bjMRmr5J.js";
+export { minifyStylesheet };

package/dist/output/stylesheet.d.ts

@@ -0,0 +1,2 @@
+import { i as itemClass, n as StylesheetOptions, r as generateStylesheet, t as ItemStyle } from "../stylesheet-i-t_7sZ7.js";
+export { ItemStyle, StylesheetOptions, generateStylesheet, itemClass };

package/dist/output/stylesheet.js

@@ -0,0 +1,2 @@
+import { n as itemClass, t as generateStylesheet } from "../stylesheet-CovT3B2S.js";
+export { generateStylesheet, itemClass };

package/dist/prepare-Bvc5ve2m.js

@@ -0,0 +1,68 @@
+import { n as LayeredResourceManager } from "./manager-dfI7b9N4.js";
+import { n as UnsafeJarError, t as JarResourceManager } from "./jar-Bt3i0ls4.js";
+import { t as synthesizeItemModels } from "./synthesize-CRgSEmEp.js";
+//#region src/mods/prepare.ts
+/**
+* Mod asset composition: mod jars layered under the vanilla base (vanilla wins
+* the `minecraft` namespace, but mod-provided vanilla textures fill gaps —
+* roughly half of the old pipeline's missing-texture failures were paths some
+* jar already held), plus synthesized item models per namespace.
+*/
+/** Loader-owned namespaces that never contain renderable mod items. */
+const LOADER_NAMESPACES = /* @__PURE__ */ new Set([
+	"minecraft",
+	"forge",
+	"neoforge",
+	"fabric",
+	"fabricloader",
+	"c",
+	"quilt",
+	"realms"
+]);
+/** A namespace must ship item-ish content to be worth rendering. */
+async function hasItemContent(resources, namespace) {
+	if ((await resources.listResources("itemDefinition", namespace)).length > 0) return true;
+	for (const locator of await resources.listResources("model", namespace)) if (locator.path.startsWith("item/")) return true;
+	for (const locator of await resources.listResources("texture", namespace)) if (/^(?:item|items|block|blocks)\//.test(locator.path)) return true;
+	return false;
+}
+async function prepareModResources(options) {
+	const jarLayers = [];
+	const rejected = [];
+	const namespaceSet = /* @__PURE__ */ new Set();
+	for (const jar of options.jars) {
+		const manager = new JarResourceManager(jar);
+		try {
+			for (const namespace of await manager.listNamespaces()) if (!LOADER_NAMESPACES.has(namespace)) namespaceSet.add(namespace);
+			jarLayers.push(manager);
+		} catch (err) {
+			rejected.push({
+				jar,
+				reason: err instanceof UnsafeJarError ? err.message : err.message
+			});
+			await manager.close().catch(() => {});
+		}
+	}
+	const base = new LayeredResourceManager([options.vanilla, ...jarLayers]);
+	const namespaces = [];
+	let synthesized = 0;
+	const synthLayers = [];
+	for (const namespace of [...namespaceSet].toSorted((left, right) => left.localeCompare(right))) {
+		if (!await hasItemContent(base, namespace)) continue;
+		namespaces.push(namespace);
+		const result = await synthesizeItemModels(base, namespace);
+		if (result.synthesized > 0) {
+			synthesized += result.synthesized;
+			synthLayers.push(result.models);
+			options.onProgress?.(`Synthesized ${result.synthesized} item models for ${namespace}`);
+		}
+	}
+	return {
+		resources: new LayeredResourceManager([base, ...synthLayers]),
+		namespaces,
+		synthesized,
+		rejected
+	};
+}
+//#endregion
+export { prepareModResources as n, LOADER_NAMESPACES as t };