@nodecraft/rendermite 0.0.1 → 1.0.1

package/dist/run-Dr6BfyN9.js

@@ -0,0 +1,316 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-dfI7b9N4.js";
+import { t as loadAtlasResolver } from "./registry-C9E7jyzG.js";
+import { a as builtinDynamicResources } from "./generators-CcVRG30y.js";
+import { a as defaultProperties } from "./definition-3MBm8ar_.js";
+import { n as discoverItems, r as resolveItem } from "./discovery-BzaOti7l.js";
+import { t as ModelLoader } from "./loader-C-eqwp3M.js";
+import { s as toFloatTexture, t as blendPixel } from "./blend-CHP2-j9U.js";
+import { r as encodeRasterAsset, t as encodeAnimatedIcon } from "./encode-3u49i-eD.js";
+import { t as classifyItemStyle } from "./item-styles-DJ3LWZS2.js";
+import { t as minifyStylesheet } from "./minify-bjMRmr5J.js";
+import { t as generateStylesheet } from "./stylesheet-CovT3B2S.js";
+import { a as renderModelFrames, i as renderModel, n as boxDownscale, r as pointResize } from "./renderer-CmOz6WI9.js";
+import { n as renderEntityFallback, r as spawnEggTints, t as renderDyedVariantFallback } from "./entity-fallback-CodtI6v8.js";
+import { i as renderGeo, t as findGeoForItem } from "./geo-B5VqGulc.js";
+import { t as legacyTintsForChain } from "./legacy-tints-B09J0Rxh.js";
+import { a as resolveTints } from "./tints-FQlxTzUL.js";
+import { n as TextureLoader } from "./loader-CBzn3Koc.js";
+import path from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+//#region src/run.ts
+/**
+* Render-run orchestration: discover items, evaluate definitions, render,
+* encode, write images + stylesheet + item list. Unlike upstream, failures are
+* per-item, collected, and reported — a run summary counts files, never log lines.
+*/
+async function run(options) {
+	const namespaces = options.namespaces ?? ["minecraft"];
+	const size = options.size ?? 64;
+	const quality = options.quality ?? 2;
+	const prefix = options.prefix ?? "rc-";
+	const format = options.format ?? "webp";
+	const fallback = options.fallback ?? true;
+	const lightingProfile = options.lightingProfile ?? "modern";
+	const dynamic = options.builtin ? builtinDynamicResources() : null;
+	const resources = options.builtin && dynamic ? new LayeredResourceManager([
+		new FolderResourceManager(options.builtin),
+		dynamic.layer,
+		options.resources
+	]) : options.resources;
+	const models = new ModelLoader(resources);
+	const textures = new TextureLoader(resources);
+	const glint = await resolveEnchantmentGlint(resources);
+	if (!glint) throw new Error("Missing enchantment glint texture (minecraft:misc/enchanted_glint_item or enchanted_item_glint)");
+	const encodedGlint = await encodeRasterAsset(glint, fallback ? ["png", format] : [format]);
+	textures.setAtlasResolver(await loadAtlasResolver(resources, (locator) => textures.load(locator)));
+	const ids = [];
+	const seen = /* @__PURE__ */ new Set();
+	if (options.builtin) for (const placeholder of ["renderchest:unknown", "renderchest:empty"]) {
+		seen.add(placeholder);
+		ids.push(placeholder);
+	}
+	for (const namespace of namespaces) for (const item of await discoverItems(resources, namespace)) {
+		if (seen.has(item.id)) continue;
+		if (options.builtin && !await itemExistsIn(options.resources, item.id)) continue;
+		seen.add(item.id);
+		ids.push(item.id);
+	}
+	if (dynamic && namespaces.includes("minecraft")) {
+		const hasTrims = await resources.hasResource("texture", ResourceLocator.parse("minecraft:trims/color_palettes/trim_palette"));
+		const groupAvailable = {
+			_armor_trims: hasTrims,
+			_leather_armor: hasTrims,
+			_decorated_pot: await resources.hasResource("texture", ResourceLocator.parse("minecraft:entity/decorated_pot/decorated_pot_base")),
+			_crossbow: await resources.hasResource("model", ResourceLocator.parse("minecraft:item/crossbow_arrow"))
+		};
+		for (const item of dynamic.items) if ((groupAvailable[item.id.split(":", 1)[0]] ?? true) && !seen.has(item.id)) {
+			seen.add(item.id);
+			ids.push(item.id);
+		}
+	}
+	const rendered = [];
+	const failed = [];
+	const spriteFallbacks = [];
+	const skippedTemplates = [];
+	const styles = [];
+	let writtenFiles = 0;
+	await mkdir(options.output, { recursive: true });
+	for (const [extension, buffer] of encodedGlint) {
+		await writeFile(path.join(options.output, `${prefix}enchantment.${extension}`), buffer);
+		writtenFiles++;
+	}
+	let templateParents = null;
+	const loadTemplateParents = async () => {
+		const parents = /* @__PURE__ */ new Set();
+		for (const namespace of namespaces) for (const modelLocator of await resources.listResources("model", namespace)) {
+			if (!modelLocator.path.startsWith("item/")) continue;
+			const raw = await resources.getResource("model", modelLocator);
+			if (!raw) continue;
+			try {
+				const parent = JSON.parse(raw.toString("utf8")).parent;
+				if (typeof parent === "string") parents.add(ResourceLocator.parse(parent).toString());
+			} catch {}
+		}
+		return parents;
+	};
+	const isTemplateModel = async (id) => {
+		const locator = ResourceLocator.parse(id);
+		if (await resources.hasResource("itemDefinition", locator)) return false;
+		templateParents ??= loadTemplateParents();
+		return (await templateParents).has(new ResourceLocator(locator.namespace, `item/${locator.path}`).toString());
+	};
+	/**
+	* Code-rendered models often still ship a flat item sprite (the old
+	* pipeline's black-icon audit checked exactly this). A real sprite beats
+	* no icon; the fallback is recorded so it is never a silent substitution.
+	*/
+	const spriteFallback = async (id) => {
+		const locator = ResourceLocator.parse(id);
+		for (const directory of ["item", "items"]) {
+			const texture = await textures.load(new ResourceLocator(locator.namespace, `${directory}/${locator.path}`));
+			if (texture) {
+				const float = toFloatTexture(texture);
+				const upscaled = pointResize(float, size * quality, size * quality);
+				return quality === 1 ? upscaled : boxDownscale(upscaled, quality);
+			}
+		}
+		return null;
+	};
+	const concurrency = Math.max(1, options.concurrency ?? 8);
+	let nextIndex = 0;
+	let completed = 0;
+	const renderFrames = async (id) => {
+		const instructions = await resolveItem(resources, id, defaultProperties());
+		let frames;
+		let delaysMs;
+		if (instructions.length === 1) {
+			const model = await models.load(instructions[0].model);
+			let tints = instructions[0].tints.length > 0 ? await resolveTints(instructions[0].tints, { textures }) : await legacyTintsForChain(model.chain, textures);
+			if (!tints && model.chain.some((entry) => entry.endsWith("item/template_spawn_egg"))) tints = await spawnEggTints(id, resources, textures).catch(() => null);
+			tints ??= [];
+			const result = await renderModelFrames(model, textures, {
+				size,
+				quality,
+				lightingProfile,
+				itemTransform: instructions[0].transform,
+				tints,
+				resources
+			});
+			frames = result.frames;
+			delaysMs = result.delaysMs;
+		} else {
+			let combined = null;
+			for (const instruction of instructions) {
+				const model = await models.load(instruction.model);
+				const tints = instruction.tints.length > 0 ? await resolveTints(instruction.tints, { textures }) : await legacyTintsForChain(model.chain, textures) ?? [];
+				const renderedModel = await renderModel(model, textures, {
+					size,
+					quality,
+					lightingProfile,
+					itemTransform: instruction.transform,
+					tints,
+					resources
+				});
+				combined = combined === null ? renderedModel : blendOver(combined, renderedModel);
+			}
+			frames = [combined ?? {
+				width: size,
+				height: size,
+				data: new Float64Array(size * size * 4)
+			}];
+			delaysMs = [50];
+		}
+		if (frames.length === 0) {
+			frames = [{
+				width: size,
+				height: size,
+				data: new Float64Array(size * size * 4)
+			}];
+			delaysMs = [50];
+		}
+		return {
+			frames,
+			delaysMs
+		};
+	};
+	const renderOne = async (index) => {
+		const id = ids[index];
+		let frames;
+		let delaysMs;
+		let usedFallback = false;
+		try {
+			({frames, delaysMs} = await renderFrames(id));
+		} catch (err) {
+			const blockLocator = ResourceLocator.parse(id);
+			const blockRender = await models.load(new ResourceLocator(blockLocator.namespace, `block/${blockLocator.path}`)).then((model) => renderModel(model, textures, {
+				size,
+				quality,
+				lightingProfile,
+				resources
+			})).catch(() => null);
+			const geo = blockRender ? null : await findGeoForItem(resources, id).catch(() => null);
+			const geoRender = geo ? await renderGeo(geo.geo, geo.texture, textures, {
+				size,
+				quality,
+				lightingProfile
+			}).catch(() => null) : null;
+			let fallbackRender = blockRender ?? (geoRender && quality !== 1 ? boxDownscale(geoRender, quality) : geoRender);
+			fallbackRender ??= options.builtin ? await renderEntityFallback(id, models, textures, resources, {
+				size,
+				quality,
+				lightingProfile,
+				resources
+			}).catch(() => null) : null;
+			fallbackRender ??= await renderDyedVariantFallback(id, models, textures, {
+				size,
+				quality,
+				lightingProfile,
+				resources
+			}).catch(() => null);
+			if (fallbackRender) {
+				frames = [fallbackRender];
+				delaysMs = [50];
+			} else {
+				const fallback = await spriteFallback(id).catch(() => null);
+				if (!fallback) {
+					if (await isTemplateModel(id).catch(() => false)) skippedTemplates.push(id);
+					else failed.push({
+						id,
+						error: err.message
+					});
+					completed++;
+					options.onProgress?.(completed, ids.length, id, err.message);
+					return;
+				}
+				frames = [fallback];
+				delaysMs = [50];
+				usedFallback = true;
+			}
+		}
+		try {
+			const encoded = await encodeAnimatedIcon(frames, delaysMs, {
+				webp: true,
+				gif: options.gif,
+				avif: options.avif || format === "avif"
+			});
+			const [namespace, itemPath] = id.split(":", 2);
+			const imageBase = path.join(options.output, "items", namespace, `${itemPath}`);
+			await mkdir(path.dirname(imageBase), { recursive: true });
+			await writeFile(`${imageBase}.png`, encoded.png);
+			writtenFiles++;
+			for (const [extension, buffer] of [
+				["webp", encoded.webp],
+				["gif", encoded.gif],
+				["avif", encoded.avif]
+			]) {
+				if (!buffer) continue;
+				await writeFile(`${imageBase}.${extension}`, buffer);
+				writtenFiles++;
+			}
+			rendered.push(id);
+			if (usedFallback) spriteFallbacks.push(id);
+			completed++;
+			options.onProgress?.(completed, ids.length, id);
+		} catch (err) {
+			failed.push({
+				id,
+				error: err.message
+			});
+			completed++;
+			options.onProgress?.(completed, ids.length, id, err.message);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(concurrency, ids.length) }, async () => {
+		while (nextIndex < ids.length) {
+			const index = nextIndex++;
+			await renderOne(index);
+		}
+	}));
+	rendered.sort((left, right) => left.localeCompare(right));
+	const renderedSet = new Set(rendered);
+	for (const id of rendered) {
+		const style = classifyItemStyle(id, renderedSet);
+		if (style) styles.push(style);
+	}
+	const stylesheet = generateStylesheet(styles, {
+		prefix,
+		format,
+		fallback
+	});
+	const finalStylesheet = options.minify === false ? stylesheet : minifyStylesheet(stylesheet, (message) => options.onProgress?.(0, 0, "stylesheet", message));
+	await writeFile(path.join(options.output, `${prefix}${namespaces[0]}-${size}.css`), finalStylesheet);
+	if (options.itemList !== false) {
+		await writeFile(path.join(options.output, `${prefix}${namespaces[0]}.json`), JSON.stringify(rendered));
+		await writeFile(path.join(options.output, `${prefix}${namespaces[0]}-failures.json`), JSON.stringify(failed, null, "	"));
+	}
+	return {
+		rendered,
+		failed,
+		spriteFallbacks,
+		skippedTemplates,
+		writtenFiles
+	};
+}
+async function itemExistsIn(resources, id) {
+	const locator = ResourceLocator.parse(id);
+	if (await resources.hasResource("itemDefinition", locator)) return true;
+	return resources.hasResource("model", new ResourceLocator(locator.namespace, `item/${locator.path}`));
+}
+/** Resolve both names used on either side of Minecraft 1.19.3. */
+async function resolveEnchantmentGlint(resources) {
+	for (const path of ["misc/enchanted_glint_item", "misc/enchanted_item_glint"]) {
+		const texture = await resources.getResource("texture", new ResourceLocator("minecraft", path));
+		if (texture) return texture;
+	}
+	return null;
+}
+function blendOver(base, layer) {
+	for (let offset = 0; offset < base.data.length; offset += 4) {
+		const alpha = layer.data[offset + 3];
+		if (alpha > 0) blendPixel(base.data, offset, layer.data[offset], layer.data[offset + 1], layer.data[offset + 2], alpha);
+	}
+	return base;
+}
+//#endregion
+export { run as t };

