@nodecraft/rendermite 1.4.1 → 1.6.0

package/dist/model-code-B7jSFQqd.d.ts

@@ -0,0 +1,16 @@
+import { t as ClassFile } from "./classfile-BwaQjnUM.js";
+//#region src/entities/model-code.d.ts
+interface ModelCode {
+  /** The parsed class, when it is model code a call may be followed into. */
+  resolve: (internalName: string) => ClassFile | null;
+}
+declare function isModelCode(name: string): boolean;
+/**
+ * Reads every model class in a jar, ready to interpret.
+ *
+ * Read up front because interpretation is synchronous and a call's target is only known once it is
+ * reached. Parsing stays lazy: a jar has a few hundred of these and a model only ever calls a handful.
+ */
+declare function loadModelCode(names: Iterable<string>, read: (internalName: string) => Promise<Uint8Array | null>, originalOf?: (internalName: string) => string): Promise<ModelCode>;
+//#endregion
+export { isModelCode as n, loadModelCode as r, ModelCode as t };

package/dist/model-code-BKMEMXxF.js

@@ -0,0 +1,49 @@
+import { t as parseClassFile } from "./classfile-CAhS5qNf.js";
+//#region src/entities/model-code.ts
+/**
+* Which classes in a jar count as model code, and their parsed form.
+*
+* The interpreter follows calls into model code and models the builder API abstractly instead, so the
+* line between the two has to be drawn somewhere. It is drawn by name: everything with `model` in its
+* path except the `client.model.geom` package, which is `CubeListBuilder`, `PartDefinition`, `PartPose`
+* and friends. Following `CubeListBuilder.addBox` into its real implementation would interpret a list
+* append and lose the box.
+*
+* The name tested is the *original* one, so an obfuscated jar needs its mappings. Which is fine: they
+* are already loaded to find the model classes at all.
+*/
+function isModelCode(name) {
+	const lower = name.toLowerCase();
+	return lower.includes("model") && !lower.includes("geom");
+}
+/**
+* Reads every model class in a jar, ready to interpret.
+*
+* Read up front because interpretation is synchronous and a call's target is only known once it is
+* reached. Parsing stays lazy: a jar has a few hundred of these and a model only ever calls a handful.
+*/
+async function loadModelCode(names, read, originalOf) {
+	const code = /* @__PURE__ */ new Map();
+	for (const name of names) {
+		if (!isModelCode(originalOf?.(name) ?? name)) continue;
+		const bytes = await read(name);
+		if (bytes) code.set(name.replaceAll(".", "/"), bytes);
+	}
+	const parsed = /* @__PURE__ */ new Map();
+	return { resolve: (name) => {
+		const internalName = name.replaceAll(".", "/");
+		if (!parsed.has(internalName)) {
+			const bytes = code.get(internalName);
+			let classFile;
+			try {
+				classFile = bytes ? parseClassFile(bytes) : null;
+			} catch {
+				classFile = null;
+			}
+			parsed.set(internalName, classFile);
+		}
+		return parsed.get(internalName) ?? null;
+	} };
+}
+//#endregion
+export { loadModelCode as n, isModelCode as t };

package/dist/mods/prepare.js

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

package/dist/mods/tints.js

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

package/dist/{obj-bvs3gwex.js → obj-CJHEHpki.js}

@@ -1,13 +1,13 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
 import { l as toFloatTexture, n as cloneFloatTexture, r as darkenTexture, s as tintTexture, t as blendPixel } from "./blend-KXMclcHk.js";
+import { t as combineFaceBuffers } from "./compose-BGsNFR12.js";
+import { a as drawTexturedTriangle, i as createFaceBuffer, n as clearFaceBuffer, o as phpRound, t as RowCursor } from "./rasterizer-DcVJzkxz.js";
 import { c as normalize, g as transformVector, m as sub, n as displayMatrix, o as identity, r as dot, s as multiply, t as cross } from "./vector-CCxLae_T.js";
+import { n as faceMaxZ, r as renderFace, t as createShadeCache } from "./face-B2JjWT46.js";
 import { c as lightsForProfile } from "./lighting--5myudVu.js";
