@nodecraft/rendermite 0.0.1 → 1.0.1

package/dist/stylesheet-CovT3B2S.js

@@ -0,0 +1,71 @@
+//#region src/output/stylesheet.ts
+/** Class-name sanitization is a security/robustness boundary: ids come from mod jars. */
+function itemClass(id, prefix = "rc-") {
+	return prefix + id.replaceAll(":", "_").replaceAll(/[^\w.-]/g, "_").replaceAll(".", String.raw`\.`);
+}
+function url(path, urlPrefix) {
+	return `url('${urlPrefix}${path}')`;
+}
+function generateStylesheet(items, options = {}) {
+	const prefix = options.prefix ?? "rc-";
+	const urlPrefix = options.urlPrefix ?? "";
+	const format = options.format ?? "webp";
+	const fallback = options.fallback ?? true;
+	const baseExtension = fallback ? "png" : format;
+	const blocks = [];
+	const upgrade = [];
+	const enchantedSelectors = [];
+	const itemSelector = `.${prefix}item`;
+	const unknown = "items/renderchest/unknown";
+	const empty = "items/renderchest/empty";
+	blocks.push(`@keyframes ${prefix}enchanted {\n    from { background-position: -256px 1024px; }\n    to { background-position: 256px -1024px; }\n}`, `${itemSelector} {\n    position: relative;\n    image-rendering: pixelated;\n    background-image: ${url(`${unknown}.${baseExtension}`, urlPrefix)};\n    mask-image: ${url(`${unknown}.${baseExtension}`, urlPrefix)};\n    background-size: cover;\n    background-color: var(--${prefix}layer-1-tint);\n    background-blend-mode: multiply;\n    mask-size: cover;\n}`, `${itemSelector}.${prefix}enchanted {\n    mask-image: ${url(`${unknown}.${baseExtension}`, urlPrefix)};\n}`, `${itemSelector}:before {\n    content: '';\n    position: absolute;\n    width: 100%;\n    height: 100%;\n    top: 0;\n    left: 0;\n    image-rendering: pixelated;\n    background-image: ${url(`${empty}.${baseExtension}`, urlPrefix)};\n    background-size: cover;\n    background-color: var(--${prefix}layer-2-tint);\n    background-blend-mode: multiply;\n    mask-size: cover;\n}`);
+	upgrade.push(`${itemSelector} { background-image: ${url(`${unknown}.${format}`, urlPrefix)}; mask-image: ${url(`${unknown}.${format}`, urlPrefix)}; }`, `${itemSelector}:before { background-image: ${url(`${empty}.${format}`, urlPrefix)}; }`);
+	for (const item of items) {
+		const selector = `${itemSelector}.${itemClass(item.id, prefix)}`;
+		const image = (ext) => url(`${item.image}.${ext}`, urlPrefix);
+		const baseProps = [];
+		for (const [name, value] of Object.entries(item.variables ?? {})) baseProps.push(`${name}: ${value};`);
+		baseProps.push(`background-image: ${image(baseExtension)};`);
+		const mask = item.mask === void 0 ? null : item.mask;
+		if (item.alwaysEnchanted) {
+			enchantedSelectors.push(`${selector}:after`);
+			baseProps.push(`mask-image: ${image(baseExtension)};`);
+		} else if (mask === null) baseProps.push("mask-image: none;");
+		else baseProps.push(`mask-image: ${url(`${mask}.${baseExtension}`, urlPrefix)};`);
+		blocks.push(`${selector} {\n    ${baseProps.join("\n    ")}\n}`);
+		blocks.push(`${selector}.${prefix}enchanted {\n    mask-image: ${image(baseExtension)};\n}`);
+		upgrade.push(`${selector} { background-image: ${image(format)}; ${mask !== null || item.alwaysEnchanted ? `mask-image: ${url(`${mask ?? item.image}.${format}`, urlPrefix)}; ` : ""}}`);
+		upgrade.push(`${selector}.${prefix}enchanted { mask-image: ${image(format)}; }`);
+		if (item.before) {
+			const beforeProps = [`background-image: ${url(`${item.before.image}.${baseExtension}`, urlPrefix)};`];
+			if (item.before.mask) beforeProps.push(`mask-image: ${url(`${item.before.mask}.${baseExtension}`, urlPrefix)};`);
+			blocks.push(`${selector}:before {\n    ${beforeProps.join("\n    ")}\n}`);
+			upgrade.push(`${selector}:before { background-image: ${url(`${item.before.image}.${format}`, urlPrefix)}; }`);
+		}
+		for (const variant of item.variants ?? []) {
+			if (variant.image) {
+				const variantSelector = `${selector}.${prefix}${variant.suffix}`;
+				const props = [`background-image: ${url(`${variant.image}.${baseExtension}`, urlPrefix)};`];
+				if (variant.mask) props.push(`mask-image: ${url(`${variant.mask}.${baseExtension}`, urlPrefix)};`);
+				blocks.push(`${variantSelector} {\n    ${props.join("\n    ")}\n}`);
+				blocks.push(`${variantSelector}.${prefix}enchanted {\n    mask-image: ${url(`${variant.image}.${baseExtension}`, urlPrefix)};\n}`);
+				upgrade.push(`${variantSelector} { background-image: ${url(`${variant.image}.${format}`, urlPrefix)}; }`);
+			}
+			if (variant.before) {
+				const variantSelector = `${selector}.${prefix}${variant.suffix}:before`;
+				const props = [`background-image: ${url(`${variant.before.image}.${baseExtension}`, urlPrefix)};`];
+				if (variant.before.mask) props.push(`mask-image: ${url(`${variant.before.mask}.${baseExtension}`, urlPrefix)};`);
+				blocks.push(`${variantSelector} {\n    ${props.join("\n    ")}\n}`);
+				upgrade.push(`${variantSelector} { background-image: ${url(`${variant.before.image}.${format}`, urlPrefix)}; }`);
+			}
+		}
+	}
+	const glintSelectors = [...enchantedSelectors, `.${prefix}enchanted:after`];
+	const glint = `${glintSelectors.join(",\n")} {\n    position: absolute;\n    width: 200%;\n    height: 200%;\n    top: -50%;\n    left: -50%;\n    image-rendering: pixelated;\n    mix-blend-mode: screen;\n    content: '';\n    opacity: 0.6;\n    background-image: ${url(`${prefix}enchantment.${baseExtension}`, urlPrefix)};\n    background-size: 512px 512px;\n    filter: blur(2px) contrast(200%);\n    transform: rotate(-8deg);\n    animation-name: ${prefix}enchanted;\n    animation-duration: 32s;\n    animation-timing-function: linear;\n    animation-iteration-count: infinite;\n}`;
+	blocks.push(glint);
+	upgrade.push(`${glintSelectors.join(", ")} { background-image: ${url(`${prefix}enchantment.${format}`, urlPrefix)}; }`);
+	if (fallback) blocks.push(`@media (min-resolution: 1dpi) {\n${upgrade.map((rule) => `    ${rule}`).join("\n")}\n}`);
+	return blocks.join("\n\n");
+}
+//#endregion
+export { itemClass as n, generateStylesheet as t };

