minerender 2.1.0-alpha.59 → 2.1.0-alpha.60

package/dist/browser/index.js

@@ -1085,6 +1085,26 @@ var init_Materials = __esm({
   }
 });
 
+// src/model/Model.ts
+function isDoubleArray(obj) {
+  return Array.isArray(obj) && obj.length === 2;
+}
+function isTripleArray(obj) {
+  return Array.isArray(obj) && obj.length === 3;
+}
+function isQuadArray(obj) {
+  return Array.isArray(obj) && obj.length === 4;
+}
+var ITEM_GENERATED, BUILTIN_GENERATED, BUILTIN_ENTITY, DEFAULT_ELEMENTS;
+var init_Model = __esm({
+  "src/model/Model.ts"() {
+    ITEM_GENERATED = "item/generated";
+    BUILTIN_GENERATED = "builtin/generated";
+    BUILTIN_ENTITY = "builtin/entity";
+    DEFAULT_ELEMENTS = [];
+  }
+});
+
 // ../../node_modules/ts-deepmerge/dist/index.js
 var require_dist = __commonJS({
   "../../node_modules/ts-deepmerge/dist/index.js"(exports) {
@@ -1343,6 +1363,7 @@ var init_DisplayTransforms = __esm({
 var import_ts_deepmerge, ModelMerger;
 var init_ModelMerger = __esm({
   "src/model/ModelMerger.ts"() {
+    init_Model();
     init_Models();
     import_ts_deepmerge = __toESM(require_dist());
     init_AssetKey();
@@ -1368,6 +1389,7 @@ var init_ModelMerger = __esm({
         }
         const models = [];
         const parentKey = AssetKey.parse("models", model.parent);
+        if (parentKey.namespace === "minecraft" && parentKey.getFullPath() === BUILTIN_ENTITY) return models;
         parentKey.root = model.key?.root;
         const parentModel = await Models.getRaw(parentKey);
         if (parentModel) {
@@ -1434,12 +1456,12 @@ var init_Models = __esm({
           const result = await AssetLoader.getFirst([itemKey, key], "json" /* JSON */);
           if (!result) return void 0;
           if (result.key.assetType !== "items") return { ...result.asset, key };
-          const reference = this.defaultItemModel(result.asset.model, key);
-          const modelKey = AssetKey.parse("models", reference);
+          const selected = this.defaultItemModel(result.asset.model, key);
+          const modelKey = AssetKey.parse("models", selected.model);
           modelKey.root = key.root;
           const model2 = await this.getRaw(modelKey);
-          if (!model2) throw new Error(`Item ${key.toNamespacedString()} references missing model ${reference}`);
-          return model2;
+          if (!model2) throw new Error(`Item ${key.toNamespacedString()} references missing model ${selected.model}`);
+          return selected.special ? { ...model2, special: selected.special } : model2;
         });
         return model ? { ...model, key: Object.assign(new AssetKey("", ""), model.key) } : void 0;
       }
@@ -1450,8 +1472,25 @@ var init_Models = __esm({
         }
         switch (node.type.replace(/^minecraft:/, "")) {
           case "model":
-            if (typeof node.model === "string" && node.model) return node.model;
+            if (typeof node.model === "string" && node.model) return { model: node.model };
             break;
+          case "special": {
+            if (!node.base || !node.model || typeof node.model !== "object") break;
+            const special = node.model;
+            switch (special.type) {
+              case "chest":
+              case "minecraft:chest":
+              case "bed":
+              case "minecraft:bed":
+                if (typeof special.texture === "string" && special.texture) return { model: node.base, special };
+                break;
+              case "head":
+              case "minecraft:head":
+                if (typeof special.kind === "string" && special.kind) return { model: node.base, special };
+                break;
+            }
+            throw new Error(`Unsupported special item renderer ${special.type} for ${key.toNamespacedString()}`);
+          }
           case "condition":
             return this.defaultItemModel(node.on_false, key);
           case "select": {
@@ -3014,6 +3053,102 @@ var init_UVMapper = __esm({
   }
 });
 
+// src/MinecraftCubeTexture.ts
+var MinecraftCubeTexture;
+var init_MinecraftCubeTexture = __esm({
+  "src/MinecraftCubeTexture.ts"() {
+    init_UVMapper();
+    init_CubeFace();
+    MinecraftCubeTexture = class {
+      constructor(u, v, width, height) {
+        this.u = u;
+        this.v = v;
+        this.width = width;
+        this.height = height;
+      }
+      mapW(x) {
+        return x / this.width;
+      }
+      mapH(x) {
+        return 1 - x / this.height;
+      }
+      getUvEast(w, h, l) {
+        return [
+          [this.mapW(this.u + l + w + l), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l + w), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l + w + l), this.mapH(this.v + l)],
+          [this.mapW(this.u + l + w), this.mapH(this.v + l)]
+        ];
+      }
+      getUvWest(w, h, l) {
+        return [
+          [this.mapW(this.u + l), this.mapH(this.v + l + h)],
+          [this.mapW(this.u), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l), this.mapH(this.v + l)],
+          [this.mapW(this.u), this.mapH(this.v + l)]
+        ];
+      }
+      getUvUp(w, h, l) {
+        return [
+          [this.mapW(this.u + l + w), this.mapH(this.v + l)],
+          [this.mapW(this.u + l + w + w), this.mapH(this.v + l)],
+          [this.mapW(this.u + l + w), this.mapH(this.v)],
+          [this.mapW(this.u + l + w + w), this.mapH(this.v)]
+        ];
+      }
+      getUvDown(w, h, l) {
+        return [
+          [this.mapW(this.u + l), this.mapH(this.v)],
+          [this.mapW(this.u + l + w), this.mapH(this.v)],
+          [this.mapW(this.u + l), this.mapH(this.v + l)],
+          [this.mapW(this.u + l + w), this.mapH(this.v + l)]
+        ];
+      }
+      getUvSouth(w, h, l) {
+        return [
+          [this.mapW(this.u + l + w + l + w), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l + w + l), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l + w + l + w), this.mapH(this.v + l)],
+          [this.mapW(this.u + l + w + l), this.mapH(this.v + l)]
+        ];
+      }
+      getUvNorth(w, h, l) {
+        return [
+          [this.mapW(this.u + l + w), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l), this.mapH(this.v + l + h)],
+          [this.mapW(this.u + l + w), this.mapH(this.v + l)],
+          [this.mapW(this.u + l), this.mapH(this.v + l)]
+        ];
+      }
+      getFaceUv(face, w, h, l) {
+        switch (face) {
+          case "east" /* EAST */:
+            return this.getUvEast(w, h, l);
+          case "west" /* WEST */:
+            return this.getUvWest(w, h, l);
+          case "up" /* UP */:
+            return this.getUvUp(w, h, l);
+          case "down" /* DOWN */:
+            return this.getUvDown(w, h, l);
+          case "south" /* SOUTH */:
+            return this.getUvSouth(w, h, l);
+          case "north" /* NORTH */:
+            return this.getUvNorth(w, h, l);
+        }
+      }
+      toUvArray(w, h, l, mirror = false) {
+        const uv = [];
+        for (let i = 0; i < CUBE_FACES.length; i++) {
+          const face = mirror && i < 2 ? CUBE_FACES[1 - i] : CUBE_FACES[i];
+          const corners = this.getFaceUv(face, w, h, l);
+          UVMapper.setFaceUvInArray(uv, i * 4, mirror ? [corners[1], corners[0], corners[3], corners[2]] : corners);
+        }
+        return uv;
+      }
+    };
+  }
+});
+
 // src/error/MineRenderError.ts
 var MineRenderError;
 var init_MineRenderError = __esm({
@@ -3030,6 +3165,248 @@ var init_MineRenderError = __esm({
   }
 });
 
+// src/assets/Entities.ts
+var Entities;
+var init_Entities = __esm({
+  "src/assets/Entities.ts"() {
+    init_AssetKey();
+    init_AssetLoader();
+    init_source();
+    init_Caching();
+    init_Assets();
+    init_MineRenderError();
+    init_ModelTextures();
+    Entities = class {
+      static async getEntityList() {
+        const collect = async (path) => {
+          const prefix2 = path ? `${path}/` : "";
+          const key = new AssetKey(DEFAULT_NAMESPACE, `${prefix2}_list`, void 0, void 0, "entity-models", ".json");
+          const list = await Caching.listAssetCache.get(key.serialize(), () => AssetLoader.get(key, "list" /* LIST */));
+          if (!list) return [];
+          const files = list.files.filter((file) => file.endsWith(".json") && file !== "_list.json").map((file) => `${prefix2}${file.slice(0, -5)}`);
+          const children = await Promise.all(list.directories.map((directory) => collect(`${prefix2}${directory}`)));
+          return [...files, ...children.flat()];
+        };
+        return collect("");
+      }
+      static async getModelFile(modelKey) {
+        const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
+        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json", isAssetKey(modelKey) ? modelKey.root : void 0);
+        return Caching.entityModelCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+      }
+      static async getLayerList(modelKey) {
+        return Object.keys((await this.getModelFile(modelKey))?.layers ?? {});
+      }
+      /** The dataset's extra draws on top of `main`; their `when` labels are the states `EntityModelOptions.when` can enable. */
+      static async getPassList(modelKey) {
+        return (await this.getModelFile(modelKey))?.passes ?? [];
+      }
+      static async getEntity(modelKey, textureKey, options) {
+        const model = await this.getModelFile(modelKey);
+        if (!model) return void 0;
+        const passes = options?.layers || options?.layer !== void 0 ? [] : (model.passes ?? []).filter((pass) => pass.when === void 0 || options?.when?.includes(pass.when));
+        const draws = [...new Set(options?.layers ?? [options?.layer ?? "main"])].map((layer) => ({ layer }));
+        if (draws.length === 0) throw new MineRenderError(`Entity ${model.id} requires at least one layer`);
+        draws.push(...passes);
+        const names = [];
+        const selected = draws.map((pass) => {
+          const layer = model.layers[pass.layer];
+          if (!layer) {
+            throw new MineRenderError(`Entity ${model.id} has no layer "${pass.layer}". Available layers: ${Object.keys(model.layers).join(", ")}`);
+          }
+          let name = pass.layer;
+          for (let n = 2; names.includes(name); n++) name = `${pass.layer}#${n}`;
+          names.push(name);
+          return { name, layer, pass };
+        });
+        const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name, layer, pass }, index) => {
+          const override = options?.textures?.[name] ?? (index === 0 ? textureKey : void 0);
+          const textureLocation = pass.textureLocation ?? layer.textureLocation;
+          let texture;
+          if (override) {
+            const path = isAssetKey(override) ? override.getFullPath() : override.path;
+            texture = isAssetKey(override) && override.assetType === "textures" && path.startsWith("entity/") ? override : new AssetKey(override.namespace, path, "textures", "entity", "assets", ".png", isAssetKey(override) ? override.root : void 0);
+          } else if (textureLocation !== void 0) {
+            texture = AssetKey.parse("textures", textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+            if (isAssetKey(modelKey)) texture.root = modelKey.root;
+          } else {
+            texture = await this.resolveTexture(modelKey);
+          }
+          const render = pass.render ?? layer.render;
+          return [name, { key: override ?? modelKey, texture, layer, ...render && { render }, ...pass.tint && { tint: pass.tint } }];
+        })));
+        return { ...layers[names[0]], id: model.id, layers, ...model.transform && { transform: model.transform } };
+      }
+      /**
+       * Vanilla's keyframe animations of a model by name, or undefined when the model or the selected version has none.
+       */
+      static async getAnimations(modelKey) {
+        const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
+        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models/animations", ".json");
+        const file = await Caching.entityAnimationCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+        return file?.animations;
+      }
+      static async resolveTexture(modelKey) {
+        const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
+        const root = isAssetKey(modelKey) ? modelKey.root : void 0;
+        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json", root);
+        return Caching.entityTextureCache.get(key.serialize(), async () => {
+          const name = path.split("/").pop();
+          for (const candidate of [path, `${path}/${name}`]) {
+            const texture2 = new AssetKey(modelKey.namespace, candidate, "textures", "entity", "assets", ".png", root);
+            if (await ModelTextures.get(texture2)) return texture2;
+          }
+          const listKey = new AssetKey(modelKey.namespace, "_list", `${name}_variant`, void 0, "data", ".json", root);
+          const list = await AssetLoader.get(listKey, "list" /* LIST */);
+          const files = list?.files.filter((file2) => file2.endsWith(".json") && file2 !== "_list.json");
+          const file = files?.find((file2) => file2 === "temperate.json") ?? files?.[0];
+          if (!file) return void 0;
+          const variantKey = new AssetKey(modelKey.namespace, file.slice(0, -5), `${name}_variant`, void 0, "data", ".json", root);
+          const variant = await AssetLoader.get(variantKey, "json" /* JSON */);
+          const assets = variant?.assets;
+          const textureId = variant?.asset_id ?? (typeof assets?.wild === "string" ? assets.wild : Object.values(assets ?? {}).find((value) => typeof value === "string"));
+          if (typeof textureId !== "string") return void 0;
+          const texture = AssetKey.parse("textures", textureId);
+          texture.root = root;
+          return texture;
+        });
+      }
+      /** @deprecated Use getEntityList(); block entities share the entity dataset. */
+      static getBlockList() {
+        return this.getEntityList();
+      }
+      /** @deprecated Use getEntity(); block entities share the entity dataset. */
+      static getBlock(modelKey, textureKey, options) {
+        return this.getEntity(modelKey, textureKey, options);
+      }
+    };
+  }
+});
+
+// src/entity/EntityAnimation.ts
+function catmullRom(delta, p0, p1, p22, p32) {
+  return 0.5 * (2 * p1 + (p22 - p0) * delta + (2 * p0 - 5 * p1 + 4 * p22 - p32) * delta * delta + (3 * p1 - p0 - 3 * p22 + p32) * delta * delta * delta);
+}
+function sampleEntityKeyframes(keyframes, time) {
+  if (keyframes.length === 0) return [0, 0, 0];
+  let low = 0, high = keyframes.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (time <= keyframes[middle].time) high = middle;
+    else low = middle + 1;
+  }
+  const a = Math.max(0, low - 1);
+  const b = Math.min(keyframes.length - 1, a + 1);
+  const from = keyframes[a];
+  const to = keyframes[b];
+  const delta = a === b ? 0 : Math.min(1, Math.max(0, (time - from.time) / (to.time - from.time)));
+  if (to.interpolation === "catmullrom") {
+    const before = keyframes[Math.max(0, a - 1)].value;
+    const after = keyframes[Math.min(keyframes.length - 1, b + 1)].value;
+    return [0, 1, 2].map((i) => catmullRom(delta, before[i], from.value[i], to.value[i], after[i]));
+  }
+  const target = to.pre ?? to.value;
+  return [0, 1, 2].map((i) => from.value[i] + (target[i] - from.value[i]) * delta);
+}
+function entityAnimationTime(animation, time, loop = animation.loop) {
+  return loop && animation.length > 0 ? time % animation.length : time;
+}
+function sampleEntityAnimation(animation, time, loop = animation.loop) {
+  const elapsed = entityAnimationTime(animation, time, loop);
+  const pose = {};
+  for (const [name, bone] of Object.entries(animation.bones)) {
+    const sampled = pose[name] = {};
+    for (const channel of ENTITY_ANIMATION_CHANNELS) {
+      const keyframes = bone[channel];
+      if (keyframes?.length) sampled[channel] = sampleEntityKeyframes(keyframes, elapsed);
+    }
+  }
+  return pose;
+}
+var ENTITY_ANIMATION_CHANNELS;
+var init_EntityAnimation = __esm({
+  "src/entity/EntityAnimation.ts"() {
+    ENTITY_ANIMATION_CHANNELS = ["position", "rotation", "scale"];
+  }
+});
+
+// src/entity/scene/EntityAnimationPlayer.ts
+var ZERO, EntityAnimationPlayer;
+var init_EntityAnimationPlayer = __esm({
+  "src/entity/scene/EntityAnimationPlayer.ts"() {
+    init_EntityAnimation();
+    ZERO = [0, 0, 0];
+    EntityAnimationPlayer = class {
+      constructor() {
+        this.parts = [];
+        this._time = 0;
+        this.loop = false;
+        this.speed = 1;
+      }
+      get animation() {
+        return this._animation;
+      }
+      get time() {
+        return this._time;
+      }
+      /**
+       * Starts an animation on the named parts below each layer root. The current pose of a part becomes its default;
+       * bones without a matching part are skipped.
+       */
+      play(layers, animation, options = {}) {
+        this.stop();
+        this._animation = animation;
+        this._time = options.time ?? 0;
+        this.loop = options.loop ?? animation.loop;
+        this.speed = options.speed ?? 1;
+        for (const layer of layers) {
+          for (const bone of Object.keys(animation.bones)) {
+            const object = layer.getObjectByName(`group:${bone}`);
+            if (!object) continue;
+            this.parts.push({ bone, object, position: object.position.clone(), rotation: object.rotation.clone(), scale: object.scale.clone() });
+          }
+        }
+        this.apply();
+      }
+      /** Restores the default poses. Returns whether an animation was active. */
+      stop() {
+        if (!this._animation) return false;
+        for (const part of this.parts) {
+          part.object.position.copy(part.position);
+          part.object.rotation.copy(part.rotation);
+          part.object.scale.copy(part.scale);
+        }
+        this.clear();
+        return true;
+      }
+      /** Forgets the animation without touching the parts, for parts that no longer exist. */
+      clear() {
+        this.parts = [];
+        this._animation = void 0;
+        this._time = 0;
+      }
+      setTime(seconds) {
+        if (!this._animation) return false;
+        this._time = seconds;
+        this.apply();
+        return true;
+      }
+      advance(deltaSeconds) {
+        return this.setTime(this._time + deltaSeconds * this.speed);
+      }
+      apply() {
+        const pose = sampleEntityAnimation(this._animation, this._time, this.loop);
+        for (const part of this.parts) {
+          const { position = ZERO, rotation = ZERO, scale = ZERO } = pose[part.bone];
+          part.object.position.set(part.position.x + position[0], part.position.y + position[1], part.position.z + position[2]);
+          part.object.rotation.set(part.rotation.x + rotation[0], part.rotation.y + rotation[1], part.rotation.z + rotation[2], part.rotation.order);
+          part.object.scale.set(part.scale.x + scale[0], part.scale.y + scale[1], part.scale.z + scale[2]);
+        }
+      }
+    };
+  }
+});
+
 // src/instance/InstanceReference.ts
 function isInstanceReference(obj) {
   return obj.isInstanceReference;
@@ -3526,6 +3903,241 @@ var init_SceneObject = __esm({
   }
 });
 
+// src/entity/scene/EntityObject.ts
+function isEntityObject(obj) {
+  return obj.isEntityObject;
+}
+var import_ts_deepmerge4, import_three13, _EntityObject, EntityObject;
+var init_EntityObject = __esm({
+  "src/entity/scene/EntityObject.ts"() {
+    init_SceneObject();
+    init_Caching();
+    import_ts_deepmerge4 = __toESM(require_dist());
+    import_three13 = require("three");
+    init_Ticker();
+    init_model();
+    init_ModelTextures();
+    init_AssetKey();
+    init_Materials();
+    init_MinecraftCubeTexture();
+    init_three();
+    init_EntityAnimationPlayer();
+    _EntityObject = class _EntityObject extends SceneObject {
+      constructor(entity, options) {
+        super();
+        this.entity = entity;
+        this.isEntityObject = true;
+        this.meshesCreated = false;
+        this.geometries = /* @__PURE__ */ new Set();
+        this.disposeWireframes = [];
+        /** Scrolling materials are owned: their texture offset follows this entity's age. */
+        this.scrollMaterials = [];
+        /** Entity age in ticks, as vanilla's `ageInTicks`; drives the scrolling render modes. */
+        this.age = 0;
+        this.animationPlayer = new EntityAnimationPlayer();
+        this.options = (0, import_ts_deepmerge4.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
+        this.addEventListener("added", () => this.updateScrollSubscription());
+        this.addEventListener("removed", () => this.updateScrollSubscription());
+      }
+      async init() {
+        this.createMeshes();
+        await this.applyTextures();
+      }
+      dispose() {
+        super.dispose();
+      }
+      disposeAndRemoveAllChildren() {
+        this.clearScrollMaterials();
+        for (const geometry of this.geometries) geometry.dispose();
+        this.geometries.clear();
+        for (const dispose of this.disposeWireframes.splice(0)) dispose();
+        this.animationPlayer.clear();
+        super.disposeAndRemoveAllChildren();
+      }
+      clearScrollMaterials() {
+        Ticker.remove(this.scrollTicker);
+        this.scrollTicker = void 0;
+        for (const { material } of this.scrollMaterials.splice(0)) {
+          material.map?.dispose();
+          material.dispose();
+        }
+      }
+      updateScrollSubscription() {
+        if (this.parent && this.scrollMaterials.length) {
+          if (this.scrollTicker === void 0) {
+            this.scrollTicker = Ticker.add(() => {
+              this.age++;
+              this.updateScroll();
+            });
+          }
+        } else {
+          Ticker.remove(this.scrollTicker);
+          this.scrollTicker = void 0;
+        }
+      }
+      /** Applies the entity age to the scrolling materials; the ticker calls this 20 times per second. */
+      updateScroll() {
+        for (const { offset, speed } of this.scrollMaterials) {
+          offset.set(this.age * speed[0] % 1, 0 - this.age * speed[1] % 1);
+        }
+        this.notifyDirty();
+      }
+      //<editor-fold desc="ANIMATION">
+      /** The animation started by {@link playAnimation}, until {@link stopAnimation} or disposal. */
+      get animation() {
+        return this.animationPlayer.animation;
+      }
+      /** Seconds since the animation started, before looping. */
+      get animationTime() {
+        return this.animationPlayer.time;
+      }
+      /**
+       * Poses the object from a keyframe animation of {@link Entities.getAnimations}, replacing the current one.
+       * Parts of every layer are matched by name and their current pose is the default the offsets add to.
+       * The object owns no clock: call {@link advanceAnimation} per frame, or {@link setAnimationTime}.
+       */
+      playAnimation(animation, options) {
+        this.createMeshes();
+        const layers = Object.keys(this.entityLayers).map((name) => this.getLayerGroup(name)).filter((layer) => !!layer);
+        this.animationPlayer.play(layers, animation, options);
+        this.notifyDirty();
+      }
+      /** Stops the animation and restores the default pose. */
+      stopAnimation() {
+        if (this.animationPlayer.stop()) this.notifyDirty();
+      }
+      /** Poses the object at an explicit time in seconds. Has no effect without an animation. */
+      setAnimationTime(seconds) {
+        if (this.animationPlayer.setTime(seconds)) this.notifyDirty();
+      }
+      /** Advances the animation by a frame delta in seconds, scaled by its speed. Has no effect without an animation. */
+      advanceAnimation(deltaSeconds) {
+        if (this.animationPlayer.advance(deltaSeconds)) this.notifyDirty();
+      }
+      //</editor-fold>
+      getLayerGroup(name) {
+        return super.getGroupByName(`layer:${name}`);
+      }
+      getGroupByName(name, layerName) {
+        return layerName === void 0 ? super.getGroupByName(name) : this.getLayerGroup(layerName)?.getObjectByName(`group:${name}`);
+      }
+      getMeshByName(name, layerName) {
+        return layerName === void 0 ? super.getMeshByName(name) : this.getLayerGroup(layerName)?.getObjectByName(`mesh:${name}`);
+      }
+      get entityLayers() {
+        return this.entity.layers ?? { main: this.entity };
+      }
+      getTextureKey(layer) {
+        if (layer.texture) return layer.texture;
+        const key = layer.key;
+        return new AssetKey(
+          key.namespace,
+          isAssetKey(key) ? key.getFullPath() : key.path,
+          "textures",
+          "entity",
+          "assets",
+          ".png"
+        );
+      }
+      async loadTextures(layer = this.entity) {
+        return ModelTextures.get(this.getTextureKey(layer));
+      }
+      createMeshes(force = false) {
+        if (this.meshesCreated && !force) return;
+        const modelRoot = new import_three13.Object3D();
+        const transform = this.options.flip === void 0 ? this.entity.transform : void 0;
+        if (transform) {
+          for (const op of transform) {
+            const matrix = new import_three13.Matrix4();
+            if ("scale" in op) matrix.makeScale(...op.scale);
+            else if ("translate" in op) matrix.makeTranslation(...op.translate);
+            else matrix.makeRotationFromEuler(new import_three13.Euler(...op.rotate, "ZYX"));
+            modelRoot.matrix.multiply(matrix);
+          }
+          modelRoot.matrixAutoUpdate = false;
+        } else if (this.options.flip ?? true) {
+          modelRoot.scale.set(-1, -1, 1);
+        }
+        this.add(modelRoot);
+        Object.entries(this.entityLayers).forEach(([name, layer], index) => {
+          const group = this.createGroup(`layer:${name}`);
+          modelRoot.add(group);
+          const inward = !Materials.entityModeCulls(layer.render ?? layer.layer.render);
+          this.createPart("root", layer.layer.root, group, layer.layer.texture, Materials.MISSING_TEXTURE, index, inward);
+        });
+        this.meshesCreated = true;
+      }
+      createPart(name, part, parent, textureSize, material, renderOrder, inward = true) {
+        const anchor = this.createGroup(name);
+        anchor.position.fromArray(part.pose.offset);
+        anchor.rotation.set(...part.pose.rotation, "ZYX");
+        anchor.scale.fromArray(part.pose.scale ?? [1, 1, 1]);
+        parent.add(anchor);
+        const size = part.texture ?? textureSize;
+        for (const cube of part.cubes) {
+          const [width, height, depth] = cube.size;
+          const [growX, growY, growZ] = cube.grow ?? [0, 0, 0];
+          const texture = new MinecraftCubeTexture(...cube.uv, ...size);
+          const uv = size[0] === 0 || size[1] === 0 ? new Array(48).fill(0) : texture.toUvArray(width, height, depth, cube.mirror);
+          const geometry = this._getBoxGeometryForDimensionsAndUv(
+            width + growX * 2,
+            height + growY * 2,
+            depth + growZ * 2,
+            uv
+          ).clone();
+          this.geometries.add(geometry);
+          geometry.translate(cube.origin[0] + width / 2, cube.origin[1] + height / 2, cube.origin[2] + depth / 2);
+          if (inward && Math.min(width + growX * 2, height + growY * 2, depth + growZ * 2) > 0) {
+            const index = Array.from(geometry.getIndex().array);
+            geometry.setIndex(index.concat(index.slice().reverse()));
+          }
+          const mesh = this.createMesh(name, geometry, material);
+          mesh.renderOrder = renderOrder;
+          anchor.add(mesh);
+          if (this.options.wireframe) this.disposeWireframes.push(addWireframeToMesh(geometry, mesh));
+        }
+        for (const [childName, child] of Object.entries(part.children)) {
+          this.createPart(childName, child, anchor, size, material, renderOrder, inward);
+        }
+      }
+      async applyTextures() {
+        this.clearScrollMaterials();
+        await Promise.all(Object.entries(this.entityLayers).map(async ([name, layer]) => {
+          const mode = layer.render ?? layer.layer.render ?? "cutout";
+          const tint = layer.tint === void 0 ? void 0 : this.options.tints?.[layer.tint];
+          const scroll = Materials.entityModeScroll(mode);
+          const assetKeyStr = this.getTextureKey(layer).serialize();
+          const keyStr = `entity:${mode}:${tint === void 0 ? "" : new import_three13.Color(tint).getHexString()}:${assetKeyStr}`;
+          let mat = scroll ? void 0 : Caching.materialCache.getIfPresent(keyStr);
+          if (!mat) {
+            const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
+            const imageData = await this.loadTextures(layer);
+            if (!imageData) return;
+            const canvas = imageData.data.canvas;
+            const createMaterial = () => Materials.createEntityCanvasMaterial(canvas, mode, tint);
+            mat = !scroll && cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
+            if (scroll) {
+              this.scrollMaterials.push({ material: mat, offset: mat.map.offset, speed: scroll });
+            }
+          }
+          this.getLayerGroup(name)?.traverse((object) => {
+            if (isMesh(object)) object.material = mat;
+          });
+        }));
+        if (!this.children.length) {
+          this.clearScrollMaterials();
+        } else if (this.scrollMaterials.length) {
+          this.updateScroll();
+        }
+        this.updateScrollSubscription();
+        this.notifyDirty();
+      }
+    };
+    _EntityObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS);
+    EntityObject = _EntityObject;
+  }
+});
+
 // src/three/BufferGeometryUtils.js
 function computeTangents(geometry) {
   geometry.computeTangents();
@@ -4105,37 +4717,189 @@ var init_ModelCulling = __esm({
   }
 });
 
+// src/model/SpecialItems.ts
+var import_three22, SpecialItems;
+var init_SpecialItems = __esm({
+  "src/model/SpecialItems.ts"() {
+    import_three22 = require("three");
+    init_AssetKey();
+    init_Entities();
+    SpecialItems = class {
+      /** Resolves the static entity parts drawn by a special item renderer, in model units. */
+      static async getParts(special, root) {
+        const texture = (id, directory) => {
+          const key = AssetKey.parse("textures", id);
+          return new AssetKey(
+            key.namespace,
+            [directory, key.getFullPath()].filter(Boolean).join("/"),
+            "textures",
+            "entity",
+            "assets",
+            ".png",
+            root
+          );
+        };
+        const load = async (id, textureKey, transform, rotations = {}) => {
+          const key = new AssetKey("minecraft", id, void 0, void 0, "entity-models", ".json", root);
+          const model = await Entities.getEntity(key, textureKey, { layer: "main" });
+          if (!model) throw new Error(`Missing entity model minecraft:${id} for special item ${special.type}`);
+          return { model, transform, rotations };
+        };
+        switch (special.type) {
+          case "minecraft:chest":
+          case "chest": {
+            const angle = -(special.openness ?? 0) * Math.PI / 2;
+            const chest = await load("chest", texture(special.texture, "chest"), new import_three22.Matrix4(), {
+              lid: [angle, 0, 0],
+              lock: [angle, 0, 0]
+            });
+            chest.model = { ...chest.model, render: "solid", layers: void 0 };
+            return [chest];
+          }
+          case "minecraft:bed":
+          case "bed": {
+            const transform = new import_three22.Matrix4().makeTranslation(0, 9, 0).multiply(new import_three22.Matrix4().makeRotationX(Math.PI / 2)).multiply(new import_three22.Matrix4().makeTranslation(8, 8, 8)).multiply(new import_three22.Matrix4().makeRotationZ(Math.PI)).multiply(new import_three22.Matrix4().makeTranslation(-8, -8, -8));
+            const key = texture(special.texture, "bed");
+            return Promise.all([
+              load("bed_head", key, transform),
+              load("bed_foot", key, new import_three22.Matrix4().makeTranslation(0, 0, -16).multiply(transform))
+            ]);
+          }
+          case "minecraft:head":
+          case "head": {
+            const models = {
+              skeleton: "skeleton_skull",
+              wither_skeleton: "wither_skeleton_skull",
+              zombie: "zombie_head",
+              creeper: "creeper_head",
+              dragon: "dragon_skull",
+              piglin: "piglin_head"
+            };
+            const id = Object.prototype.hasOwnProperty.call(models, special.kind) ? models[special.kind] : void 0;
+            if (!id) throw new Error(`Unsupported special item head kind ${special.kind}`);
+            const animation = (special.animation ?? 0) * Math.PI * 0.2;
+            const rotations = { head: [0, Math.PI, 0] };
+            if (special.kind === "dragon") rotations.jaw = [(Math.sin(animation) + 1) * 0.2, 0, 0];
+            if (special.kind === "piglin") {
+              rotations.left_ear = [0, 0, -(Math.cos(animation * 1.2) + 2.5) * 0.2];
+              rotations.right_ear = [0, 0, (Math.cos(animation) + 2.5) * 0.2];
+            }
+            return [await load(
+              id,
+              special.texture ? texture(special.texture, "") : void 0,
+              new import_three22.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three22.Matrix4().makeScale(-1, -1, 1)),
+              rotations
+            )];
+          }
+        }
+      }
+      /** An owned material with model-preview shading; its entity texture remains shared. */
+      static createMaterial(source, shade) {
+        const material = source.clone();
+        if (shade) {
+          material.onBeforeCompile = (shader) => {
+            shader.vertexShader = `varying float itemLight;
+${shader.vertexShader}`.replace("#include <begin_vertex>", `
+                    #include <begin_vertex>
+                    vec3 N = inverseTransformDirection(normalMatrix * normal, viewMatrix);
+                    itemLight = (1.0 + N.y) * 0.25 - N.x * N.x * 0.15 + N.z * N.z * 0.05 + 0.5;
+                `);
+            shader.fragmentShader = `varying float itemLight;
+${shader.fragmentShader}`.replace(
+              "#include <color_fragment>",
+              "#include <color_fragment>\ndiffuseColor.rgb *= itemLight;"
+            );
+          };
+          material.customProgramCacheKey = () => "special-item-side";
+        }
+        return material;
+      }
+    };
+  }
+});
+
+// src/model/GuiLight.ts
+var GuiLight;
+var init_GuiLight = __esm({
+  "src/model/GuiLight.ts"() {
+    GuiLight = /* @__PURE__ */ ((GuiLight2) => {
+      GuiLight2["FRONT"] = "front";
+      GuiLight2["SIDE"] = "side";
+      return GuiLight2;
+    })(GuiLight || {});
+  }
+});
+
 // src/model/scene/ModelObject.ts
 function isModelObject(obj) {
   return obj.isModelObject;
 }