-import { a as drawTexturedTriangle, i as createFaceBuffer, n as clearFaceBuffer, o as phpRound, t as RowCursor } from "./rasterizer-DcVJzkxz.js";
-import { t as combineFaceBuffers } from "./compose-BGsNFR12.js";
-import { n as faceMaxZ, r as renderFace, t as createShadeCache } from "./face-CKHboPfh.js";
+import { i as resolveTexture } from "./loader-C-NuJaEi.js";
 import { t as paintBucketFluid } from "./fluid-bucket-B-I4ZYHl.js";
 import { r as buildElementFaces } from "./geometry-Bi-Bf5rb.js";
-import { i as resolveTexture } from "./loader-C-NuJaEi.js";
 //#region src/render/renderer.ts
 /**
 * Item rendering entry: flat generated items (2D layer compositing) and 3D

package/dist/{obj-mesh-rnYbSbpv.js → obj-mesh-JwPkZEWL.js}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
-import { n as parseMtl, r as parseObj, t as materialTexture } from "./obj-bvs3gwex.js";
+import { n as parseMtl, r as parseObj, t as materialTexture } from "./obj-CJHEHpki.js";
 //#region src/blocks/obj-mesh.ts
 /**
 * OBJ geometry as pack data.

package/dist/pack-format-QcVFxG_b.d.ts

@@ -0,0 +1,280 @@
+import { n as BiomeClimatePack } from "./biomes-CJDJQqJb.js";
+import { a as FaceDirectionName, l as Vec3, o as ModelElementJson, u as Vec4 } from "./types-qlp3I8_-.js";
+import { a as BlockStateMultipartCase, o as BlockStateVariantCase } from "./blockstate-eval-BzznRcVY.js";
+import { t as MeshGroup } from "./obj-mesh-ydhVfLKs.js";
+import { n as BlockTintPack } from "./tints-DoBv5S9v.js";
+//#region src/blocks/pack-format.d.ts
+/** How a sprite's alpha classifies it, inferred because assets rarely say. */
+type BlockPackRenderLayer = 'solid' | 'cutout' | 'translucent';
+interface BlockPackFace {
+  sprite: string;
+  /** [u1, v1, u2, v2] in 0–16 sprite space, derived when the model omits it. */
+  uv: Vec4;
+  rotation?: number;
+  tintindex?: number;
+  cullface?: FaceDirectionName;
+}
+interface BlockPackElement {
+  from: Vec3;
+  to: Vec3;
+  rotation?: ModelElementJson['rotation'];
+  shade?: false;
+  faces: Partial<Record<FaceDirectionName, BlockPackFace>>;
+}
+interface BlockPackModel {
+  ao: boolean;
+  elements: BlockPackElement[];
+  /**
+   * The model's `particle` texture. What the game throws when the block breaks
+   * or is walked on, and the only colour a consumer has to work with for a
+   * block that draws nothing — a placeholder cube for a chest comes out oak
+   * rather than magenta.
+   */
+  particle?: string;
+  /** Triangle geometry from an OBJ loader, when the model uses one. */
+  mesh?: MeshGroup[];
+  /**
+   * The layer the model states it draws on. Authoritative where present, and
+   * it beats the per-sprite alpha inference — the same sprite can be solid in
+   * one model and translucent in another.
+   */
+  renderType?: BlockPackRenderLayer;
+  /** Block offsets a split-multiblock mesh spans. */
+  multiblock?: Array<[number, number, number]>;
+  /**
+   * Present when the block is a fluid, whose real surface height and flow
+   * direction come from its neighbours and so cannot be baked. The cube here is
+   * a stand-in; these are the sheets to mesh the real thing with.
+   */
+  fluid?: {
+    still: string;
+    flow: string;
+    overlay?: string;
+  };
+}
+interface BlockPackSpriteFrame {
+  page: number;
+  x: number;
+  y: number;
+  /** Duration in game ticks. */
+  time: number;
+}
+interface BlockPackSprite {
+  page: number;
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  layer: BlockPackRenderLayer;
+  /** The displayed sequence, which can revisit a frame; absent when static. */
+  frames?: BlockPackSpriteFrame[];
+  interpolate?: true;
+}
+interface BlockPackAtlasPage {
+  file: string;
+  width: number;
+  height: number;
+}
+/** `atlas.json`. */
+interface BlockPackAtlasFile {
+  /** Edge-extended border per sprite, in pixels. */
+  padding: number;
+  pages: BlockPackAtlasPage[];
+  sprites: Record<string, BlockPackSprite>;
+}
+/** `models.json`, by fully-qualified model id. */
+type BlockPackModelsFile = Record<string, BlockPackModel>;
+/** `blockstates.json`, by block id, with keys and predicates already parsed. */
+type BlockPackBlockStatesFile = Record<string, BlockPackBlockState>;
+/**
+ * A variant as the pack writes it. Every rotation is optional because the emit
+ * drops each one at its default, which is most of them.
+ */
+interface BlockPackVariant {
+  model: string;
+  x?: number;
+  y?: number;
+  z?: number;
+  uvlock?: true;
+  weight?: number;
+}
+/**
+ * One block's cases as the pack writes them: what `evaluateBlockState` takes,
+ * flattened to the key the file uses. Pass it as
+ * `{ kind: 'variants', cases: state.variants }` and the models come back as
+ * `BlockPackVariant`, no cast in either direction.
+ */
+type BlockPackBlockState = {
+  variants: Array<BlockStateVariantCase<BlockPackVariant>>;
+  multipart?: undefined;
+} | {
+  multipart: Array<BlockStateMultipartCase<BlockPackVariant>>;
+  variants?: undefined;
+};
+/** `tints.json`. */
+type BlockPackTintsFile = BlockTintPack;
+/**
+ * `biomes.json`, present only when the pack has biomes to describe: vanilla's
+ * whole table, or the ones a mod's datapack declares. Absent is not empty — a
+ * consumer with no file falls back to tinting at `tints.json`'s flat climate.
+ */
+type BlockPackBiomesFile = BiomeClimatePack;
+/** One flat sprite of an item's layer stack, in the order the client draws them. */
+interface ItemPackLayer {
+  sprite: string;
+  /**
+   * Present when the item declares a tint at this layer, which is the client's own
+   * rule: `ItemModelGenerator` passes each layer its own index as the tint index.
+   */
+  tintindex?: number;
+  /**
+   * The colour that tint resolves to in an item's default state, `#rrggbb`.
+   *
+   * Absent where it cannot be known from assets — a dyed leather boot or a potion
+   * takes its colour from the stack's components, which no pack can carry. A
+   * consumer drawing an absent tint untinted gets the mod's own artwork, which is
+   * the same thing the icon renderer settles for.
+   */
+  tint?: string;
+}
+/** One flat item: everything there is to say about how the game draws it. */
+interface ItemPackEntry {
+  layers: ItemPackLayer[];
+}
+/**
+ * `items.json`. Self-contained rather than sharing `atlas.json`'s pages, so a
+ * consumer that only draws blocks never fetches the item sheet at all — a world
+ * viewer needs it only once it finds a dropped stack of something that is not a
+ * block.
+ *
+ * Holds *only* items whose model is a flat sprite stack. An item absent from
+ * `items` either draws from `blockstates.json` under the same id, or is in
+ * `failures.json` saying why nothing can draw it.
+ */
+interface BlockPackItemsFile {
+  /** Edge-extended border per sprite, in pixels. */
+  padding: number;
+  pages: BlockPackAtlasPage[];
+  sprites: Record<string, BlockPackSprite>;
+  items: Record<string, ItemPackEntry>;
+}
+/**
+ * One entity type: what to call it, and what colour it is.
+ *
+ * No geometry, because no jar has any — entity models are Java code at every version. What a consumer
+ * can do with this is name the stand-in box it draws and tint it like the animal, which is the
+ * difference between a field of arbitrary colours and a readable one.
+ */
+interface EntityPackEntry {
+  /** English display name, from the jar's own lang file. */
+  name: string;
+  /**
+   * Mean colour of the opaque pixels of the entity's sheet, `#rrggbb`.
+   *
+   * Absent for everything that is not a mob — an item entity, a falling block, a marker, a display,
+   * a thrown projectile — because those draw from an item or a block and have no sheet of their own.
+   * None is invented for them.
+   */
+  color?: string;
+  /**
+   * The sheet the colour came from, and what the model's `uv` values address. A sprite id in
+   * `entity-models.json`'s atlas once that file is present.
+   */
+  texture?: string;
+  /** Key into `entity-models.json`'s `models`, when geometry was recovered for this entity. */
+  model?: string;
+}
+/**
+ * `entities.json`, by entity id. The registry read off the lang file, which is the closest thing a jar
+ * carries to it. Absent from a pack whose namespaces register no entities.
+ */
+type BlockPackEntitiesFile = Record<string, EntityPackEntry>;
+/** One box of a part, in the model's own space, exactly as the game's own builder stated it. */
+/** The six faces a box can carry its own texture rect on. */
+type EntityPackCubeFace = 'north' | 'south' | 'east' | 'west' | 'up' | 'down';
+interface EntityPackCube {
+  /** Minimum corner. */
+  origin: Vec3;
+  size: Vec3;
+  /** Texture offset in pixels on the entity's own sheet, as `texOffs` set it. */
+  uv: [number, number];
+  /** Grows the box on every side; `CubeDeformation`, or a builder's `delta`. */
+  inflate?: number;
+  mirror?: true;
+  /**
+   * Per-face texture rects, which replace the box unwrap `uv` implies wherever they are present.
+   *
+   * Java has no such thing, since `addBox` always unwraps the same way, but bedrock geometry does and
+   * leans on it: 56% of the cubes across four GeckoLib mods state their faces individually. A consumer
+   * that ignores this draws over half of every such mob from the wrong part of its sheet.
+   */
+  faces?: Partial<Record<EntityPackCubeFace, {
+    uv: [number, number];
+    size: [number, number];
+  }>>;
+}
+/** One bone: where it pivots, what it is made of, and what hangs off it. */
+interface EntityPackPart {
+  name: string;
+  /** Pivot relative to the parent bone. */
+  pivot: Vec3;
+  /** Radians about x, y, z, as `PartPose.offsetAndRotation` states them. */
+  rotation: Vec3;
+  cubes: EntityPackCube[];
+  children: EntityPackPart[];
+}
+/**
+ * One entity model: a bone hierarchy of boxes, recovered from the client's own code.
+ *
+ * `textureSize` is the sheet the `uv` values are in, which is *not* the atlas page — a consumer maps
+ * `uv` through it into the sprite's rect, exactly as it does for a block face.
+ *
+ * **Prefer the sprite's own `w`/`h` where the entity has one**, and keep this as the fallback. One
+ * model can be drawn on two differently sized sheets: from 1.21.4 a boat and a chest boat are both a
+ * `BoatModel`, on a 128x64 and a 128x128 sheet respectively, so no single value here is right for both.
+ */
+interface EntityPackModel {
+  textureSize: [number, number];
+  parts: EntityPackPart[];
+  /** Anything the extraction had to skip or assume, so a consumer can distrust it knowingly. */
+  notes?: string[];
+}
+/**
+ * `entity-models.json`. Self-contained like `items.json`, with its own atlas of entity sheets, so a
+ * consumer that never draws a mob does not fetch any of it.
+ *
+ * `models` is keyed by the class the geometry came from, and `entities.json`'s `model` points at it —
+ * several entities share one model (every zombie is a `HumanoidModel`), and keying by class is what
+ * makes that one entry rather than twenty copies.
+ */
+interface BlockPackEntityModelsFile {
+  padding: number;
+  pages: BlockPackAtlasPage[];
+  sprites: Record<string, BlockPackSprite>;
+  models: Record<string, EntityPackModel>;
+}
+/** `meta.json`, written last because it hashes every other file. */
+interface BlockPackMetaFile {
+  generator: string;
+  version: string;
+  namespaces: string[];
+  counts: {
+    blocks: number;
+    models: number;
+    sprites: number;
+    pages: number;
+    /** Biomes in `biomes.json`; `0` means the pack has none and the file is absent. */
+    biomes: number;
+    /** Flat items in `items.json`; `0` means the pack has none and the file is absent. */
+    items: number;
+    /** Entity types in `entities.json`; `0` means the pack has none and the file is absent. */
+    entities: number;
+    /** Distinct entity models in `entity-models.json`; `0` means the file is absent. */
+    entityModels: number;
+    failures: number;
+  };
+  /** sha256 per file, enough to verify a cached copy without refetching it. */
+  hashes: Record<string, string>;
+}
+//#endregion
+export { EntityPackPart as C, EntityPackModel as S, ItemPackLayer as T, BlockPackTintsFile as _, BlockPackBlockStatesFile as a, EntityPackCubeFace as b, BlockPackEntityModelsFile as c, BlockPackMetaFile as d, BlockPackModel as f, BlockPackSpriteFrame as g, BlockPackSprite as h, BlockPackBlockState as i, BlockPackFace as l, BlockPackRenderLayer as m, BlockPackAtlasPage as n, BlockPackElement as o, BlockPackModelsFile as p, BlockPackBiomesFile as r, BlockPackEntitiesFile as s, BlockPackAtlasFile as t, BlockPackItemsFile as u, BlockPackVariant as v, ItemPackEntry as w, EntityPackEntry as x, EntityPackCube as y };