package/dist/run.d.ts

@@ -0,0 +1,3 @@
+import { l as evaluateItemModel } from "./definition-BwX6Xxv0.js";
+import { i as run, n as RunOptions, r as RunResult, t as ItemFailure } from "./run-BK7Q8WZ3.js";
+export { ItemFailure, RunOptions, RunResult, evaluateItemModel, run };

package/dist/run.js

@@ -0,0 +1,3 @@
+import { o as evaluateItemModel } from "./definition-3MBm8ar_.js";
+import { t as run } from "./run-Dr6BfyN9.js";
+export { evaluateItemModel, run };

package/dist/sources-Bxk-WOzH.js

@@ -0,0 +1,202 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+//#region src/atlas/sources.ts
+/**
+* Atlas texture sources (docs/research/renderchest-spec.md §6): directory,
+* single, unstitch, paletted_permutations. Sources resolve sprite ids to
+* texture content; the resolver checks sources in reverse load order
+* (last-loaded wins, matching upstream's unshift behavior).
+*/
+var AtlasSourceError = class extends Error {};
+var DirectoryAtlasSource = class {
+	namespace;
+	settings;
+	hasTexture;
+	constructor(namespace, settings, hasTexture) {
+		this.namespace = namespace;
+		this.settings = settings;
+		this.hasTexture = hasTexture;
+	}
+	target(locator) {
+		const rest = locator.path.slice(this.settings.prefix.length);
+		return new ResourceLocator(locator.namespace, `${this.settings.source}/${rest}`);
+	}
+	/**
+	* The rewritten file must actually exist — gui.json ships a directory source
+	* with an empty prefix that would otherwise claim every sprite id.
+	*/
+	async has(locator) {
+		if (locator.namespace !== this.namespace || !locator.path.startsWith(this.settings.prefix)) return false;
+		return this.hasTexture(this.target(locator));
+	}
+	async resolve(locator) {
+		if (!await this.has(locator)) return null;
+		return {
+			kind: "file",
+			locator: this.target(locator)
+		};
+	}
+};
+var SingleAtlasSource = class {
+	spriteId;
+	resource;
+	hasTexture;
+	constructor(settings, hasTexture) {
+		this.resource = ResourceLocator.parse(settings.resource);
+		this.spriteId = ResourceLocator.parse(settings.sprite ?? settings.resource);
+		this.hasTexture = hasTexture;
+	}
+	async has(locator) {
+		return locator.equals(this.spriteId) && this.hasTexture(this.resource);
+	}
+	async resolve(locator) {
+		return await this.has(locator) ? {
+			kind: "file",
+			locator: this.resource
+		} : null;
+	}
+};
+/**
+* Armor-trim style palette swaps: a key palette maps colors → indices; each
+* permutation palette replaces pixels whose exact RGBA matches a key entry
+* with the pixel at the same row-major index in the permutation image.
+*/
+var PalettedPermutationsSource = class PalettedPermutationsSource {
+	static encode(r, g, b, a) {
+		return r * 16777216 + g * 65536 + b * 256 + a;
+	}
+	settings;
+	sprites = /* @__PURE__ */ new Map();
+	keyPalette = null;
+	loadTexture;
+	constructor(settings, loadTexture) {
+		this.loadTexture = loadTexture;
+		this.settings = settings;
+		const separator = settings.separator ?? "_";
+		for (const [name, palette] of Object.entries(settings.permutations)) {
+			const paletteLocator = ResourceLocator.parse(palette);
+			for (const base of settings.textures) {
+				const baseLocator = ResourceLocator.parse(base.replace(/\.png$/, ""));
+				const sprite = new ResourceLocator(baseLocator.namespace, `${baseLocator.path}${separator}${name}`);
+				this.sprites.set(sprite.toString(), {
+					base: baseLocator,
+					palette: paletteLocator
+				});
+			}
+		}
+	}
+	async getKeyPalette() {
+		if (this.keyPalette) return this.keyPalette;
+		const keyTexture = await this.loadTexture(ResourceLocator.parse(this.settings.palette_key));
+		if (!keyTexture) throw new AtlasSourceError(`Missing palette key ${this.settings.palette_key}`);
+		const palette = /* @__PURE__ */ new Map();
+		for (let index = 0; index < keyTexture.width * keyTexture.height; index++) {
+			const offset = index * 4;
+			palette.set(PalettedPermutationsSource.encode(keyTexture.data[offset], keyTexture.data[offset + 1], keyTexture.data[offset + 2], keyTexture.data[offset + 3]), index);
+		}
+		this.keyPalette = palette;
+		return palette;
+	}
+	has(locator) {
+		return this.sprites.has(locator.toString());
+	}
+	async resolve(locator) {
+		const sprite = this.sprites.get(locator.toString());
+		if (!sprite) return null;
+		const base = await this.loadTexture(sprite.base);
+		if (!base) return null;
+		const permutation = await this.loadTexture(sprite.palette);
+		if (!permutation) return null;
+		const keyPalette = await this.getKeyPalette();
+		const data = new Uint8ClampedArray(base.data);
+		for (let offset = 0; offset < data.length; offset += 4) {
+			const index = keyPalette.get(PalettedPermutationsSource.encode(data[offset], data[offset + 1], data[offset + 2], data[offset + 3]));
+			if (index === void 0) continue;
+			const x = index % permutation.width;
+			const y = Math.floor(index / permutation.width);
+			if (y >= permutation.height) continue;
+			const src = (y * permutation.width + x) * 4;
+			data[offset] = permutation.data[src];
+			data[offset + 1] = permutation.data[src + 1];
+			data[offset + 2] = permutation.data[src + 2];
+			data[offset + 3] = permutation.data[src + 3];
+		}
+		return {
+			kind: "pixels",
+			texture: {
+				width: base.width,
+				height: base.height,
+				data
+			}
+		};
+	}
+};
+var UnstitchAtlasSource = class {
+	settings;
+	loadTexture;
+	constructor(settings, loadTexture) {
+		this.settings = settings;
+		this.loadTexture = loadTexture;
+	}
+	has(locator) {
+		return this.settings.regions.some((region) => ResourceLocator.parse(region.sprite).equals(locator));
+	}
+	async resolve(locator) {
+		const region = this.settings.regions.find((entry) => ResourceLocator.parse(entry.sprite).equals(locator));
+		if (!region) return null;
+		const base = await this.loadTexture(ResourceLocator.parse(this.settings.resource));
+		if (!base) return null;
+		const divisorX = this.settings.divisor_x ?? 1;
+		const divisorY = this.settings.divisor_y ?? 1;
+		const width = Math.round(region.width / divisorX * base.width);
+		const height = Math.round(region.height / divisorY * base.height);
+		const left = Math.round(region.x / divisorX * base.width);
+		const top = Math.round(region.y / divisorY * base.height);
+		const data = new Uint8ClampedArray(width * height * 4);
+		for (let y = 0; y < height; y++) {
+			const srcStart = ((top + y) * base.width + left) * 4;
+			data.set(base.data.subarray(srcStart, srcStart + width * 4), y * width * 4);
+		}
+		return {
+			kind: "pixels",
+			texture: {
+				width,
+				height,
+				data
+			}
+		};
+	}
+};
+/**
+* Parses one atlas JSON's sources array. Unknown types are reported and
+* skipped rather than failing the file — mods ship experimental source types,
+* and losing a whole atlas over one is how items vanish.
+*/
+function parseAtlasSources(namespace, atlasJson, loadTexture, onUnknown, hasTexture = async (locator) => await loadTexture(locator) !== null) {
+	const sources = [];
+	for (const entry of atlasJson.sources ?? []) switch (String(entry.type ?? "").replace(/^minecraft:/, "")) {
+		case "directory":
+			sources.push(new DirectoryAtlasSource(namespace, entry, hasTexture));
+			break;
+		case "single":
+			sources.push(new SingleAtlasSource(entry, hasTexture));
+			break;
+		case "paletted_permutations":
+			sources.push(new PalettedPermutationsSource(entry, loadTexture));
+			break;
+		case "unstitch":
+			sources.push(new UnstitchAtlasSource(entry, loadTexture));
+			break;
+		case "filter": break;
+		default: onUnknown?.(String(entry.type));
+	}
+	return sources;
+}
+/** Sources checked in reverse insertion order (last added wins), per upstream. */
+function createAtlasResolver(sources) {
+	return { async resolve(locator) {
+		for (let i = sources.length - 1; i >= 0; i--) if (await sources[i].has(locator)) return sources[i].resolve(locator);
+		return null;
+	} };
+}
+//#endregion
+export { UnstitchAtlasSource as a, SingleAtlasSource as i, DirectoryAtlasSource as n, createAtlasResolver as o, PalettedPermutationsSource as r, parseAtlasSources as s, AtlasSourceError as t };