-var import_three22, import_ts_deepmerge5, p7, _ModelObject, ModelObject;
+var import_three23, import_ts_deepmerge5, p7, _ModelObject, ModelObject;
 var init_ModelObject = __esm({
   "src/model/scene/ModelObject.ts"() {
     init_SceneObject();
     init_Materials();
     init_UVMapper();
-    import_three22 = require("three");
+    import_three23 = require("three");
     init_BufferGeometryUtils();
     init_model();
     import_ts_deepmerge5 = __toESM(require_dist());
     init_log();
     init_CubeFace();
+    init_DisplayPosition();
     init_DisplayTransforms();
     init_ModelCulling();
+    init_SpecialItems();
+    init_EntityObject();
+    init_GuiLight();
     p7 = prefix("ModelObject");
     _ModelObject = class _ModelObject extends SceneObject {
       constructor(originalModel, options) {
         super(options);
         this.originalModel = originalModel;
         this.isModelObject = true;
+        this.specialMaterials = /* @__PURE__ */ new Map();
         this.meshesCreated = false;
         this.options = (0, import_ts_deepmerge5.default)({}, _ModelObject.DEFAULT_OPTIONS, options ?? {});
+        if (originalModel.special) this.options.instanceMeshes = false;
         if (this.options.tints) this.options.tints = { ...this.options.tints };
         this.addEventListener("added", () => this.updateAnimationSubscription());
         this.addEventListener("removed", () => this.updateAnimationSubscription());
       }
       async init() {
+        const special = this.originalModel.special;
+        if (special) {
+          const parts = await SpecialItems.getParts(special, this.originalModel.key?.root);
+          const transform = this.options.displayPosition ? DisplayTransforms.getMatrix(this.originalModel.display, this.options.displayPosition) : new import_three23.Matrix4();
+          transform.multiply(new import_three23.Matrix4().makeTranslation(-8, -8, -8));
+          try {
+            for (const part of parts) {
+              const object = new EntityObject(part.model, { flip: false, wireframe: this.options.wireframe });
+              object.matrix.copy(transform).multiply(part.transform);
+              object.matrixAutoUpdate = false;
+              this.add(object);
+              await object.init();
+              object.iterateAllMeshes((mesh) => {
+                const source = mesh.material;
+                let material = this.specialMaterials.get(source);
+                if (!material) {
+                  const front = this.options.displayPosition === "gui" /* GUI */ && this.originalModel.gui_light === "front" /* FRONT */;
+                  material = SpecialItems.createMaterial(source, !front);
+                  this.specialMaterials.set(source, material);
+                }
+                mesh.material = material;
+              });
+              for (const [name, rotation] of Object.entries(part.rotations)) {
+                object.getGroupByName(name)?.rotation.set(...rotation, "ZYX");
+              }
+            }
+          } catch (error) {
+            this.disposeAndRemoveAllChildren();
+            throw error;
+          }
+          this.notifyDirty();
+          return;
+        }
         await this.loadTextures();
         this.createMeshes();
         this.applyTextures();
@@ -4169,7 +4933,7 @@ var init_ModelObject = __esm({
                 elGeo.clearGroups();
               }
               if (this.options.uvLockRotation) {
-                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three22.Euler(...this.options.uvLockRotation));
+                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three23.Euler(...this.options.uvLockRotation));
               }
               if (this.options.tints) {
                 const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4178,19 +4942,19 @@ var init_ModelObject = __esm({
                   if (tintIndex === void 0 || tintIndex < 0) continue;
                   const tint = this.options.tints[tintIndex];
                   if (tint === void 0) continue;
-                  const color = new import_three22.Color(tint);
+                  const color = new import_three23.Color(tint);
                   for (let vertex = 0; vertex < 4; vertex++) {
                     color.toArray(colors, (faceIndex * 4 + vertex) * 3);
                   }
                 }
-                elGeo.setAttribute("color", new import_three22.BufferAttribute(colors, 3));
+                elGeo.setAttribute("color", new import_three23.BufferAttribute(colors, 3));
               }
-              elGeo.applyMatrix4(new import_three22.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
-              elGeo.applyMatrix4(new import_three22.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+              elGeo.applyMatrix4(new import_three23.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
+              elGeo.applyMatrix4(new import_three23.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
               if (el.rotation) {
                 applyElementRotation(el.rotation, elGeo);
               }
-              elGeo.applyMatrix4(new import_three22.Matrix4().makeTranslation(-8, -8, -8));
+              elGeo.applyMatrix4(new import_three23.Matrix4().makeTranslation(-8, -8, -8));
               if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
               if (this.options.mergeMeshes) {
                 allGeos.push(elGeo);
@@ -4212,7 +4976,7 @@ var init_ModelObject = __esm({
           if (allGeos.length > 0) {
             combinedGeo = mergeBufferGeometries(allGeos);
           } else {
-            combinedGeo = new import_three22.BoxGeometry(16, 16, 16);
+            combinedGeo = new import_three23.BoxGeometry(16, 16, 16);
             if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
           }
           combinedGeo.computeBoundingBox();
@@ -4280,6 +5044,8 @@ var init_ModelObject = __esm({
         this.atlasMaterial?.dispose();
         this.atlasTexture = void 0;
         this.atlasMaterial = void 0;
+        for (const material of this.specialMaterials.values()) material.dispose();
+        this.specialMaterials.clear();
         super.disposeAndRemoveAllChildren();
       }
     };
@@ -4322,7 +5088,7 @@ function ownHeight(sample) {
   return (level === 0 || level >= 8 ? 8 : 8 - level) / 9;
 }
 function createFluidGeometry(kind, sample) {
-  const geometry = new import_three27.BufferGeometry();
+  const geometry = new import_three28.BufferGeometry();
   const positions = [], normals = [], uvs = [], indices = [];
   const self = sample(0, 0, 0);
   const height = (x, z) => {
@@ -4421,16 +5187,16 @@ function createFluidGeometry(kind, sample) {
       1
     );
   }
-  geometry.setAttribute("position", new import_three27.Float32BufferAttribute(positions, 3));
-  geometry.setAttribute("normal", new import_three27.Float32BufferAttribute(normals, 3));
-  geometry.setAttribute("uv", new import_three27.Float32BufferAttribute(uvs, 2));
+  geometry.setAttribute("position", new import_three28.Float32BufferAttribute(positions, 3));
+  geometry.setAttribute("normal", new import_three28.Float32BufferAttribute(normals, 3));
+  geometry.setAttribute("uv", new import_three28.Float32BufferAttribute(uvs, 2));
   geometry.setIndex(indices);
   return geometry;
 }
-var import_three27, fluidRules, HORIZONTAL, EPSILON;
+var import_three28, fluidRules, HORIZONTAL, EPSILON;
 var init_FluidGeometry = __esm({
   "src/model/fluid/FluidGeometry.ts"() {
-    import_three27 = require("three");
+    import_three28 = require("three");
     init_fluidBlocks();
     fluidRules = fluidBlocks_default;
     HORIZONTAL = [[0, -1], [0, 1], [-1, 0], [1, 0]];
@@ -4459,10 +5225,10 @@ function sampleFluid(kind, sample) {
   }
   return { key: key.join(""), sample: (x, y, z) => cells[(y + 1) * 9 + (z + 1) * 3 + x + 1] };
 }
-var import_three28, FluidModelObject;
+var import_three29, FluidModelObject;
 var init_FluidModelObject = __esm({
   "src/model/fluid/FluidModelObject.ts"() {
-    import_three28 = require("three");
+    import_three29 = require("three");
     init_AssetKey();
     init_Materials();
     init_ModelObject();
@@ -4495,10 +5261,10 @@ var init_FluidModelObject = __esm({
           }
         }
         geometry.clearGroups();
-        const color = new import_three28.Color(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
+        const color = new import_three29.Color(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
         const colors = new Float32Array(geometry.getAttribute("position").count * 3);
         for (let i = 0; i < colors.length; i += 3) color.toArray(colors, i);
-        geometry.setAttribute("color", new import_three28.BufferAttribute(colors, 3));
+        geometry.setAttribute("color", new import_three29.BufferAttribute(colors, 3));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
         if (this.options.instanceMeshes) {
@@ -4512,7 +5278,7 @@ var init_FluidModelObject = __esm({
         super.applyTextures();
         this.iterateAllMeshes((mesh) => {
           const material = mesh.material;
-          material.side = import_three28.DoubleSide;
+          material.side = import_three29.DoubleSide;
           material.forceSinglePass = true;
           material.depthWrite = !material.transparent;
         });
@@ -4616,6 +5382,7 @@ __export(index_browser_exports, {
   SkinPart: () => SkinPart,
   SkinTextures: () => SkinTextures,
   Skins: () => Skins,
+  SpecialItems: () => SpecialItems,
   StructureParser: () => StructureParser,
   TextureAtlas: () => TextureAtlas,
   TextureLoader: () => TextureLoader,
@@ -4845,96 +5612,8 @@ var Meshes = class _Meshes {
   }
 };
 
-// src/MinecraftCubeTexture.ts
-init_UVMapper();
-init_CubeFace();
-var MinecraftCubeTexture = class {
-  constructor(u, v, width, height) {
-    this.u = u;
-    this.v = v;
-    this.width = width;
-    this.height = height;
-  }
-  mapW(x) {
-    return x / this.width;
-  }
-  mapH(x) {
-    return 1 - x / this.height;
-  }
-  getUvEast(w, h, l) {
-    return [
-      [this.mapW(this.u + l + w + l), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w + l), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w), this.mapH(this.v + l)]
-    ];
-  }
-  getUvWest(w, h, l) {
-    return [
-      [this.mapW(this.u + l), this.mapH(this.v + l + h)],
-      [this.mapW(this.u), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l), this.mapH(this.v + l)],
-      [this.mapW(this.u), this.mapH(this.v + l)]
-    ];
-  }
-  getUvUp(w, h, l) {
-    return [
-      [this.mapW(this.u + l + w), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w + w), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w), this.mapH(this.v)],
-      [this.mapW(this.u + l + w + w), this.mapH(this.v)]
-    ];
-  }
-  getUvDown(w, h, l) {
-    return [
-      [this.mapW(this.u + l), this.mapH(this.v)],
-      [this.mapW(this.u + l + w), this.mapH(this.v)],
-      [this.mapW(this.u + l), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w), this.mapH(this.v + l)]
-    ];
-  }
-  getUvSouth(w, h, l) {
-    return [
-      [this.mapW(this.u + l + w + l + w), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w + l), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w + l + w), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w + l), this.mapH(this.v + l)]
-    ];
-  }
-  getUvNorth(w, h, l) {
-    return [
-      [this.mapW(this.u + l + w), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w), this.mapH(this.v + l)],
-      [this.mapW(this.u + l), this.mapH(this.v + l)]
-    ];
-  }
-  getFaceUv(face, w, h, l) {
-    switch (face) {
-      case "east" /* EAST */:
-        return this.getUvEast(w, h, l);
-      case "west" /* WEST */:
-        return this.getUvWest(w, h, l);
-      case "up" /* UP */:
-        return this.getUvUp(w, h, l);
-      case "down" /* DOWN */:
-        return this.getUvDown(w, h, l);
-      case "south" /* SOUTH */:
-        return this.getUvSouth(w, h, l);
-      case "north" /* NORTH */:
-        return this.getUvNorth(w, h, l);
-    }
-  }
-  toUvArray(w, h, l, mirror = false) {
-    const uv = [];
-    for (let i = 0; i < CUBE_FACES.length; i++) {
-      const face = mirror && i < 2 ? CUBE_FACES[1 - i] : CUBE_FACES[i];
-      const corners = this.getFaceUv(face, w, h, l);
-      UVMapper.setFaceUvInArray(uv, i * 4, mirror ? [corners[1], corners[0], corners[3], corners[2]] : corners);
-    }
-    return uv;
-  }
-};
+// src/index.ts
+init_MinecraftCubeTexture();
 
 // src/SceneStats.ts
 var SceneStats = class {
@@ -5028,116 +5707,7 @@ var BlockEntities = class {
 
 // src/assets/index.ts
 init_BlockStates();
-
-// src/assets/Entities.ts
-init_AssetKey();
-init_AssetLoader();
-init_source();
-init_Caching();
-init_Assets();
-init_MineRenderError();
-init_ModelTextures();
-var Entities = class {
-  static async getEntityList() {
-    const collect = async (path) => {
-      const prefix2 = path ? `${path}/` : "";
-      const key = new AssetKey(DEFAULT_NAMESPACE, `${prefix2}_list`, void 0, void 0, "entity-models", ".json");
-      const list = await Caching.listAssetCache.get(key.serialize(), () => AssetLoader.get(key, "list" /* LIST */));
-      if (!list) return [];
-      const files = list.files.filter((file) => file.endsWith(".json") && file !== "_list.json").map((file) => `${prefix2}${file.slice(0, -5)}`);
-      const children = await Promise.all(list.directories.map((directory) => collect(`${prefix2}${directory}`)));
-      return [...files, ...children.flat()];
-    };
-    return collect("");
-  }
-  static async getModelFile(modelKey) {
-    const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
-    const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json");
-    return Caching.entityModelCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
-  }
-  static async getLayerList(modelKey) {
-    return Object.keys((await this.getModelFile(modelKey))?.layers ?? {});
-  }
-  /** The dataset's extra draws on top of `main`; their `when` labels are the states `EntityModelOptions.when` can enable. */
-  static async getPassList(modelKey) {
-    return (await this.getModelFile(modelKey))?.passes ?? [];
-  }
-  static async getEntity(modelKey, textureKey, options) {
-    const model = await this.getModelFile(modelKey);
-    if (!model) return void 0;
-    const passes = options?.layers || options?.layer !== void 0 ? [] : (model.passes ?? []).filter((pass) => pass.when === void 0 || options?.when?.includes(pass.when));
-    const draws = [...new Set(options?.layers ?? [options?.layer ?? "main"])].map((layer) => ({ layer }));
-    if (draws.length === 0) throw new MineRenderError(`Entity ${model.id} requires at least one layer`);
-    draws.push(...passes);
-    const names = [];
-    const selected = draws.map((pass) => {
-      const layer = model.layers[pass.layer];
-      if (!layer) {
-        throw new MineRenderError(`Entity ${model.id} has no layer "${pass.layer}". Available layers: ${Object.keys(model.layers).join(", ")}`);
-      }
-      let name = pass.layer;
-      for (let n = 2; names.includes(name); n++) name = `${pass.layer}#${n}`;
-      names.push(name);
-      return { name, layer, pass };
-    });
-    const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name, layer, pass }, index) => {
-      const override = options?.textures?.[name] ?? (index === 0 ? textureKey : void 0);
-      const textureLocation = pass.textureLocation ?? layer.textureLocation;
-      let texture;
-      if (override) {
-        const path = isAssetKey(override) ? override.getFullPath() : override.path;
-        texture = isAssetKey(override) && override.assetType === "textures" && path.startsWith("entity/") ? override : new AssetKey(override.namespace, path, "textures", "entity", "assets", ".png", isAssetKey(override) ? override.root : void 0);
-      } else if (textureLocation !== void 0) {
-        texture = AssetKey.parse("textures", textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
-      } else {
-        texture = await this.resolveTexture(modelKey);
-      }
-      const render = pass.render ?? layer.render;
-      return [name, { key: override ?? modelKey, texture, layer, ...render && { render }, ...pass.tint && { tint: pass.tint } }];
-    })));
-    return { ...layers[names[0]], id: model.id, layers, ...model.transform && { transform: model.transform } };
-  }
-  /**
-   * Vanilla's keyframe animations of a model by name, or undefined when the model or the selected version has none.
-   */
-  static async getAnimations(modelKey) {
-    const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
-    const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models/animations", ".json");
-    const file = await Caching.entityAnimationCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
-    return file?.animations;
-  }
-  static async resolveTexture(modelKey) {
-    const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
-    const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json");
-    return Caching.entityTextureCache.get(key.serialize(), async () => {
-      const name = path.split("/").pop();
-      for (const candidate of [path, `${path}/${name}`]) {
-        const texture = new AssetKey(modelKey.namespace, candidate, "textures", "entity", "assets", ".png");
-        if (await ModelTextures.get(texture)) return texture;
-      }
-      const listKey = new AssetKey(modelKey.namespace, "_list", `${name}_variant`, void 0, "data", ".json");
-      const list = await AssetLoader.get(listKey, "list" /* LIST */);
-      const files = list?.files.filter((file2) => file2.endsWith(".json") && file2 !== "_list.json");
-      const file = files?.find((file2) => file2 === "temperate.json") ?? files?.[0];
-      if (!file) return void 0;
-      const variantKey = new AssetKey(modelKey.namespace, file.slice(0, -5), `${name}_variant`, void 0, "data", ".json");
-      const variant = await AssetLoader.get(variantKey, "json" /* JSON */);
-      const assets = variant?.assets;
-      const textureId = variant?.asset_id ?? (typeof assets?.wild === "string" ? assets.wild : Object.values(assets ?? {}).find((value) => typeof value === "string"));
-      return typeof textureId === "string" ? AssetKey.parse("textures", textureId) : void 0;
-    });
-  }
-  /** @deprecated Use getEntityList(); block entities share the entity dataset. */
-  static getBlockList() {
-    return this.getEntityList();
-  }
-  /** @deprecated Use getEntity(); block entities share the entity dataset. */
-  static getBlock(modelKey, textureKey, options) {
-    return this.getEntity(modelKey, textureKey, options);
-  }
-};
-
-// src/assets/index.ts
+init_Entities();
 init_ModelTextures();
 init_Models();
 init_source();
@@ -5182,346 +5752,12 @@ function trimCanvas(source) {
   return canvas;
 }
 
-// src/entity/EntityAnimation.ts
-var ENTITY_ANIMATION_CHANNELS = ["position", "rotation", "scale"];
-function catmullRom(delta, p0, p1, p22, p32) {
-  return 0.5 * (2 * p1 + (p22 - p0) * delta + (2 * p0 - 5 * p1 + 4 * p22 - p32) * delta * delta + (3 * p1 - p0 - 3 * p22 + p32) * delta * delta * delta);
-}
-function sampleEntityKeyframes(keyframes, time) {
-  if (keyframes.length === 0) return [0, 0, 0];
-  let low = 0, high = keyframes.length;
-  while (low < high) {
-    const middle = low + high >>> 1;
-    if (time <= keyframes[middle].time) high = middle;
-    else low = middle + 1;
-  }
-  const a = Math.max(0, low - 1);
-  const b = Math.min(keyframes.length - 1, a + 1);
-  const from = keyframes[a];
-  const to = keyframes[b];
-  const delta = a === b ? 0 : Math.min(1, Math.max(0, (time - from.time) / (to.time - from.time)));
-  if (to.interpolation === "catmullrom") {
-    const before = keyframes[Math.max(0, a - 1)].value;
-    const after = keyframes[Math.min(keyframes.length - 1, b + 1)].value;
-    return [0, 1, 2].map((i) => catmullRom(delta, before[i], from.value[i], to.value[i], after[i]));
-  }
-  const target = to.pre ?? to.value;
-  return [0, 1, 2].map((i) => from.value[i] + (target[i] - from.value[i]) * delta);
-}
-function entityAnimationTime(animation, time, loop = animation.loop) {
-  return loop && animation.length > 0 ? time % animation.length : time;
-}
-function sampleEntityAnimation(animation, time, loop = animation.loop) {
-  const elapsed = entityAnimationTime(animation, time, loop);
-  const pose = {};
-  for (const [name, bone] of Object.entries(animation.bones)) {
-    const sampled = pose[name] = {};
-    for (const channel of ENTITY_ANIMATION_CHANNELS) {
-      const keyframes = bone[channel];
-      if (keyframes?.length) sampled[channel] = sampleEntityKeyframes(keyframes, elapsed);
-    }
-  }
-  return pose;
-}
-
-// src/entity/scene/EntityAnimationPlayer.ts
-var ZERO = [0, 0, 0];
-var EntityAnimationPlayer = class {
-  constructor() {
-    this.parts = [];
-    this._time = 0;
-    this.loop = false;
-    this.speed = 1;
-  }
-  get animation() {
-    return this._animation;
-  }
-  get time() {
-    return this._time;
-  }
-  /**
-   * Starts an animation on the named parts below each layer root. The current pose of a part becomes its default;
-   * bones without a matching part are skipped.
-   */
-  play(layers, animation, options = {}) {
-    this.stop();
-    this._animation = animation;
-    this._time = options.time ?? 0;
-    this.loop = options.loop ?? animation.loop;
-    this.speed = options.speed ?? 1;
-    for (const layer of layers) {
-      for (const bone of Object.keys(animation.bones)) {
-        const object = layer.getObjectByName(`group:${bone}`);
-        if (!object) continue;
-        this.parts.push({ bone, object, position: object.position.clone(), rotation: object.rotation.clone(), scale: object.scale.clone() });
-      }
-    }
-    this.apply();
-  }
-  /** Restores the default poses. Returns whether an animation was active. */
-  stop() {
-    if (!this._animation) return false;
-    for (const part of this.parts) {
-      part.object.position.copy(part.position);
-      part.object.rotation.copy(part.rotation);
-      part.object.scale.copy(part.scale);
-    }
-    this.clear();
-    return true;
-  }
-  /** Forgets the animation without touching the parts, for parts that no longer exist. */
-  clear() {
-    this.parts = [];
-    this._animation = void 0;
-    this._time = 0;
-  }
-  setTime(seconds) {
-    if (!this._animation) return false;
-    this._time = seconds;
-    this.apply();
-    return true;
-  }
-  advance(deltaSeconds) {
-    return this.setTime(this._time + deltaSeconds * this.speed);
-  }
-  apply() {
-    const pose = sampleEntityAnimation(this._animation, this._time, this.loop);
-    for (const part of this.parts) {
-      const { position = ZERO, rotation = ZERO, scale = ZERO } = pose[part.bone];
-      part.object.position.set(part.position.x + position[0], part.position.y + position[1], part.position.z + position[2]);
-      part.object.rotation.set(part.rotation.x + rotation[0], part.rotation.y + rotation[1], part.rotation.z + rotation[2], part.rotation.order);
-      part.object.scale.set(part.scale.x + scale[0], part.scale.y + scale[1], part.scale.z + scale[2]);
-    }
-  }
-};
+// src/entity/index.ts
+init_EntityAnimation();
 
-// src/entity/scene/EntityObject.ts
-init_SceneObject();
-init_Caching();
-var import_ts_deepmerge4 = __toESM(require_dist());
-var import_three13 = require("three");
-init_Ticker();
-init_model();
-init_ModelTextures();
-init_AssetKey();
-init_Materials();
-init_three();
-var _EntityObject = class _EntityObject extends SceneObject {
-  constructor(entity, options) {
-    super();
-    this.entity = entity;
-    this.isEntityObject = true;
-    this.meshesCreated = false;
-    this.geometries = /* @__PURE__ */ new Set();
-    this.disposeWireframes = [];
-    /** Scrolling materials are owned: their texture offset follows this entity's age. */
-    this.scrollMaterials = [];
-    /** Entity age in ticks, as vanilla's `ageInTicks`; drives the scrolling render modes. */
-    this.age = 0;
-    this.animationPlayer = new EntityAnimationPlayer();
-    this.options = (0, import_ts_deepmerge4.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
-    this.addEventListener("added", () => this.updateScrollSubscription());
-    this.addEventListener("removed", () => this.updateScrollSubscription());
-  }
-  async init() {
-    this.createMeshes();
-    await this.applyTextures();
-  }
-  dispose() {
-    super.dispose();
-  }
-  disposeAndRemoveAllChildren() {
-    this.clearScrollMaterials();
-    for (const geometry of this.geometries) geometry.dispose();
-    this.geometries.clear();
-    for (const dispose of this.disposeWireframes.splice(0)) dispose();
-    this.animationPlayer.clear();
-    super.disposeAndRemoveAllChildren();
-  }
-  clearScrollMaterials() {
-    Ticker.remove(this.scrollTicker);
-    this.scrollTicker = void 0;
-    for (const { material } of this.scrollMaterials.splice(0)) {
-      material.map?.dispose();
-      material.dispose();
-    }
-  }
-  updateScrollSubscription() {
-    if (this.parent && this.scrollMaterials.length) {
-      if (this.scrollTicker === void 0) {
-        this.scrollTicker = Ticker.add(() => {
-          this.age++;
-          this.updateScroll();
-        });
-      }
-    } else {
-      Ticker.remove(this.scrollTicker);
-      this.scrollTicker = void 0;
-    }
-  }
-  /** Applies the entity age to the scrolling materials; the ticker calls this 20 times per second. */
-  updateScroll() {
-    for (const { offset, speed } of this.scrollMaterials) {
-      offset.set(this.age * speed[0] % 1, 0 - this.age * speed[1] % 1);
-    }
-    this.notifyDirty();
-  }
-  //<editor-fold desc="ANIMATION">
-  /** The animation started by {@link playAnimation}, until {@link stopAnimation} or disposal. */
-  get animation() {
-    return this.animationPlayer.animation;
-  }
-  /** Seconds since the animation started, before looping. */
-  get animationTime() {
-    return this.animationPlayer.time;
-  }
-  /**
-   * Poses the object from a keyframe animation of {@link Entities.getAnimations}, replacing the current one.
-   * Parts of every layer are matched by name and their current pose is the default the offsets add to.
-   * The object owns no clock: call {@link advanceAnimation} per frame, or {@link setAnimationTime}.
-   */
-  playAnimation(animation, options) {
-    this.createMeshes();
-    const layers = Object.keys(this.entityLayers).map((name) => this.getLayerGroup(name)).filter((layer) => !!layer);
-    this.animationPlayer.play(layers, animation, options);
-    this.notifyDirty();
-  }
-  /** Stops the animation and restores the default pose. */
-  stopAnimation() {
-    if (this.animationPlayer.stop()) this.notifyDirty();
-  }
-  /** Poses the object at an explicit time in seconds. Has no effect without an animation. */
-  setAnimationTime(seconds) {
-    if (this.animationPlayer.setTime(seconds)) this.notifyDirty();
-  }
-  /** Advances the animation by a frame delta in seconds, scaled by its speed. Has no effect without an animation. */
-  advanceAnimation(deltaSeconds) {
-    if (this.animationPlayer.advance(deltaSeconds)) this.notifyDirty();
-  }
-  //</editor-fold>
-  getLayerGroup(name) {
-    return super.getGroupByName(`layer:${name}`);
-  }
-  getGroupByName(name, layerName) {
-    return layerName === void 0 ? super.getGroupByName(name) : this.getLayerGroup(layerName)?.getObjectByName(`group:${name}`);
-  }
-  getMeshByName(name, layerName) {
-    return layerName === void 0 ? super.getMeshByName(name) : this.getLayerGroup(layerName)?.getObjectByName(`mesh:${name}`);
-  }
-  get entityLayers() {
-    return this.entity.layers ?? { main: this.entity };
-  }
-  getTextureKey(layer) {
-    if (layer.texture) return layer.texture;
-    const key = layer.key;
-    return new AssetKey(
-      key.namespace,
-      isAssetKey(key) ? key.getFullPath() : key.path,
-      "textures",
-      "entity",
-      "assets",
-      ".png"
-    );
-  }
-  async loadTextures(layer = this.entity) {
-    return ModelTextures.get(this.getTextureKey(layer));
-  }
-  createMeshes(force = false) {
-    if (this.meshesCreated && !force) return;
-    const modelRoot = new import_three13.Object3D();
-    const transform = this.options.flip === void 0 ? this.entity.transform : void 0;
-    if (transform) {
-      for (const op of transform) {
-        const matrix = new import_three13.Matrix4();
-        if ("scale" in op) matrix.makeScale(...op.scale);
-        else if ("translate" in op) matrix.makeTranslation(...op.translate);
-        else matrix.makeRotationFromEuler(new import_three13.Euler(...op.rotate, "ZYX"));
-        modelRoot.matrix.multiply(matrix);
-      }
-      modelRoot.matrixAutoUpdate = false;
-    } else if (this.options.flip ?? true) {
-      modelRoot.scale.set(-1, -1, 1);
-    }
-    this.add(modelRoot);
-    Object.entries(this.entityLayers).forEach(([name, layer], index) => {
-      const group = this.createGroup(`layer:${name}`);
-      modelRoot.add(group);
-      const inward = !Materials.entityModeCulls(layer.render ?? layer.layer.render);
-      this.createPart("root", layer.layer.root, group, layer.layer.texture, Materials.MISSING_TEXTURE, index, inward);
-    });
-    this.meshesCreated = true;
-  }
-  createPart(name, part, parent, textureSize, material, renderOrder, inward = true) {
-    const anchor = this.createGroup(name);
-    anchor.position.fromArray(part.pose.offset);
-    anchor.rotation.set(...part.pose.rotation, "ZYX");
-    anchor.scale.fromArray(part.pose.scale ?? [1, 1, 1]);
-    parent.add(anchor);
-    const size = part.texture ?? textureSize;
-    for (const cube of part.cubes) {
-      const [width, height, depth] = cube.size;
-      const [growX, growY, growZ] = cube.grow ?? [0, 0, 0];
-      const texture = new MinecraftCubeTexture(...cube.uv, ...size);
-      const uv = size[0] === 0 || size[1] === 0 ? new Array(48).fill(0) : texture.toUvArray(width, height, depth, cube.mirror);
-      const geometry = this._getBoxGeometryForDimensionsAndUv(
-        width + growX * 2,
-        height + growY * 2,
-        depth + growZ * 2,
-        uv
-      ).clone();
-      this.geometries.add(geometry);
-      geometry.translate(cube.origin[0] + width / 2, cube.origin[1] + height / 2, cube.origin[2] + depth / 2);
-      if (inward && Math.min(width + growX * 2, height + growY * 2, depth + growZ * 2) > 0) {
-        const index = Array.from(geometry.getIndex().array);
-        geometry.setIndex(index.concat(index.slice().reverse()));
-      }
-      const mesh = this.createMesh(name, geometry, material);
-      mesh.renderOrder = renderOrder;
-      anchor.add(mesh);
-      if (this.options.wireframe) this.disposeWireframes.push(addWireframeToMesh(geometry, mesh));
-    }
-    for (const [childName, child] of Object.entries(part.children)) {
-      this.createPart(childName, child, anchor, size, material, renderOrder, inward);
-    }
-  }
-  async applyTextures() {
-    this.clearScrollMaterials();
-    await Promise.all(Object.entries(this.entityLayers).map(async ([name, layer]) => {
-      const mode = layer.render ?? layer.layer.render ?? "cutout";
-      const tint = layer.tint === void 0 ? void 0 : this.options.tints?.[layer.tint];
-      const scroll = Materials.entityModeScroll(mode);
-      const assetKeyStr = this.getTextureKey(layer).serialize();
-      const keyStr = `entity:${mode}:${tint === void 0 ? "" : new import_three13.Color(tint).getHexString()}:${assetKeyStr}`;
-      let mat = scroll ? void 0 : Caching.materialCache.getIfPresent(keyStr);
-      if (!mat) {
-        const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
-        const imageData = await this.loadTextures(layer);
-        if (!imageData) return;
-        const canvas = imageData.data.canvas;
-        const createMaterial = () => Materials.createEntityCanvasMaterial(canvas, mode, tint);
-        mat = !scroll && cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
-        if (scroll) {
-          this.scrollMaterials.push({ material: mat, offset: mat.map.offset, speed: scroll });
-        }
-      }
-      this.getLayerGroup(name)?.traverse((object) => {
-        if (isMesh(object)) object.material = mat;
-      });
-    }));
-    if (!this.children.length) {
-      this.clearScrollMaterials();
-    } else if (this.scrollMaterials.length) {
-      this.updateScroll();
-    }
-    this.updateScrollSubscription();
-    this.notifyDirty();
-  }
-};
-_EntityObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS);
-var EntityObject = _EntityObject;
-function isEntityObject(obj) {
-  return obj.isEntityObject;
-}
+// src/entity/scene/index.ts
+init_EntityAnimationPlayer();
+init_EntityObject();
 
 // src/error/index.ts
 init_MineRenderError();
@@ -8097,7 +8333,7 @@ var GuiHelper = class {
 };
 
 // src/gui/scene/GuiObject.ts
-var import_three23 = require("three");
+var import_three24 = require("three");
 init_AssetKey();
 init_ModelTextures();
 init_Models();
@@ -8106,22 +8342,14 @@ init_SceneObject();
 init_Materials();
 init_ModelObject();
 init_DisplayPosition();
-
-// src/model/GuiLight.ts
-var GuiLight = /* @__PURE__ */ ((GuiLight2) => {
-  GuiLight2["FRONT"] = "front";
-  GuiLight2["SIDE"] = "side";
-  return GuiLight2;
-})(GuiLight || {});
-
-// src/gui/scene/GuiObject.ts
+init_GuiLight();
 var GuiObject = class extends SceneObject {
   constructor(textureLayers, options) {
     super({ ...options, instanceMeshes: false, mergeMeshes: false });
     this.textureLayers = textureLayers;
     this.isGuiObject = true;
     /** Local bounds in GUI pixels, with y growing down from the origin. */
-    this.bounds = new import_three23.Box2();
+    this.bounds = new import_three24.Box2();
     this.geometries = /* @__PURE__ */ new Set();
     this.ownedMaterials = /* @__PURE__ */ new Set();
     this.initialized = false;
@@ -8137,19 +8365,19 @@ var GuiObject = class extends SceneObject {
           const item = await this.createItem(layer, index);
           item.position.set(x + width2 / 2, -y - height2 / 2, 0);
           item.scale.set(width2 / 16, height2 / 16, width2 / 16);
-          item.updateMatrix();
-          const bounds = new import_three23.Box3();
+          item.updateWorldMatrix(true, true);
+          const inverse = this.matrixWorld.clone().invert();
+          const bounds = new import_three24.Box3();
           item.iterateAllMeshes((mesh2) => {
             mesh2.geometry.computeBoundingBox();
-            bounds.union(mesh2.geometry.boundingBox);
+            bounds.union(mesh2.geometry.boundingBox.clone().applyMatrix4(new import_three24.Matrix4().multiplyMatrices(inverse, mesh2.matrixWorld)));
           });
-          bounds.applyMatrix4(item.matrix);
           item.position.z = depth - bounds.min.z;
           depth += bounds.max.z - bounds.min.z + 0.01;
-          this.bounds.expandByPoint(new import_three23.Vector2(x, y));
-          this.bounds.expandByPoint(new import_three23.Vector2(x + width2, y + height2));
-          this.bounds.expandByPoint(new import_three23.Vector2(bounds.min.x, -bounds.max.y));
-          this.bounds.expandByPoint(new import_three23.Vector2(bounds.max.x, -bounds.min.y));
+          this.bounds.expandByPoint(new import_three24.Vector2(x, y));
+          this.bounds.expandByPoint(new import_three24.Vector2(x + width2, y + height2));
+          this.bounds.expandByPoint(new import_three24.Vector2(bounds.min.x, -bounds.max.y));
+          this.bounds.expandByPoint(new import_three24.Vector2(bounds.max.x, -bounds.min.y));
           continue;
         }
         const key = typeof layer.texture === "string" ? AssetKey.parse("textures", layer.texture) : layer.texture;
@@ -8157,7 +8385,7 @@ var GuiObject = class extends SceneObject {
         const image = material.map.image;
         const [cropX, cropY, cropWidth, cropHeight] = layer.crop ?? [0, 0, image.width, image.height];
         const [width, height] = layer.size ?? [cropWidth, cropHeight];
-        const geometry = new import_three23.PlaneGeometry(width, height);
+        const geometry = new import_three24.PlaneGeometry(width, height);
         this.geometries.add(geometry);
         const uv = geometry.getAttribute("uv");
         for (let i = 0; i < uv.count; i++) {
@@ -8167,13 +8395,13 @@ var GuiObject = class extends SceneObject {
             1 - (cropY + (1 - uv.getY(i)) * cropHeight) / image.height
           );
         }
-        const mesh = new import_three23.Mesh(geometry, material);
+        const mesh = new import_three24.Mesh(geometry, material);
         mesh.name = `mesh:${layer.name ?? index}`;
         mesh.position.set(x + width / 2, -y - height / 2, depth);
         mesh.renderOrder = index;
         this.add(mesh);
-        this.bounds.expandByPoint(new import_three23.Vector2(x, y));
-        this.bounds.expandByPoint(new import_three23.Vector2(x + width, y + height));
+        this.bounds.expandByPoint(new import_three24.Vector2(x, y));
+        this.bounds.expandByPoint(new import_three24.Vector2(x + width, y + height));
         depth += 0.01;
       }
       for (const child of this.children) child.position.z -= depth - 0.01;
@@ -8198,7 +8426,7 @@ var GuiObject = class extends SceneObject {
     this.add(item);
     await item.init();
     item.iterateAllMeshes((mesh) => {
-      this.geometries.add(mesh.geometry);
+      if (!model.special) this.geometries.add(mesh.geometry);
       mesh.name = `mesh:${layer.name ?? index}`;
       mesh.renderOrder = index;
       for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material]) {
@@ -8248,7 +8476,7 @@ function isGuiObject(obj) {
 init_image();
 
 // src/inspector/SceneInspector.ts
-var import_three24 = require("three");
+var import_three25 = require("three");
 init_SceneObject();
 init_util();
 init_log();
@@ -8258,11 +8486,11 @@ var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new import_three24.Vector2();
+    this.mouse = new import_three25.Vector2();
     this.listeners = new AbortController();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
-    this.raycaster = new import_three24.Raycaster();
+    this.raycaster = new import_three25.Raycaster();
     this.init();
   }
   init() {
@@ -8656,29 +8884,15 @@ function isInstanceable(obj) {
 // src/model/index.ts
 init_DisplayPosition();
 init_DisplayTransforms();
-
-// src/model/Model.ts
-var ITEM_GENERATED = "item/generated";
-var BUILTIN_GENERATED = "builtin/generated";
-var BUILTIN_ENTITY = "builtin/entity";
-var DEFAULT_ELEMENTS = [];
-function isDoubleArray(obj) {
-  return Array.isArray(obj) && obj.length === 2;
-}
-function isTripleArray(obj) {
-  return Array.isArray(obj) && obj.length === 3;
-}
-function isQuadArray(obj) {
-  return Array.isArray(obj) && obj.length === 4;
-}
-
-// src/model/index.ts
+init_GuiLight();
+init_Model();
 init_ModelCulling();
 init_ModelGenerator();
 init_ModelMerger();
+init_SpecialItems();
 
 // src/model/block/BlockStateResolver.ts
-var import_three26 = require("three");
+var import_three27 = require("three");
 init_BlockStates();
 init_MineRenderError();
 init_util();
@@ -8756,7 +8970,7 @@ var BlockStateResolver = class {
     return variants[variants.length - 1];
   }
   static rotation(variant) {
-    const rotation = new import_three26.Euler();
+    const rotation = new import_three27.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -8863,12 +9077,13 @@ init_SceneObject();
 init_ModelObject();
 init_Models();
 var import_ts_deepmerge6 = __toESM(require_dist());
-var import_three29 = require("three");
+var import_three30 = require("three");
 init_MineRenderError();
 init_InstanceReference();
 init_AssetKey();
 init_ModelCulling();
 init_FluidGeometry();
+init_Entities();
 var _BlockObject = class _BlockObject extends SceneObject {
   constructor(blockState, options) {
     super(options);
@@ -8884,7 +9099,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     this._models = [];
     this._cullMask = 0;
     this._entities = [];
-    this._entityPlacement = new import_three29.Matrix4();
+    this._entityPlacement = new import_three30.Matrix4();
     this._entityGeneration = 0;
     this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
   }
@@ -8964,7 +9179,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     return true;
   }
   placeEntities() {
-    const matrix = new import_three29.Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
+    const matrix = new import_three30.Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
     for (const entity of this._entities) {
       matrix.decompose(entity.position, entity.quaternion, entity.scale);
     }
@@ -8983,12 +9198,12 @@ var _BlockObject = class _BlockObject extends SceneObject {
   getModelCullMask(model, worldMask) {
     const object = isInstanceReference(model) ? model.instanceable : model;
     if (object.options.displayPosition) return 0;
-    const position = new import_three29.Vector3();
-    const rotation = new import_three29.Quaternion();
-    const scale = new import_three29.Vector3();
+    const position = new import_three30.Vector3();
+    const rotation = new import_three30.Quaternion();
+    const scale = new import_three30.Vector3();
     this.getModelMatrix(model).decompose(position, rotation, scale);
-    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three29.Vector3(1, 1, 1)) > 1e-10) return 0;
-    return ModelCulling.toLocalMask(worldMask, new import_three29.Euler().setFromQuaternion(rotation));
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three30.Vector3(1, 1, 1)) > 1e-10) return 0;
+    return ModelCulling.toLocalMask(worldMask, new import_three30.Euler().setFromQuaternion(rotation));
   }
   async setCullMask(worldMask) {
     worldMask &= 63;
@@ -9050,7 +9265,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
       () => new FluidModelObject2(kind, surface.sample, this.blockState.key, this.options)
     );
     const previous = this._fluidModel;
-    const matrix = previous ? this.getModelMatrix(previous) : new import_three29.Matrix4().makeTranslation(...this.position.toArray());
+    const matrix = previous ? this.getModelMatrix(previous) : new import_three30.Matrix4().makeTranslation(...this.position.toArray());
     if (isInstanceReference(replacement)) replacement.setMatrix(matrix);
     else matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
     this._models = this._models.filter((model) => model !== previous);
@@ -9188,7 +9403,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new import_three29.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three30.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -11059,7 +11274,7 @@ init_ModelObject();
 init_nbt();
 
 // src/renderer/MineRenderScene.ts
-var import_three31 = require("three");
+var import_three32 = require("three");
 init_SceneObject();
 var import_ts_deepmerge8 = __toESM(require_dist());
 init_ModelObject();
@@ -11792,7 +12007,7 @@ var import_ts_deepmerge7 = __toESM(require_dist());
 init_util();
 
 // src/skin/SkinTextures.ts
-var import_three30 = require("three");
+var import_three31 = require("three");
 init_Caching();
 init_CacheKey();
 init_MineRenderError();
@@ -11876,11 +12091,11 @@ var SkinTextures = class {
     });
   }
   static createMaterial(pixels, width, height, transparent = true) {
-    const texture = Textures.initTextureProps(new import_three30.DataTexture(pixels, width, height));
-    texture.colorSpace = import_three30.SRGBColorSpace;
+    const texture = Textures.initTextureProps(new import_three31.DataTexture(pixels, width, height));
+    texture.colorSpace = import_three31.SRGBColorSpace;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new import_three30.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three30.DoubleSide : import_three30.FrontSide, alphaTest: transparent ? 0.1 : 0 });
+    return new import_three31.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three31.DoubleSide : import_three31.FrontSide, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -12108,7 +12323,8 @@ var SkinObject = class extends SceneObject {
 };
 
 // src/renderer/MineRenderScene.ts
-var _MineRenderScene = class _MineRenderScene extends import_three31.Scene {
+init_EntityObject();
+var _MineRenderScene = class _MineRenderScene extends import_three32.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -12235,19 +12451,20 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three33 = require("three");
+var import_three34 = require("three");
 var import_ts_deepmerge9 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
 init_util();
+init_Model();
 init_three();
 
 // src/three/OrbitControls.js
-var import_three32 = require("three");
+var import_three33 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three32.EventDispatcher {
+var OrbitControls = class extends import_three33.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -12256,7 +12473,7 @@ var OrbitControls = class extends import_three32.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three32.Vector3();
+    this.target = new import_three33.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -12278,8 +12495,8 @@ var OrbitControls = class extends import_three32.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three32.MOUSE.ROTATE, MIDDLE: import_three32.MOUSE.DOLLY, RIGHT: import_three32.MOUSE.PAN };
-    this.touches = { ONE: import_three32.TOUCH.ROTATE, TWO: import_three32.TOUCH.DOLLY_PAN };
+    this.mouseButtons = { LEFT: import_three33.MOUSE.ROTATE, MIDDLE: import_three33.MOUSE.DOLLY, RIGHT: import_three33.MOUSE.PAN };
+    this.touches = { ONE: import_three33.TOUCH.ROTATE, TWO: import_three33.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -12308,11 +12525,11 @@ var OrbitControls = class extends import_three32.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three32.Vector3();
-      const quat = new import_three32.Quaternion().setFromUnitVectors(object.up, new import_three32.Vector3(0, 1, 0));
+      const offset = new import_three33.Vector3();
+      const quat = new import_three33.Quaternion().setFromUnitVectors(object.up, new import_three33.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three32.Vector3();
-      const lastQuaternion = new import_three32.Quaternion();
+      const lastPosition = new import_three33.Vector3();
+      const lastQuaternion = new import_three33.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -12398,20 +12615,20 @@ var OrbitControls = class extends import_three32.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three32.Spherical();
-    const sphericalDelta = new import_three32.Spherical();
+    const spherical = new import_three33.Spherical();
+    const sphericalDelta = new import_three33.Spherical();
     let scale = 1;
-    const panOffset = new import_three32.Vector3();
+    const panOffset = new import_three33.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three32.Vector2();
-    const rotateEnd = new import_three32.Vector2();
-    const rotateDelta = new import_three32.Vector2();
-    const panStart = new import_three32.Vector2();
-    const panEnd = new import_three32.Vector2();
-    const panDelta = new import_three32.Vector2();
-    const dollyStart = new import_three32.Vector2();
-    const dollyEnd = new import_three32.Vector2();
-    const dollyDelta = new import_three32.Vector2();
+    const rotateStart = new import_three33.Vector2();
+    const rotateEnd = new import_three33.Vector2();
+    const rotateDelta = new import_three33.Vector2();
+    const panStart = new import_three33.Vector2();
+    const panEnd = new import_three33.Vector2();
+    const panDelta = new import_three33.Vector2();
+    const dollyStart = new import_three33.Vector2();
+    const dollyEnd = new import_three33.Vector2();
+    const dollyDelta = new import_three33.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -12427,7 +12644,7 @@ var OrbitControls = class extends import_three32.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three32.Vector3();
+      const v = new import_three33.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -12435,7 +12652,7 @@ var OrbitControls = class extends import_three32.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three32.Vector3();
+      const v = new import_three33.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -12448,7 +12665,7 @@ var OrbitControls = class extends import_three32.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three32.Vector3();
+      const offset = new import_three33.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -12697,12 +12914,12 @@ var OrbitControls = class extends import_three32.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three32.MOUSE.DOLLY:
+        case import_three33.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three32.MOUSE.ROTATE:
+        case import_three33.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -12713,7 +12930,7 @@ var OrbitControls = class extends import_three32.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three32.MOUSE.PAN:
+        case import_three33.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -12769,12 +12986,12 @@ var OrbitControls = class extends import_three32.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three32.TOUCH.ROTATE:
+            case import_three33.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three32.TOUCH.PAN:
+            case import_three33.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -12785,12 +13002,12 @@ var OrbitControls = class extends import_three32.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three32.TOUCH.DOLLY_PAN:
+            case import_three33.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three32.TOUCH.DOLLY_ROTATE:
+            case import_three33.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -12857,7 +13074,7 @@ var OrbitControls = class extends import_three32.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three32.Vector2();
+        position = new import_three33.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -12877,10 +13094,10 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three32.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three32.MOUSE.ROTATE;
-    this.touches.ONE = import_three32.TOUCH.PAN;
-    this.touches.TWO = import_three32.TOUCH.DOLLY_ROTATE;
+    this.mouseButtons.LEFT = import_three33.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three33.MOUSE.ROTATE;
+    this.touches.ONE = import_three33.TOUCH.PAN;
+    this.touches.TWO = import_three33.TOUCH.DOLLY_ROTATE;
   }
 };
 
@@ -12931,14 +13148,14 @@ var _Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three33.PerspectiveCamera(
+        return new import_three34.PerspectiveCamera(
           this.options.camera.perspective.fov,
           this.options.camera.perspective.aspect ?? this.viewWidth / this.viewHeight,
           this.options.camera.near,
           this.options.camera.far
         );
       case "orthographic":
-        return new import_three33.OrthographicCamera(
+        return new import_three34.OrthographicCamera(
           this.options.camera.orthographic.left ?? this.viewWidth / -2,
           this.options.camera.orthographic.right ?? this.viewWidth / 2,
           this.options.camera.orthographic.top ?? this.viewHeight / 2,
@@ -12949,7 +13166,7 @@ var _Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three33.WebGLRenderer({
+    const renderer = new import_three34.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -12957,8 +13174,8 @@ var _Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three33.PCFSoftShadowMap;
-    renderer.outputColorSpace = import_three33.SRGBColorSpace;
+    renderer.shadowMap.type = import_three34.PCFSoftShadowMap;
+    renderer.outputColorSpace = import_three34.SRGBColorSpace;
     renderer.setPixelRatio(this.options.render.pixelRatio ?? 1);
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
@@ -12993,20 +13210,20 @@ var _Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three33.GridHelper(128, 16);
+      const gridHelper = new import_three34.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three33.GridHelper(128, 16);
+      const gridHelper2 = new import_three34.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three33.GridHelper(128, 16);
+      const gridHelper3 = new import_three34.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper3);
       gridHelper3.rotation.z = 90 * (Math.PI / 180);
       this.scene.add(gridHelper3);
     }
     if (this.options.debug.axes) {
-      const axesHelper = new import_three33.AxesHelper(64);
+      const axesHelper = new import_three34.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -13265,8 +13482,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new import_three33.Vector3(50, 50, 50),
-    lookingAt: new import_three33.Vector3(0, 0, 0)
+    position: new import_three34.Vector3(50, 50, 50),
+    lookingAt: new import_three34.Vector3(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -13730,19 +13947,20 @@ var AnvilParser = class {
 };
 
 // src/world/Chunk.ts
-var import_three38 = require("three");
+var import_three39 = require("three");
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
-var import_three36 = require("three");
+var import_three37 = require("three");
+init_Model();
 init_BatchedExecutor();
 init_AssetKey();
 init_BlockStates();
 init_CubeFace();
 
 // src/world/SectionModels.ts
-var import_three35 = require("three");
+var import_three36 = require("three");
 init_AssetKey();
 init_Models();
 init_CubeFace();
@@ -13808,12 +14026,12 @@ var SectionModels = class {
         });
         await object.init();
         const geometry = object.children[0].geometry;
-        geometry.applyMatrix4(new import_three35.Matrix4().makeRotationFromEuler(rotation));
+        geometry.applyMatrix4(new import_three36.Matrix4().makeRotationFromEuler(rotation));
         object.clear();
         const cullFaces = CUBE_FACES.map((face) => {
           const local = CUBE_FACES.findIndex((name) => name === atlas.model.elements[0].faces[face]?.cullface);
           if (local < 0) return 0;
-          const normal = new import_three35.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const normal = new import_three36.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
           const world = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           return 1 << world;
         });
@@ -13843,20 +14061,20 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three36.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three37.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three36.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three37.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three36.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three37.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three36.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three37.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -13877,7 +14095,7 @@ var MineRenderWorld = class {
     const collect = async (positions2) => {
       for (const pos of positions2) changes.set(pos.toArray().join(","), pos);
     };
-    const place = (block) => this.placeBlock(new import_three36.Vector3(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new import_three37.Vector3(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -13955,13 +14173,13 @@ var MineRenderWorld = class {
     for (const pos of positions) {
       this.pendingCulling.set(pos.toArray().join(","), pos.clone());
       for (const offset of CUBE_FACE_OFFSETS) {
-        const neighbor = pos.clone().add(new import_three36.Vector3(...offset));
+        const neighbor = pos.clone().add(new import_three37.Vector3(...offset));
         this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
       }
       for (let y = -1; y <= 1; y++) {
         for (let z = -1; z <= 1; z++) {
           for (let x = -1; x <= 1; x++) {
-            const neighbor = pos.clone().add(new import_three36.Vector3(x, y, z));
+            const neighbor = pos.clone().add(new import_three37.Vector3(x, y, z));
             if (this.getBlockAt(neighbor)?.object?.fluidKind) {
               this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
             }
@@ -13983,7 +14201,7 @@ var MineRenderWorld = class {
             if (!block) continue;
             if (block.object?.fluidKind) {
               await block.object.updateFluid((x, y, z) => {
-                const neighbor = pos.clone().add(new import_three36.Vector3(x, y, z));
+                const neighbor = pos.clone().add(new import_three37.Vector3(x, y, z));
                 const section = this.getChunkAt(neighbor);
                 const object = section?.getBlockAt(neighbor)?.object;
                 return {
@@ -13995,7 +14213,7 @@ var MineRenderWorld = class {
             }
             let mask = 0;
             for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
-              const neighbor = pos.clone().add(new import_three36.Vector3(...offset));
+              const neighbor = pos.clone().add(new import_three37.Vector3(...offset));
               if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
                 mask |= 1 << face;
               }
@@ -14029,14 +14247,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new import_three36.Vector3(
+    return new import_three37.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three36.Vector3(
+    return new import_three37.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -14055,11 +14273,14 @@ var MineRenderWorld = class {
   }
 };
 
+// src/world/Chunk.ts
+init_Model();
+
 // src/world/SectionMesh.ts
-var import_three37 = require("three");
+var import_three38 = require("three");
 init_CanvasCompat();
 init_Materials();
-var SectionMesh = class _SectionMesh extends import_three37.Group {
+var SectionMesh = class _SectionMesh extends import_three38.Group {
   constructor() {
     super(...arguments);
     this.ownedMeshes = [];
@@ -14132,18 +14353,18 @@ var SectionMesh = class _SectionMesh extends import_three37.Group {
           for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
         }
       }
-      const geometry = new import_three37.BufferGeometry();
-      geometry.setAttribute("position", new import_three37.Float32BufferAttribute(positions, 3));
-      geometry.setAttribute("normal", new import_three37.Float32BufferAttribute(normals, 3));
-      geometry.setAttribute("uv", new import_three37.Float32BufferAttribute(uvs, 2));
-      geometry.setAttribute("color", new import_three37.Float32BufferAttribute(colors, 3));
+      const geometry = new import_three38.BufferGeometry();
+      geometry.setAttribute("position", new import_three38.Float32BufferAttribute(positions, 3));
+      geometry.setAttribute("normal", new import_three38.Float32BufferAttribute(normals, 3));
+      geometry.setAttribute("uv", new import_three38.Float32BufferAttribute(uvs, 2));
+      geometry.setAttribute("color", new import_three38.Float32BufferAttribute(colors, 3));
       geometry.setIndex(indices);
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
       const material = Materials.createShadedCanvasMaterial(canvas, false);
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
-      const mesh = new import_three37.Mesh(geometry, material);
+      const mesh = new import_three38.Mesh(geometry, material);
       section.add(mesh);
       section.ownedMeshes.push({ mesh, texture });
     }
@@ -14177,10 +14398,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three38.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three39.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three38.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three39.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -14188,10 +14409,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three38.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three39.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three38.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three39.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -14277,7 +14498,7 @@ var Chunk = class _Chunk {
   }
   async clear(onBlocksChanged = this.onBlocksChanged) {
     const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new import_three38.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new import_three39.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     ));
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -14301,14 +14522,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three38.Vector3(
+    return new import_three39.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three38.Vector3(
+    return new import_three39.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z