package/dist/pack.d.ts

@@ -2,5 +2,5 @@ import { n as BiomeClimatePack, t as BiomeClimate } from "./biomes-CJDJQqJb.js";
 import { a as BlockStateMultipartCase, d as matchesCondition, n as BlockProperties, o as BlockStateVariantCase, p as weightedVariantIndex, r as BlockStateDefinition, s as MultipartCondition, t as BlockModelVariant, u as evaluateBlockState } from "./blockstate-eval-BzznRcVY.js";
 import { n as ObjMesh, t as MeshGroup } from "./obj-mesh-ydhVfLKs.js";
 import { n as BlockTintPack, t as BlockTint } from "./tints-DoBv5S9v.js";
-import { a as BlockPackBlockStatesFile, c as BlockPackMetaFile, d as BlockPackRenderLayer, f as BlockPackSprite, h as BlockPackVariant, i as BlockPackBlockState, l as BlockPackModel, m as BlockPackTintsFile, n as BlockPackAtlasPage, o as BlockPackElement, p as BlockPackSpriteFrame, r as BlockPackBiomesFile, s as BlockPackFace, t as BlockPackAtlasFile, u as BlockPackModelsFile } from "./pack-format-BVC_B-ZW.js";
+import { _ as BlockPackTintsFile, a as BlockPackBlockStatesFile, d as BlockPackMetaFile, f as BlockPackModel, g as BlockPackSpriteFrame, h as BlockPackSprite, i as BlockPackBlockState, l as BlockPackFace, m as BlockPackRenderLayer, n as BlockPackAtlasPage, o as BlockPackElement, p as BlockPackModelsFile, r as BlockPackBiomesFile, t as BlockPackAtlasFile, v as BlockPackVariant } from "./pack-format-QcVFxG_b.js";
 export { type BiomeClimate, type BiomeClimatePack, type BlockModelVariant, type BlockPackAtlasFile, type BlockPackAtlasPage, type BlockPackBiomesFile, type BlockPackBlockState, type BlockPackBlockStatesFile, type BlockPackElement, type BlockPackFace, type BlockPackMetaFile, type BlockPackModel, type BlockPackModelsFile, type BlockPackRenderLayer, type BlockPackSprite, type BlockPackSpriteFrame, type BlockPackTintsFile, type BlockPackVariant, type BlockProperties, type BlockStateDefinition, type BlockStateMultipartCase, type BlockStateVariantCase, type BlockTint, type BlockTintPack, type MeshGroup, type MultipartCondition, type ObjMesh, evaluateBlockState, matchesCondition, weightedVariantIndex };