package/dist/sources-DH9dk3KF.d.ts

@@ -0,0 +1,104 @@
+import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
+import { r as Texture } from "./loader-TFFNV4Jl.js";
+//#region src/atlas/sources.d.ts
+declare class AtlasSourceError extends Error {}
+interface AtlasSource {
+  /** Does this source provide the sprite id? */
+  has(locator: ResourceLocator): boolean | Promise<boolean>;
+  /** Resolve to the actual texture file locator, or synthesized pixels. */
+  resolve(locator: ResourceLocator): Promise<ResolvedSprite | null>;
+}
+type ResolvedSprite = {
+  kind: 'file';
+  locator: ResourceLocator;
+} | {
+  kind: 'pixels';
+  texture: Texture;
+};
+interface DirectorySettings {
+  source: string;
+  prefix: string;
+}
+type HasTexture = (locator: ResourceLocator) => Promise<boolean>;
+declare class DirectoryAtlasSource implements AtlasSource {
+  private readonly namespace;
+  private readonly settings;
+  private readonly hasTexture;
+  constructor(namespace: string, settings: DirectorySettings, hasTexture: HasTexture);
+  private target;
+  /**
+   * The rewritten file must actually exist — gui.json ships a directory source
+   * with an empty prefix that would otherwise claim every sprite id.
+   */
+  has(locator: ResourceLocator): Promise<boolean>;
+  resolve(locator: ResourceLocator): Promise<ResolvedSprite | null>;
+}
+interface SingleSettings {
+  resource: string;
+  sprite?: string;
+}
+declare class SingleAtlasSource implements AtlasSource {
+  private readonly spriteId;
+  private readonly resource;
+  private readonly hasTexture;
+  constructor(settings: SingleSettings, hasTexture: HasTexture);
+  has(locator: ResourceLocator): Promise<boolean>;
+  resolve(locator: ResourceLocator): Promise<ResolvedSprite | null>;
+}
+interface PalettedPermutationsSettings {
+  textures: string[];
+  palette_key: string;
+  permutations: Record<string, string>;
+  separator?: string;
+}
+/**
+ * Armor-trim style palette swaps: a key palette maps colors → indices; each
+ * permutation palette replaces pixels whose exact RGBA matches a key entry
+ * with the pixel at the same row-major index in the permutation image.
+ */
+declare class PalettedPermutationsSource implements AtlasSource {
+  private static encode;
+  private readonly settings;
+  private readonly sprites;
+  private keyPalette;
+  private readonly loadTexture;
+  constructor(settings: PalettedPermutationsSettings, loadTexture: (locator: ResourceLocator) => Promise<Texture | null>);
+  private getKeyPalette;
+  has(locator: ResourceLocator): boolean;
+  resolve(locator: ResourceLocator): Promise<ResolvedSprite | null>;
+}
+interface UnstitchRegion {
+  sprite: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface UnstitchSettings {
+  resource: string;
+  regions: UnstitchRegion[];
+  divisor_x?: number;
+  divisor_y?: number;
+}
+declare class UnstitchAtlasSource implements AtlasSource {
+  private readonly settings;
+  private readonly loadTexture;
+  constructor(settings: UnstitchSettings, loadTexture: (locator: ResourceLocator) => Promise<Texture | null>);
+  has(locator: ResourceLocator): boolean;
+  resolve(locator: ResourceLocator): Promise<ResolvedSprite | null>;
+}
+/**
+ * Parses one atlas JSON's sources array. Unknown types are reported and
+ * skipped rather than failing the file — mods ship experimental source types,
+ * and losing a whole atlas over one is how items vanish.
+ */
+declare function parseAtlasSources(namespace: string, atlasJson: {
+  sources?: Array<Record<string, unknown>>;
+}, loadTexture: (locator: ResourceLocator) => Promise<Texture | null>, onUnknown?: (type: string) => void, hasTexture?: HasTexture): AtlasSource[];
+interface AtlasResolver {
+  resolve(locator: ResourceLocator): Promise<ResolvedSprite | null>;
+}
+/** Sources checked in reverse insertion order (last added wins), per upstream. */
+declare function createAtlasResolver(sources: AtlasSource[]): AtlasResolver;
+//#endregion
+export { HasTexture as a, SingleAtlasSource as c, parseAtlasSources as d, DirectoryAtlasSource as i, UnstitchAtlasSource as l, AtlasSource as n, PalettedPermutationsSource as o, AtlasSourceError as r, ResolvedSprite as s, AtlasResolver as t, createAtlasResolver as u };