package/dist/stylesheet-i-t_7sZ7.d.ts

@@ -0,0 +1,53 @@
+//#region src/output/stylesheet.d.ts
+/**
+ * Stylesheet generation matching the renderchest CSS contract
+ * (docs/research/css-contract.md). Differences by design: selectors are
+ * sanitized (junk mod item names once broke whole sheets), and the URL prefix
+ * is configurable so published sheets need no downstream rebasing.
+ */
+interface StylesheetOptions {
+  /** CSS class prefix, default `rc-`. */
+  prefix?: string;
+  /** Prepended to every url(); default '' = relative to the stylesheet. */
+  urlPrefix?: string;
+  /** Primary image format for the upgrade block; base rules always use png. */
+  format?: 'webp' | 'avif';
+  /** Emit the base rules in png plus a media-query upgrade block. */
+  fallback?: boolean;
+}
+interface ItemStyle {
+  /** Item id, e.g. `minecraft:stone`. */
+  id: string;
+  /** Image path relative to output root, without extension (e.g. `items/minecraft/stone`). */
+  image: string;
+  /** Custom properties set on the base rule (e.g. --rc-layer-1-tint: #9e643f). */
+  variables?: Record<string, string>;
+  /** Mask image path (defaults to none — cleared for regular items). */
+  mask?: string | null;
+  /** :before layer image, for two-layer items. */
+  before?: {
+    image: string;
+    mask?: string;
+  };
+  /**
+   * Extra selector-suffixed variants: `before` styles the pseudo-element
+   * (trims, pot overlays); `image`/`mask` restyle the base element
+   * (pot bodies, crossbow projectiles).
+   */
+  variants?: Array<{
+    suffix: string;
+    image?: string;
+    mask?: string;
+    before?: {
+      image: string;
+      mask?: string;
+    };
+  }>;
+  /** Item always shows the enchant glint (enchanted book etc.). */
+  alwaysEnchanted?: boolean;
+}
+/** Class-name sanitization is a security/robustness boundary: ids come from mod jars. */
+declare function itemClass(id: string, prefix?: string): string;
+declare function generateStylesheet(items: ItemStyle[], options?: StylesheetOptions): string;
+//#endregion
+export { itemClass as i, StylesheetOptions as n, generateStylesheet as r, ItemStyle as t };