package/dist/{pipeline-B8e6x8Hh.js → pipeline-BUIMzMzg.js}

@@ -1,18 +1,18 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
 import { l as toFloatTexture, t as blendPixel } from "./blend-KXMclcHk.js";
+import { a as renderGeo, t as findGeoForItem } from "./geo-Desq-gRC.js";
+import { a as defaultProperties } from "./definition-ColsvWrH.js";
+import { i as resolveItem } from "./discovery-CD0QqxSF.js";
 import { t as ModelLoader } from "./loader-C-NuJaEi.js";
-import { c as renderModel, l as renderModelFrames, o as boxDownscale, s as pointResize } from "./obj-bvs3gwex.js";
+import { a as resolveTints } from "./tints-B3WQcPtx.js";
+import { c as renderModel, l as renderModelFrames, o as boxDownscale, s as pointResize } from "./obj-CJHEHpki.js";
 import { t as loadAtlasResolver } from "./registry-DlduyjtM.js";
 import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
 import { n as TextureLoader } from "./loader-C18GpurU.js";
-import { a as defaultProperties } from "./definition-ColsvWrH.js";
-import { r as resolveItem } from "./discovery-CsZu08re.js";
 import { t as encodeAnimatedIcon } from "./encode-LR9wxigC.js";
 import { a as builtinDynamicResources } from "./generators-BCZVlWig.js";
-import { a as spawnEggTints, i as renderEntityFallback, n as dyedVariantTint, r as renderDyedVariantFallback, t as dyeVariantName } from "./entity-fallback-BTkM8j0V.js";
-import { i as renderGeo, t as findGeoForItem } from "./geo-BguldlU-.js";
+import { a as spawnEggTints, i as renderEntityFallback, n as dyedVariantTint, r as renderDyedVariantFallback, t as dyeVariantName } from "./entity-fallback-Bth0fa7m.js";
 import { t as legacyTintsForChain } from "./legacy-tints-l-541wgI.js";
-import { a as resolveTints } from "./tints-B3WQcPtx.js";
 import { n as defaultBlockStateModel, t as blockStateTransform } from "./blockstate-DVb8Mhxc.js";
 import path from "node:path";
 import { mkdir, writeFile } from "node:fs/promises";

package/dist/{prepare-C9gjqQTt.js → prepare-Myd_ec4v.js}

@@ -1,8 +1,8 @@
 import { n as LayeredResourceManager } from "./manager-BNibYkmI.js";
+import { n as UnsafeJarError, t as JarResourceManager } from "./jar-W2cV2ZVO.js";
 import { t as curatedModelOverrides } from "./models-CZjCOjs4.js";
 import { t as synthesizeItemModels } from "./synthesize-jTjVjPAt.js";