package/dist/synthesize-CRgSEmEp.js

@@ -0,0 +1,128 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import { n as MapResourceManager } from "./synthetic-DC2bSnGe.js";
+//#region src/mods/synthesize.ts
+/**
+* Model synthesis for mods that ship textures without item models, ported from
+* the ui pipeline's synthesizeItemModels. Every rule below was earned on the
+* 419k-item modded run:
+* - a real model from the mod always beats a synthesized one;
+* - lang-declared ids filter out invented items (a mod with no lang file
+*   synthesizes everything — losing coverage is worse than a few extras);
+* - the item sprite wins name collisions with block sprites (one model per name);
+* - block textures another model draws as faces are custom geometry — wrapping
+*   a UV atlas over a cube renders scrambled, so skip;
+* - `<id>_base` block models with no `<id>` are code-built block entities, skip;
+* - face-suffixed textures (_top, _side…) are parts, not items.
+*/
+const BLOCK_FACE_SUFFIXES = [
+	"_top",
+	"_bottom",
+	"_side",
+	"_front",
+	"_back",
+	"_end",
+	"_inner",
+	"_overlay"
+];
+/** Texture directories by era: modern singular and pre-1.13 plural. */
+const ITEM_TEXTURE_DIRS = ["item", "items"];
+const BLOCK_TEXTURE_DIRS = ["block", "blocks"];
+async function textureNames(resources, namespace, directories) {
+	const names = /* @__PURE__ */ new Map();
+	for (const directory of directories) for (const locator of await resources.listResources("texture", namespace)) {
+		if (!locator.path.startsWith(`${directory}/`)) continue;
+		const name = locator.path.slice(directory.length + 1);
+		if (!names.has(name)) names.set(name, locator.path);
+	}
+	return names;
+}
+/** Ids declared by the mod's own lang file (item.<ns>.<id> / block.<ns>.<id>). */
+async function declaredItemIds(resources, namespace) {
+	const lang = await resources.getResource("lang", ResourceLocator.parse(`${namespace}:en_us`));
+	if (!lang) return null;
+	try {
+		const entries = JSON.parse(lang.toString("utf8"));
+		const declared = /* @__PURE__ */ new Set();
+		const pattern = new RegExp(String.raw`^(?:item|block)\.${namespace}\.(.+)$`);
+		for (const key of Object.keys(entries)) {
+			const match = pattern.exec(key);
+			if (match) declared.add(match[1].split(".", 1)[0]);
+		}
+		return declared;
+	} catch {
+		return null;
+	}
+}
+/** Every texture referenced as a face by any of the namespace's models. */
+async function referencedBlockTextures(resources, namespace) {
+	const used = /* @__PURE__ */ new Set();
+	for (const locator of await resources.listResources("model", namespace)) {
+		const raw = await resources.getResource("model", locator);
+		if (!raw) continue;
+		try {
+			const json = JSON.parse(raw.toString("utf8"));
+			for (const value of Object.values(json.textures ?? {})) {
+				if (typeof value !== "string" || value.startsWith("#")) continue;
+				const normalized = value.includes(":") ? value : `${namespace}:${value}`;
+				if (normalized.startsWith(`${namespace}:block/`) || normalized.startsWith(`${namespace}:blocks/`)) used.add(normalized.split("/").slice(1).join("/"));
+			}
+		} catch {}
+	}
+	return used;
+}
+async function synthesizeItemModels(resources, namespace) {
+	const output = new MapResourceManager();
+	let synthesized = 0;
+	const existingModels = /* @__PURE__ */ new Set();
+	const blockModels = /* @__PURE__ */ new Set();
+	for (const locator of await resources.listResources("model", namespace)) if (locator.path.startsWith("item/")) existingModels.add(locator.path.slice(5));
+	else if (locator.path.startsWith("block/")) blockModels.add(locator.path.slice(6));
+	const declared = await declaredItemIds(resources, namespace);
+	const wanted = (name) => !declared || declared.size === 0 || declared.has(name);
+	const itemTextures = await textureNames(resources, namespace, ITEM_TEXTURE_DIRS);
+	const blockTextures = await textureNames(resources, namespace, BLOCK_TEXTURE_DIRS);
+	const usedTextures = await referencedBlockTextures(resources, namespace);
+	const claimed = /* @__PURE__ */ new Set();
+	for (const [name, texturePath] of itemTextures) {
+		if (existingModels.has(name) || !wanted(name)) continue;
+		output.set("model", `${namespace}:item/${name}`, JSON.stringify({
+			parent: "item/generated",
+			textures: { layer0: `${namespace}:${texturePath}` }
+		}));
+		claimed.add(name);
+		synthesized++;
+	}
+	for (const [name, texturePath] of blockTextures) {
+		if (existingModels.has(name) || claimed.has(name) || !wanted(name)) continue;
+		if (BLOCK_FACE_SUFFIXES.some((suffix) => name.endsWith(suffix))) continue;
+		if (blockModels.has(name)) {
+			output.set("model", `${namespace}:item/${name}`, JSON.stringify({ parent: `${namespace}:block/${name}` }));
+			synthesized++;
+			continue;
+		}
+		if (usedTextures.has(texturePath.split("/").slice(1).join("/")) || usedTextures.has(name)) continue;
+		if (blockModels.has(`${name}_base`)) continue;
+		const directory = texturePath.split("/", 1)[0];
+		const topName = blockTextures.has(`${name}_top`) ? `${namespace}:${directory}/${name}_top` : null;
+		const sideName = blockTextures.has(`${name}_side`) ? `${namespace}:${directory}/${name}_side` : `${namespace}:${texturePath}`;
+		if (topName) output.set("model", `${namespace}:item/${name}`, JSON.stringify({
+			parent: "block/cube_bottom_top",
+			textures: {
+				top: topName,
+				bottom: topName,
+				side: sideName
+			}
+		}));
+		else output.set("model", `${namespace}:item/${name}`, JSON.stringify({
+			parent: "block/cube_all",
+			textures: { all: sideName }
+		}));
+		synthesized++;
+	}
+	return {
+		models: output,
+		synthesized
+	};
+}
+//#endregion
+export { synthesizeItemModels as t };