-import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-C1tT6pKk.js";
-import { n as UnsafeJarError, t as JarResourceManager } from "./jar-W2cV2ZVO.js";
+import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-BspVCz2G.js";
 //#region src/mods/prepare.ts
 /**
 * Mod asset composition: mod jars layered under the vanilla base (vanilla wins

package/dist/render/entity-fallback.js

@@ -1,2 +1,2 @@
-import { a as spawnEggTints, i as renderEntityFallback, n as dyedVariantTint, r as renderDyedVariantFallback, t as dyeVariantName } from "../entity-fallback-BTkM8j0V.js";
+import { a as spawnEggTints, i as renderEntityFallback, n as dyedVariantTint, r as renderDyedVariantFallback, t as dyeVariantName } from "../entity-fallback-Bth0fa7m.js";
 export { dyeVariantName, dyedVariantTint, renderDyedVariantFallback, renderEntityFallback, spawnEggTints };

package/dist/render/face.js

@@ -1,2 +1,2 @@
-import { n as faceMaxZ, r as renderFace, t as createShadeCache } from "../face-CKHboPfh.js";
+import { n as faceMaxZ, r as renderFace, t as createShadeCache } from "../face-B2JjWT46.js";
 export { createShadeCache, faceMaxZ, renderFace };

package/dist/render/geo.d.ts

@@ -1,54 +1,2 @@
-import { n as ResourceLocator } from "../locator-jDbdUeTd.js";
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { i as TextureLoader } from "../loader-DUlx29PC.js";
-import { n as FloatTexture } from "../blend-eT64Z6qm.js";
-import { n as FaceGeometry } from "../geometry-Bkur58Vi.js";
-import { i as RenderOptions } from "../renderer-C_DFi8DF.js";
-//#region src/render/geo.d.ts
-interface GeoCube {
-  origin?: number[];
-  size?: number[];
-  uv?: number[] | Record<string, {
-    uv: number[];
-    uv_size?: number[];
-  }>;
-  inflate?: number;
-  pivot?: number[];
-  rotation?: number[];
-}
-interface GeoBone {
-  name?: string;
-  parent?: string;
-  pivot?: number[];
-  rotation?: number[];
-  cubes?: GeoCube[];
-}
-interface GeoDescription {
-  texture_width?: number;
-  texture_height?: number;
-}
-interface GeoFile {
-  'minecraft:geometry'?: Array<{
-    description?: GeoDescription;
-    bones?: GeoBone[];
-  }>;
-  [key: string]: unknown;
-}
-interface ParsedGeo {
-  textureWidth: number;
-  textureHeight: number;
-  bones: GeoBone[];
-}
-/** Handles both the modern (1.12+) and legacy (`geometry.name` keyed) layouts. */
-declare function parseGeo(json: GeoFile): ParsedGeo | null;
-/** Convert a parsed geo into face geometry, unit-cube fitted with gui pose. */
-declare function geoToFaces(geo: ParsedGeo): FaceGeometry[];
-/** Conventional locations GeckoLib mods keep item geometry and textures. */
-declare function findGeoForItem(resources: ResourceManager, id: string): Promise<{
-  geo: ParsedGeo;
-  texture: ResourceLocator;
-} | null>;
-/** Render a parsed geo with the standard block gui pose. */
-declare function renderGeo(geo: ParsedGeo, texture: ResourceLocator, textures: TextureLoader, options: RenderOptions): Promise<FloatTexture | null>;
-//#endregion
-export { findGeoForItem, geoToFaces, parseGeo, renderGeo };
+import { a as parseGeo, i as nameTokens, n as findGeoForItem, o as renderGeo, r as geoToFaces, t as ParsedGeo } from "../geo-CmjrXu0G.js";
+export { ParsedGeo, findGeoForItem, geoToFaces, nameTokens, parseGeo, renderGeo };

package/dist/render/geo.js

@@ -1,2 +1,2 @@
-import { i as renderGeo, n as geoToFaces, r as parseGeo, t as findGeoForItem } from "../geo-BguldlU-.js";
-export { findGeoForItem, geoToFaces, parseGeo, renderGeo };
+import { a as renderGeo, i as parseGeo, n as geoToFaces, r as nameTokens, t as findGeoForItem } from "../geo-Desq-gRC.js";
+export { findGeoForItem, geoToFaces, nameTokens, parseGeo, renderGeo };

package/dist/render/obj.js

@@ -1,2 +1,2 @@
-import { i as renderObjModel, n as parseMtl, r as parseObj, t as materialTexture } from "../obj-bvs3gwex.js";
+import { i as renderObjModel, n as parseMtl, r as parseObj, t as materialTexture } from "../obj-CJHEHpki.js";
 export { materialTexture, parseMtl, parseObj, renderObjModel };

package/dist/render/pipeline.js

@@ -1,2 +1,2 @@
-import { t as ItemPipeline } from "../pipeline-B8e6x8Hh.js";
+import { t as ItemPipeline } from "../pipeline-BUIMzMzg.js";
 export { ItemPipeline };

package/dist/render/renderer.js

@@ -1,2 +1,2 @@
-import { a as ItemRenderError, c as renderModel, l as renderModelFrames, o as boxDownscale, s as pointResize } from "../obj-bvs3gwex.js";
+import { a as ItemRenderError, c as renderModel, l as renderModelFrames, o as boxDownscale, s as pointResize } from "../obj-CJHEHpki.js";
 export { ItemRenderError, boxDownscale, pointResize, renderModel, renderModelFrames };

package/dist/resources/descriptor.js

@@ -1,2 +1,2 @@
-import { n as restoreResources, t as describeResources } from "../descriptor-D7VKgeGT.js";
+import { n as restoreResources, t as describeResources } from "../descriptor-JyXhfd-c.js";
 export { describeResources, restoreResources };

package/dist/{run-B_JAUbXe.js → run-BQJkqc5f.js}

@@ -1,13 +1,13 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
+import { n as discoverItems } from "./discovery-CD0QqxSF.js";
 import { n as LayeredResourceManager } from "./manager-BNibYkmI.js";
 import { t as curatedModelOverrides } from "./models-CZjCOjs4.js";
-import { n as discoverItems } from "./discovery-CsZu08re.js";
 import { r as encodeRasterAsset } from "./encode-LR9wxigC.js";
 import { t as classifyItemStyle } from "./item-styles-DjYRdyHi.js";
 import { t as minifyStylesheet } from "./minify-bjMRmr5J.js";
 import { t as generateStylesheet } from "./stylesheet-CovT3B2S.js";
-import { t as ItemPipeline } from "./pipeline-B8e6x8Hh.js";
-import { t as describeResources } from "./descriptor-D7VKgeGT.js";
+import { t as ItemPipeline } from "./pipeline-BUIMzMzg.js";
+import { t as describeResources } from "./descriptor-JyXhfd-c.js";
 import { t as WorkerRenderPool } from "./pool-CKGp1qup.js";
 import path from "node:path";
 import os from "node:os";

package/dist/run.js

@@ -1,3 +1,3 @@
 import { o as evaluateItemModel } from "./definition-ColsvWrH.js";
-import { t as run } from "./run-B_JAUbXe.js";
+import { t as run } from "./run-BQJkqc5f.js";
 export { evaluateItemModel, run };