package/dist/synthetic-CDsj--li.d.ts

@@ -0,0 +1,34 @@
+import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
+import { a as ResourceManager, i as ResourceKindName } from "./manager-CoZaeQTu.js";
+//#region src/resources/synthetic.d.ts
+/**
+ * In-memory resources, used for era shims (synthesized `models/item/generated.json`,
+ * reshaped legacy textures) so version preparation composes as layers instead of
+ * mutating asset trees on disk like the old pipeline did.
+ */
+declare class MapResourceManager implements ResourceManager {
+  private readonly entries;
+  set(kind: ResourceKindName, locator: string | ResourceLocator, content: Buffer | string): this;
+  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[]>;
+}
+/**
+ * Restricts a manager to specific resource kinds — donor versions may only
+ * contribute geometry (models/blockstates), never textures, so borrowed shapes
+ * always render with the target version's own art.
+ */
+declare class KindFilteredResourceManager implements ResourceManager {
+  private readonly inner;
+  private readonly kinds;
+  constructor(inner: ResourceManager, kinds: ResourceKindName[]);
+  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 { MapResourceManager as n, KindFilteredResourceManager as t };

package/dist/textures/loader.d.ts

@@ -0,0 +1,2 @@
+import { a as TextureMeta, i as TextureLoader, n as AtlasResolverLike, o as TextureResolutionError, r as Texture, t as AnimatedTexture } from "../loader-TFFNV4Jl.js";
+export { AnimatedTexture, AtlasResolverLike, Texture, TextureLoader, TextureMeta, TextureResolutionError };

package/dist/textures/loader.js

@@ -0,0 +1,2 @@
+import { n as TextureLoader, r as TextureResolutionError, t as AnimatedTexture } from "../loader-CBzn3Koc.js";
+export { AnimatedTexture, TextureLoader, TextureResolutionError };

package/dist/tints-FQlxTzUL.js

@@ -0,0 +1,108 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+//#region src/render/tints.ts
+/**
+* Tint definition → color resolution for static icons, mirroring upstream's
+* Tinter classes (docs/research/renderchest-spec.md §8).
+*/
+var InvalidTinterDefinitionError = class extends Error {};
+/** The 16 dye colors upstream's renderchest:random picks from. */
+const DYE_COLORS = [
+	"#f9fffe",
+	"#f9801d",
+	"#c74ebd",
+	"#3ab3da",
+	"#fed83d",
+	"#80c71f",
+	"#f38baa",
+	"#474f52",
+	"#9d9d97",
+	"#169c9c",
+	"#8932b8",
+	"#3c44aa",
+	"#835432",
+	"#5e7c16",
+	"#b02e26",
+	"#1d1d21"
+];
+function hexColor(hex) {
+	return {
+		r: Number.parseInt(hex.slice(1, 3), 16) / 255,
+		g: Number.parseInt(hex.slice(3, 5), 16) / 255,
+		b: Number.parseInt(hex.slice(5, 7), 16) / 255
+	};
+}
+/**
+* Upstream constant-tint parsing: null/-1 → no tint; int → ARGB packed
+* (alpha ignored for tinting — tintImage uses the pixel's own alpha);
+* [r,g,b] floats. Anything else throws.
+*/
+function parseTintValue(value) {
+	if ([
+		null,
+		void 0,
+		-1
+	].includes(value)) return null;
+	if (typeof value === "number") return {
+		r: (value >>> 16 & 255) / 255,
+		g: (value >>> 8 & 255) / 255,
+		b: (value & 255) / 255
+	};
+	if (Array.isArray(value) && value.length >= 3 && value.every((entry) => typeof entry === "number")) return {
+		r: value[0],
+		g: value[1],
+		b: value[2]
+	};
+	throw new InvalidTinterDefinitionError(`Unparseable tint value: ${JSON.stringify(value)}`);
+}
+const DEFAULT_READING_TYPES = /* @__PURE__ */ new Set([
+	"minecraft:dye",
+	"minecraft:firework",
+	"minecraft:potion",
+	"minecraft:map_color",
+	"minecraft:team"
+]);
+async function resolveTint(definition, context) {
+	const type = definition.type.includes(":") ? definition.type : `minecraft:${definition.type}`;
+	switch (type) {
+		case "minecraft:constant": return parseTintValue(definition.value);
+		case "minecraft:custom_model_data": return null;
+		case "minecraft:grass": {
+			const temperature = clamp01(typeof definition.temperature === "number" ? definition.temperature : .5);
+			const downfall = clamp01(typeof definition.downfall === "number" ? definition.downfall : 1);
+			return sampleColorMap(context.textures, "minecraft:colormap/grass", 1 - temperature, 1 - downfall * temperature);
+		}
+		case "renderchest:random": {
+			const index = context.randomIndex ?? Math.floor(Math.random() * DYE_COLORS.length);
+			return hexColor(DYE_COLORS[index % DYE_COLORS.length]);
+		}
+		default:
+			if (DEFAULT_READING_TYPES.has(type)) return parseTintValue(definition.default);
+			throw new InvalidTinterDefinitionError(`Unknown tint type: ${definition.type}`);
+	}
+}
+async function resolveTints(definitions, context) {
+	const colors = [];
+	for (const definition of definitions) colors.push(await resolveTint(definition, context));
+	return colors;
+}
+function clamp01(value) {
+	return value < 0 ? 0 : Math.min(value, 1);
+}
+/** Sample coordinates are clamped into the map; a missing map falls back to magenta. */
+async function sampleColorMap(textures, locator, sampleX, sampleY) {
+	const texture = await textures.load(ResourceLocator.parse(locator));
+	if (!texture) return {
+		r: 1,
+		g: 0,
+		b: 1
+	};
+	const x = Math.min(texture.width - 1, Math.max(0, Math.floor(sampleX * texture.width)));
+	const offset = (Math.min(texture.height - 1, Math.max(0, Math.floor(sampleY * texture.height))) * texture.width + x) * 4;
+	return {
+		r: texture.data[offset] / 255,
+		g: texture.data[offset + 1] / 255,
+		b: texture.data[offset + 2] / 255
+	};
+}
+//#endregion
+export { resolveTints as a, resolveTint as i, InvalidTinterDefinitionError as n, parseTintValue as r, DYE_COLORS as t };

package/dist/tints-Fr6WoPaU.d.ts

@@ -0,0 +1,22 @@
+import { i as TextureLoader } from "./loader-TFFNV4Jl.js";
+import { n as TintColor } from "./face-DC6cNMdz.js";
+import { o as TintDefinition } from "./definition-BwX6Xxv0.js";
+//#region src/render/tints.d.ts
+declare class InvalidTinterDefinitionError extends Error {}
+/** The 16 dye colors upstream's renderchest:random picks from. */
+declare const DYE_COLORS: readonly ["#f9fffe", "#f9801d", "#c74ebd", "#3ab3da", "#fed83d", "#80c71f", "#f38baa", "#474f52", "#9d9d97", "#169c9c", "#8932b8", "#3c44aa", "#835432", "#5e7c16", "#b02e26", "#1d1d21"];
+/**
+ * Upstream constant-tint parsing: null/-1 → no tint; int → ARGB packed
+ * (alpha ignored for tinting — tintImage uses the pixel's own alpha);
+ * [r,g,b] floats. Anything else throws.
+ */
+declare function parseTintValue(value: unknown): TintColor | null;
+interface TintContext {
+  textures: TextureLoader;
+  /** Deterministic replacement for upstream's random dye pick, keyed per item. */
+  randomIndex?: number;
+}
+declare function resolveTint(definition: TintDefinition, context: TintContext): Promise<TintColor | null>;
+declare function resolveTints(definitions: TintDefinition[], context: TintContext): Promise<Array<TintColor | null>>;
+//#endregion
+export { resolveTint as a, parseTintValue as i, InvalidTinterDefinitionError as n, resolveTints as o, TintContext as r, DYE_COLORS as t };

package/dist/types-COGbtA1t.d.ts

@@ -0,0 +1,69 @@
+//#region src/models/types.d.ts
+/**
+ * Raw Minecraft block/item model JSON, as found in `assets/<ns>/models/`.
+ * Field semantics: https://minecraft.wiki/w/Model — stable since 1.8, with
+ * `gui_light` added in 1.15 and loader-specific extensions ignored here.
+ */
+type Vec3 = [number, number, number];
+type Vec4 = [number, number, number, number];
+declare const FaceDirection: {
+  readonly down: "down";
+  readonly up: "up";
+  readonly north: "north";
+  readonly south: "south";
+  readonly west: "west";
+  readonly east: "east";
+};
+type FaceDirectionName = keyof typeof FaceDirection;
+interface ModelFaceJson {
+  /** Texture reference (`#name`) or direct locator. */
+  texture: string;
+  /** [x1, y1, x2, y2] in 0–16 texture space; derived from the element bounds when absent. */
+  uv?: Vec4;
+  cullface?: string;
+  /** UV rotation in degrees: 0, 90, 180, 270. */
+  rotation?: number;
+  /** Index into the model's tint layers; -1/absent = untinted. */
+  tintindex?: number;
+}
+interface ElementRotationJson {
+  origin: Vec3;
+  axis: 'x' | 'y' | 'z';
+  /** -45 to 45 in 22.5 steps in vanilla; mods ship arbitrary angles. */
+  angle: number;
+  rescale?: boolean;
+}
+interface ModelElementJson {
+  /** Corner coordinates in 0–16 block space (mods exceed the range). */
+  from: Vec3;
+  to: Vec3;
+  rotation?: ElementRotationJson;
+  shade?: boolean;
+  light_emission?: number;
+  faces: Partial<Record<FaceDirectionName, ModelFaceJson>>;
+}
+interface DisplayTransformJson {
+  /** Degrees, applied x then y then z. */
+  rotation?: Vec3;
+  translation?: Vec3;
+  scale?: Vec3;
+}
+type DisplayPosition = 'gui' | 'ground' | 'fixed' | 'head' | 'firstperson_righthand' | 'firstperson_lefthand' | 'thirdperson_righthand' | 'thirdperson_lefthand';
+interface ModelJson {
+  parent?: string;
+  ambientocclusion?: boolean;
+  /** `front` renders items like flat sprites, `side` like blocks. */
+  gui_light?: 'front' | 'side';
+  display?: Partial<Record<DisplayPosition, DisplayTransformJson>>;
+  /** name → locator or `#reference`. */
+  textures?: Record<string, string>;
+  elements?: ModelElementJson[];
+  overrides?: Array<{
+    predicate: Record<string, number>;
+    model: string;
+  }>;
+  /** Loader-specific extension point (forge/neoforge); handled by the mods layer. */
+  loader?: string;
+}
+//#endregion
+export { FaceDirectionName as a, ModelJson as c, FaceDirection as i, Vec3 as l, DisplayTransformJson as n, ModelElementJson as o, ElementRotationJson as r, ModelFaceJson as s, DisplayPosition as t, Vec4 as u };