minerender 2.1.0-beta.7 → 2.1.0-beta.8

package/dist/node/index.js

@@ -184,8 +184,6 @@ async function sleep(timeout) {
   });
 }
 function yieldToEventLoop() {
-  const scheduler = globalThis.scheduler;
-  if (scheduler?.yield) return scheduler.yield();
   return new Promise((resolve) => {
     if (typeof MessageChannel !== "undefined") {
       const channel = new MessageChannel();
@@ -243,6 +241,10 @@ var init_Caching = __esm({
     import_loading_cache = require("@inventivetalent/loading-cache");
     import_time = require("@inventivetalent/time");
     Caching = class _Caching {
+      static {
+        /** Cached in place of a missing asset. The caches drop `undefined` results, which would request the asset again. */
+        this.MISSING = false;
+      }
       static {
         this._generation = 0;
       }
@@ -310,6 +312,9 @@ var init_Caching = __esm({
       static {
         this.blockEntityIndexCache = _Caching.createAssetCache();
       }
+      static {
+        this.entityDatasetVersionCache = _Caching.createAssetCache();
+      }
       static {
         this.unihexCache = _Caching.createAssetCache();
       }
@@ -319,6 +324,12 @@ var init_Caching = __esm({
       static {
         this.bannerPatternCache = _Caching.createAssetCache();
       }
+      static {
+        this.equipmentCache = _Caching.createAssetCache();
+      }
+      static {
+        this.trimCache = _Caching.createAssetCache();
+      }
       static {
         this.mineRenderDataCache = _Caching.createAssetCache();
       }
@@ -354,9 +365,12 @@ var init_Caching = __esm({
           this.entityTextureCache,
           this.entityAnimationCache,
           this.blockEntityIndexCache,
+          this.entityDatasetVersionCache,
           this.fontCache,
           this.unihexCache,
           this.bannerPatternCache,
+          this.equipmentCache,
+          this.trimCache,
           this.mineRenderDataCache,
           this.usernameUuidCache,
           this.biomeCache
@@ -2404,15 +2418,21 @@ var init_ModelTextures = __esm({
           key.extension += ".mcmeta";
         }
         const keyStr = key.serialize();
-        return Caching.textureMetaCache.get(keyStr, (k) => {
-          return this.PERSISTENT_META_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
-            return AssetLoader.get(key, "meta" /* META */).then((asset2) => {
-              if (asset2)
-                asset2.key = key;
-              return asset2;
-            });
+        const meta = await Caching.textureMetaCache.get(keyStr, (k) => {
+          return this.PERSISTENT_META_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), async (k1) => {
+            if (AssetLoader.persistentScope === "") {
+              const path = key.getFullPath();
+              const slash = path.lastIndexOf("/");
+              const listKey = new AssetKey(key.namespace, `${path.slice(0, slash + 1)}_list`, "textures", void 0, "assets", ".json", key.root);
+              const list2 = await Caching.listAssetCache.get(listKey.serialize(), () => AssetLoader.get(listKey, "list" /* LIST */)).catch(() => void 0);
+              if (list2 && !list2.files.includes(`${path.slice(slash + 1)}${key.extension}`)) return Caching.MISSING;
+            }
+            const asset2 = await AssetLoader.get(key, "meta" /* META */);
+            if (asset2) asset2.key = key;
+            return asset2 ?? Caching.MISSING;
           });
         });
+        return meta === Caching.MISSING ? void 0 : meta;
       }
       /** Clears persisted texture metadata. Use {@link Caching.clear} to discard in-memory textures and metadata. */
       static async clearCache() {
@@ -3332,23 +3352,303 @@ var init_MinecraftCubeTexture = __esm({
   }
 });
 
+// src/assets/_versions/DatasetVersions.ts
+var parseRelease, compare2, nearestRelease;
+var init_DatasetVersions = __esm({
+  "src/assets/_versions/DatasetVersions.ts"() {
+    parseRelease = (value) => /^\d+\.\d+(?:\.\d+)?$/.test(value) ? value.split(".").map(Number) : void 0;
+    compare2 = (left, right) => {
+      for (let i = 0; i < 3; i++) {
+        const difference = (left[i] ?? 0) - (right[i] ?? 0);
+        if (difference) return difference;
+      }
+      return 0;
+    };
+    nearestRelease = (requestedVersion, published) => {
+      const requested = parseRelease(requestedVersion);
+      if (!requested) return void 0;
+      const versions = published.map((name) => ({ name, number: parseRelease(name) })).filter((entry) => !!entry.number).sort((left, right) => compare2(left.number, right.number));
+      const sameLine = versions.filter((entry) => entry.number[0] === requested[0] && entry.number[1] === requested[1]);
+      const selected = sameLine.sort((left, right) => Math.abs((left.number[2] ?? 0) - (requested[2] ?? 0)) - Math.abs((right.number[2] ?? 0) - (requested[2] ?? 0)) || compare2(left.number, right.number))[0] ?? versions.filter((entry) => compare2(entry.number, requested) <= 0).pop() ?? versions[0];
+      return selected?.name;
+    };
+  }
+});
+
+// src/error/MineRenderError.ts
+var MineRenderError;
+var init_MineRenderError = __esm({
+  "src/error/MineRenderError.ts"() {
+    MineRenderError = class _MineRenderError extends Error {
+      constructor(msg) {
+        super(msg);
+        Object.setPrototypeOf(this, _MineRenderError.prototype);
+      }
+      get name() {
+        return "MineRenderError";
+      }
+    };
+  }
+});
+
+// src/assets/Entities.ts
+var Entities;
+var init_Entities = __esm({
+  "src/assets/Entities.ts"() {
+    init_AssetKey();
+    init_DatasetVersions();
+    init_AssetLoader();
+    init_source();
+    init_Caching();
+    init_AssetDefaults();
+    init_MineRenderError();
+    init_ModelTextures();
+    Entities = class {
+      /**
+       * Resolves `root` (default: the active version). Uses the exact dataset when published or when the
+       * version is not a release; otherwise selects the nearest published release, like {@link MineRenderData.resolve}.
+       * Textures keep the requested root.
+       */
+      static async getDatasetRoot(root) {
+        const requestRoot = (root ?? AssetLoader.ROOT).replace(/\/+$/, "");
+        const requestedVersion = requestRoot.slice(requestRoot.lastIndexOf("/") + 1);
+        const base = requestRoot.slice(0, requestRoot.lastIndexOf("/"));
+        const selected = await Caching.entityDatasetVersionCache.get(root ?? `sources:${AssetLoader.ROOT}`, async () => {
+          const key = new AssetKey("entity-models", "version", void 0, void 0, void 0, ".json", root);
+          key.rootType = void 0;
+          if (!parseRelease(requestedVersion) || await AssetLoader.get(key, "json" /* JSON */) !== void 0) return requestedVersion;
+          const indexKey = new AssetKey("entity-models", "versions", void 0, void 0, void 0, ".json", base);
+          indexKey.rootType = void 0;
+          const index = await AssetLoader.get(indexKey, "json" /* JSON */);
+          if (index === void 0) return requestedVersion;
+          if (!index || typeof index !== "object" || Array.isArray(index) || !Array.isArray(index.versions) || !index.versions.every((entry) => entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.name === "string")) {
+            throw new MineRenderError(`Invalid entity model version index at ${base}/entity-models/versions.json`);
+          }
+          return nearestRelease(requestedVersion, index.versions.map((entry) => entry.name)) ?? requestedVersion;
+        });
+        return selected === requestedVersion ? root : `${base}/${selected}`;
+      }
+      /** Lists model paths in the `minecraft` namespace, including subdirectories and excluding `.json`. */
+      static async getEntityList() {
+        const root = await this.getDatasetRoot();
+        const collect = async (path) => {
+          const prefix2 = path ? `${path}/` : "";
+          const key = new AssetKey(DEFAULT_NAMESPACE, `${prefix2}_list`, void 0, void 0, "entity-models", ".json", root);
+          const list2 = await Caching.listAssetCache.get(key.serialize(), () => AssetLoader.get(key, "list" /* LIST */));
+          if (!list2) return [];
+          const files = list2.files.filter((file) => file.endsWith(".json") && file !== "_list.json").map((file) => `${prefix2}${file.slice(0, -5)}`);
+          const children = await Promise.all(list2.directories.map((directory) => collect(`${prefix2}${directory}`)));
+          return [...files, ...children.flat()];
+        };
+        return collect("");
+      }
+      /** @internal */
+      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", await this.getDatasetRoot(isAssetKey(modelKey) ? modelKey.root : void 0));
+        return Caching.entityModelCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+      }
+      /** Returns selectable geometry-layer names, or an empty list when the model is missing. */
+      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 ?? [];
+      }
+      /**
+       * Loads the layers and textures to pass to {@link MineRenderScene.addEntity}.
+       * By default, selects `main`, unconditional passes, and passes enabled by `options.when`.
+       *
+       * @param modelKey - Dataset model, such as `new BasicAssetKey("minecraft", "zombie")`.
+       * @param textureKey - Texture override for the first selected layer.
+       * @param options - Layer selection, conditional passes, and per-layer texture overrides.
+       * @returns The selected model, or `undefined` when its dataset file is missing.
+       */
+      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 } };
+      }
+      /**
+       * Native and sampled vanilla clips by name, or undefined when the model or 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", await this.getDatasetRoot(isAssetKey(modelKey) ? modelKey.root : void 0));
+        const file = await Caching.entityAnimationCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+        return file?.animations;
+      }
+      /** Finds a fallback texture using the model path, its directory, and vanilla variant data. */
+      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);
+        const texture = await Caching.entityTextureCache.get(key.serialize(), async () => {
+          const name = path.split("/").pop();
+          for (const candidate of [path, `${path}/${name}`]) {
+            const texture3 = new AssetKey(modelKey.namespace, candidate, "textures", "entity", "assets", ".png", root);
+            if (await ModelTextures.get(texture3)) return texture3;
+          }
+          const listKey = new AssetKey(modelKey.namespace, "_list", `${name}_variant`, void 0, "data", ".json", root);
+          const list2 = await AssetLoader.get(listKey, "list" /* LIST */);
+          const files = list2?.files.filter((file2) => file2.endsWith(".json") && file2 !== "_list.json");
+          const file = files?.find((file2) => file2 === "temperate.json") ?? files?.[0];
+          if (!file) return Caching.MISSING;
+          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 Caching.MISSING;
+          const texture2 = AssetKey.parse("textures", textureId);
+          texture2.root = root;
+          return texture2;
+        });
+        return texture === Caching.MISSING ? void 0 : 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/armor/Armor.ts
+var Armor_exports = {};
+__export(Armor_exports, {
+  Armor: () => Armor
+});
+var ARMOR_TRANSFORM, Armor;
+var init_Armor = __esm({
+  "src/armor/Armor.ts"() {
+    init_AssetKey();
+    init_AssetLoader();
+    init_Entities();
+    init_AssetParsers();
+    init_Caching();
+    init_MineRenderError();
+    ARMOR_TRANSFORM = [
+      { rotate: [0, Math.PI, 0] },
+      { scale: [-1, -1, 1] },
+      { translate: [0, -24, 0] }
+    ];
+    Armor = class {
+      /** Loads 1.21.4+ armor in SkinObject's frame, or returns undefined when no layer draws. */
+      static async getEntity(armor) {
+        const model = await Entities.getModelFile(new BasicAssetKey("minecraft", "player"));
+        const layers = {};
+        const slots = { chest: "chestplate", legs: "leggings", feet: "boots", head: "helmet" };
+        for (const slot of Object.keys(slots)) {
+          const value = armor[slot];
+          if (value === void 0) continue;
+          const piece = typeof value === "string" ? { asset: value } : value;
+          const name = slots[slot], geometry = model?.layers[name];
+          if (!geometry) throw new MineRenderError(`Missing armor geometry ${name}; armor needs Minecraft 1.21.4 or later`);
+          const id = this.identifier(piece.asset);
+          const key = new AssetKey(id.namespace, id.path, "equipment", void 0, "assets", ".json");
+          const equipment = await Caching.equipmentCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+          if (!equipment) throw new MineRenderError(`Missing equipment asset ${piece.asset}; armor takes equipment asset IDs such as minecraft:diamond and needs Minecraft 1.21.4 or later`);
+          const layerType = slot === "legs" ? "humanoid_leggings" : "humanoid";
+          const equipmentLayers = equipment.layers[layerType];
+          if (!equipmentLayers?.length) continue;
+          let count = 0;
+          const add = (texture, settings) => {
+            layers[++count === 1 ? name : `${name}#${count}`] = { key: texture, texture, layer: geometry, ...settings };
+          };
+          let glint = piece.glint;
+          for (const layer of equipmentLayers) {
+            let color2;
+            if (layer.dyeable) {
+              const undyed = layer.dyeable.color_when_undyed;
+              color2 = piece.color || (Array.isArray(undyed) ? Math.floor(undyed[0] * 255) << 16 | Math.floor(undyed[1] * 255) << 8 | Math.floor(undyed[2] * 255) : undyed === void 0 ? void 0 : undyed & 16777215);
+              if (color2 === void 0) continue;
+            }
+            const texture = this.identifier(layer.texture);
+            add(
+              new AssetKey(texture.namespace, `equipment/${layerType}/${texture.path}`, "textures", "entity", "assets", ".png"),
+              { ...color2 !== void 0 && { color: color2 }, ...glint && { glint: true } }
+            );
+            glint = false;
+          }
+          if (piece.trim) {
+            const patternId = this.identifier(piece.trim.pattern), materialId = this.identifier(piece.trim.material);
+            const patternKey = new AssetKey(patternId.namespace, patternId.path, "trim_pattern", void 0, "data", ".json");
+            const materialKey = new AssetKey(materialId.namespace, materialId.path, "trim_material", void 0, "data", ".json");
+            const pattern2 = await Caching.trimCache.get(patternKey.serialize(), () => AssetLoader.get(patternKey, "json" /* JSON */));
+            if (!pattern2) throw new MineRenderError(`Missing trim pattern ${piece.trim.pattern}`);
+            const material = await Caching.trimCache.get(materialKey.serialize(), () => AssetLoader.get(materialKey, "json" /* JSON */));
+            if (!material) throw new MineRenderError(`Missing trim material ${piece.trim.material}`);
+            const patternAsset = this.identifier(pattern2.asset_id);
+            const suffix = material.override_armor_assets?.[id.toNamespacedString()] ?? material.asset_name;
+            add(new AssetKey(patternAsset.namespace, `entity/${layerType}/${patternAsset.path}`, "textures", "trims", "assets", ".png"), {
+              palette: {
+                key: new AssetKey("minecraft", "color_palettes/trim_palette", "textures", "trims", "assets", ".png"),
+                permutation: new AssetKey("minecraft", `color_palettes/${suffix}`, "textures", "trims", "assets", ".png")
+              },
+              render: pattern2.decal ? "cutout_z_offset" : "cutout"
+            });
+          }
+        }
+        const first = Object.values(layers)[0];
+        return first ? { ...first, id: "minecraft:player", layers, transform: ARMOR_TRANSFORM } : void 0;
+      }
+      static identifier(value) {
+        if (!isResourceLocation(value) || value.split(/[:/]/).some((part) => !part || part === "." || part === "..")) {
+          throw new MineRenderError(`Invalid armor identifier ${value}`);
+        }
+        const [namespace, path] = value.includes(":") ? value.split(":") : ["minecraft", value];
+        return new BasicAssetKey(namespace, path);
+      }
+    };
+  }
+});
+
 // src/assets/MineRenderData.ts
-var object2, release, compare2, MineRenderData;
+var object2, MineRenderData;
 var init_MineRenderData = __esm({
   "src/assets/MineRenderData.ts"() {
+    init_DatasetVersions();
     init_AssetKey();
     init_AssetLoader();
     init_AssetParsers();
     init_Caching();
     object2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-    release = (value) => /^\d+\.\d+(?:\.\d+)?$/.test(value) ? value.split(".").map(Number) : void 0;
-    compare2 = (left, right) => {
-      for (let i = 0; i < 3; i++) {
-        const difference = (left[i] ?? 0) - (right[i] ?? 0);
-        if (difference) return difference;
-      }
-      return 0;
-    };
     MineRenderData = class {
       /** Loads one registry. Missing files and invalid data reject the request. */
       static async get(dataset, root) {
@@ -3378,9 +3678,9 @@ var init_MineRenderData = __esm({
         const scope = AssetLoader.persistentScope;
         return this.cached(`resolve:${requestRoot === void 0 ? "sources" : "explicit"}:${root}`, scope, defaultRoot, async () => {
           const requestedVersion = root.slice(root.lastIndexOf("/") + 1);
-          let manifest = await this.manifest(root, requestRoot !== void 0 && release(requestedVersion) ? requestedVersion : void 0, requestRoot);
+          let manifest = await this.manifest(root, requestRoot !== void 0 && parseRelease(requestedVersion) ? requestedVersion : void 0, requestRoot);
           if (manifest) return { requestedVersion, version: manifest.minecraftVersion, root, manifest };
-          const requested = release(requestedVersion);
+          const requested = parseRelease(requestedVersion);
           if (!requested) {
             throw new Error(`No MineRender data is published for ${requestedVersion}; automatic fallback requires a release`);
           }
@@ -3392,14 +3692,12 @@ var init_MineRenderData = __esm({
             }
             return value.versions;
           });
-          const versions = index.map((entry) => ({ name: entry.name, number: release(entry.name) })).filter((entry) => !!entry.number).sort((left, right) => compare2(left.number, right.number));
-          const sameLine = versions.filter((entry) => entry.number[0] === requested[0] && entry.number[1] === requested[1]);
-          const selected = sameLine.sort((left, right) => Math.abs((left.number[2] ?? 0) - (requested[2] ?? 0)) - Math.abs((right.number[2] ?? 0) - (requested[2] ?? 0)) || compare2(left.number, right.number))[0] ?? versions.filter((entry) => compare2(entry.number, requested) <= 0).pop() ?? versions[0];
+          const selected = nearestRelease(requestedVersion, index.map((entry) => entry.name));
           if (!selected) throw new Error(`No compatible MineRender data is published for ${requestedVersion}`);
-          const resolvedRoot = `${base}/${selected.name}`;
-          manifest = await this.manifest(resolvedRoot, selected.name, resolvedRoot);
-          if (!manifest) throw new Error(`Missing MineRender manifest for published version ${selected.name}`);
-          return { requestedVersion, version: selected.name, root: resolvedRoot, manifest };
+          const resolvedRoot = `${base}/${selected}`;
+          manifest = await this.manifest(resolvedRoot, selected, resolvedRoot);
+          if (!manifest) throw new Error(`Missing MineRender manifest for published version ${selected}`);
+          return { requestedVersion, version: selected, root: resolvedRoot, manifest };
         });
       }
       static async manifest(root, expectedVersion, requestRoot) {
@@ -3731,22 +4029,6 @@ var init_ItemDefaults = __esm({
   }
 });
 
-// src/error/MineRenderError.ts
-var MineRenderError;
-var init_MineRenderError = __esm({
-  "src/error/MineRenderError.ts"() {
-    MineRenderError = class _MineRenderError extends Error {
-      constructor(msg) {
-        super(msg);
-        Object.setPrototypeOf(this, _MineRenderError.prototype);
-      }
-      get name() {
-        return "MineRenderError";
-      }
-    };
-  }
-});
-
 // src/texture/Colormaps.ts
 var Colormaps;
 var init_Colormaps = __esm({
@@ -4527,6 +4809,7 @@ var init_BlockEntities = __esm({
   "src/assets/BlockEntities.ts"() {
     import_three9 = require("three");
     init_AssetKey();
+    init_Entities();
     init_AssetLoader();
     init_source();
     init_Caching();
@@ -4543,6 +4826,7 @@ var init_BlockEntities = __esm({
         key.rootType = void 0;
         const index = await Caching.blockEntityIndexCache.get(key.serialize(), async () => {
           try {
+            key.root = await Entities.getDatasetRoot(root);
             return await AssetLoader.get(key, "json" /* JSON */) ?? {};
           } catch (error) {
             log9.warn("Could not load the block entity index; block entities are drawn as plain block models", error);
@@ -4628,136 +4912,6 @@ var init_DecoratedPots = __esm({
   }
 });
 
-// src/assets/Entities.ts
-var Entities;
-var init_Entities = __esm({
-  "src/assets/Entities.ts"() {
-    init_AssetKey();
-    init_AssetLoader();
-    init_source();
-    init_Caching();
-    init_AssetDefaults();
-    init_MineRenderError();
-    init_ModelTextures();
-    Entities = class {
-      /** Lists model paths in the `minecraft` namespace, including subdirectories and excluding `.json`. */
-      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 list2 = await Caching.listAssetCache.get(key.serialize(), () => AssetLoader.get(key, "list" /* LIST */));
-          if (!list2) return [];
-          const files = list2.files.filter((file) => file.endsWith(".json") && file !== "_list.json").map((file) => `${prefix2}${file.slice(0, -5)}`);
-          const children = await Promise.all(list2.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 */));
-      }
-      /** Returns selectable geometry-layer names, or an empty list when the model is missing. */
-      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 ?? [];
-      }
-      /**
-       * Loads the layers and textures to pass to {@link MineRenderScene.addEntity}.
-       * By default, selects `main`, unconditional passes, and passes enabled by `options.when`.
-       *
-       * @param modelKey - Dataset model, such as `new BasicAssetKey("minecraft", "zombie")`.
-       * @param textureKey - Texture override for the first selected layer.
-       * @param options - Layer selection, conditional passes, and per-layer texture overrides.
-       * @returns The selected model, or `undefined` when its dataset file is missing.
-       */
-      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 } };
-      }
-      /**
-       * Native and sampled vanilla clips by name, or undefined when the model or 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", isAssetKey(modelKey) ? modelKey.root : void 0);
-        const file = await Caching.entityAnimationCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
-        return file?.animations;
-      }
-      /** Finds a fallback texture using the model path, its directory, and vanilla variant data. */
-      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 list2 = await AssetLoader.get(listKey, "list" /* LIST */);
-          const files = list2?.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/assets/_fonts/Unihex.ts
 var Unihex_exports = {};
 __export(Unihex_exports, {
@@ -5898,6 +6052,266 @@ var init_model = __esm({
   }
 });
 
+// src/model/ItemGlint.ts
+var ItemGlint_exports = {};
+__export(ItemGlint_exports, {
+  ItemGlint: () => ItemGlint
+});
+var import_three14, ItemGlint;
+var init_ItemGlint = __esm({
+  "src/model/ItemGlint.ts"() {
+    import_three14 = require("three");
+    init_AssetKey();
+    init_Models();
+    init_ModelTextures();
+    init_Caching();
+    init_Textures();
+    init_Ticker();
+    init_CubeFace();
+    init_DisplayPosition();
+    ItemGlint = class _ItemGlint {
+      constructor(owner, material) {
+        this.owner = owner;
+        this.material = material;
+        this.updateTime();
+      }
+      /** Enables glint for enchantments or a lodestone compass unless a boolean component overrides them. */
+      static enabled(components = {}, itemId) {
+        const override = Models.componentValue(components, "enchantment_glint_override");
+        if (override !== void 0) {
+          if (typeof override !== "boolean") throw new Error("Item enchantment_glint_override must be a boolean");
+          return override;
+        }
+        if (itemId === "minecraft:compass") {
+          Models.componentValue(components, "lodestone_tracker");
+          if (Object.prototype.hasOwnProperty.call(components, "lodestone_tracker") || Object.prototype.hasOwnProperty.call(components, "minecraft:lodestone_tracker")) return true;
+        }
+        const enchantments = Models.componentValue(components, "enchantments");
+        if (enchantments === void 0) return false;
+        if (!enchantments || typeof enchantments !== "object" || Array.isArray(enchantments)) throw new Error("Item enchantments must be an object");
+        return Object.keys(enchantments).length > 0;
+      }
+      /** @internal */
+      static async create(owner, baseMap, root, entityMeshes, kind = "item") {
+        const key = new AssetKey("minecraft", `enchanted_glint_${kind}`, "textures", "misc", "assets", ".png", root);
+        const assetKey = key.serialize(), textureKey = `item-glint:${assetKey}`;
+        let texture = Caching.textureCache.getIfPresent(textureKey);
+        if (!texture) {
+          const pending = ModelTextures.get(key);
+          const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKey);
+          const [image, metadata] = await Promise.all([pending, ModelTextures.getMeta(key)]);
+          if (!image) throw new Error(`Missing ${kind} glint texture ${key.toNamespacedString()}`);
+          if (cachedAsset && Caching.textureAssetCache.getIfPresent(assetKey) !== cachedAsset) return this.create(owner, baseMap, root, entityMeshes, kind);
+          texture = Caching.textureCache.get(textureKey, () => {
+            const texture2 = Textures.createCanvasTexture(image.data.canvas);
+            texture2.wrapS = texture2.wrapT = metadata?.texture?.clamp ? import_three14.ClampToEdgeWrapping : import_three14.RepeatWrapping;
+            if (metadata?.texture?.blur) texture2.magFilter = texture2.minFilter = import_three14.LinearFilter;
+            return texture2;
+          });
+        }
+        const material = new import_three14.ShaderMaterial({
+          name: "item-glint",
+          transparent: true,
+          depthWrite: false,
+          depthFunc: import_three14.EqualDepth,
+          side: import_three14.DoubleSide,
+          forceSinglePass: true,
+          blending: import_three14.CustomBlending,
+          blendSrc: import_three14.SrcColorFactor,
+          blendDst: import_three14.OneFactor,
+          blendSrcAlpha: import_three14.ZeroFactor,
+          blendDstAlpha: import_three14.OneFactor,
+          toneMapped: false,
+          // TextureTransform.ARMOR_ENTITY_GLINT_TEXTURING uses a smaller UV scale than item glint.
+          defines: entityMeshes ? { ENTITY_GLINT: true, ENTITY_GLINT_SCALE: kind === "armor" ? "0.16" : "0.5" } : {},
+          uniforms: {
+            ...!entityMeshes && { baseMap: { value: baseMap } },
+            glintMap: { value: texture },
+            glintOffset: { value: new import_three14.Vector2() },
+            glintAlpha: { value: 0.75 }
+          },
+          vertexShader: `
+                uniform vec2 glintOffset;
+                #ifndef ENTITY_GLINT
+                attribute vec4 uvBounds;
+                attribute vec2 glintUv;
+                flat out vec4 vUvBounds;
+                centroid out vec2 vUv;
+                #endif
+                varying vec2 vGlintUv;
+                void main() {
+                    #ifdef ENTITY_GLINT
+                    vec2 p = vec2(uv.x, 1.0 - uv.y) * ENTITY_GLINT_SCALE;
+                    #else
+                    vUv = uv;
+                    vUvBounds = uvBounds;
+                    vec2 p = glintUv * 8.0;
+                    #endif
+                    float angle = radians(10.0);
+                    vGlintUv = vec2(cos(angle) * p.x - sin(angle) * p.y, sin(angle) * p.x + cos(angle) * p.y) + glintOffset;
+                    vec4 mvPosition = vec4(position, 1.0);
+                    mvPosition = modelViewMatrix * mvPosition;
+                    gl_Position = projectionMatrix * mvPosition;
+                }
+            `,
+          fragmentShader: `
+                #ifndef ENTITY_GLINT
+                uniform sampler2D baseMap;
+                flat in vec4 vUvBounds;
+                centroid in vec2 vUv;
+                #endif
+                uniform sampler2D glintMap;
+                uniform float glintAlpha;
+                varying vec2 vGlintUv;
+                void main() {
+                    #ifndef ENTITY_GLINT
+                    vec2 mapUv = clamp(vUv, vUvBounds.xy, vUvBounds.zw);
+                    if (texture2D(baseMap, mapUv).a < 0.01) discard;
+                    #endif
+                    vec4 color = texture2D(glintMap, vec2(vGlintUv.x, 1.0 - vGlintUv.y));
+                    if (color.a < 0.1) discard;
+                    gl_FragColor = color;
+                    #include <colorspace_fragment>
+                    gl_FragColor.rgb *= glintAlpha;
+                }
+            `
+        });
+        if (!entityMeshes) Object.assign(material.defaultAttributeValues, { uvBounds: [0, 0, 1, 1] });
+        const targets = entityMeshes ? [...entityMeshes] : [];
+        if (!entityMeshes) owner.iterateAllMeshes((mesh) => targets.push({ mesh }));
+        for (const { mesh: base, parent = base } of targets) {
+          const pass = new import_three14.Mesh(base.geometry, material);
+          pass.name = `${base.name}:glint`;
+          pass.userData.minerenderItemGlint = true;
+          pass.raycast = () => {
+          };
+          pass.renderOrder = parent.renderOrder + 0.5;
+          parent.add(pass);
+        }
+        return new _ItemGlint(owner, material);
+      }
+      /**
+       * Maps glint before model centering and display transforms. Ordinary sprites approximate Minecraft's shared atlas density.
+       * @internal
+       */
+      static mapUvs(geometry, faces, atlas, itemId, display) {
+        const uv = geometry.getAttribute("uv");
+        const mapped = new Float32Array(uv.count * 2);
+        if (itemId === "minecraft:compass" || itemId === "minecraft:recovery_compass" || itemId === "minecraft:clock") {
+          const positions = geometry.getAttribute("position"), normals = geometry.getAttribute("normal");
+          const scale = display === "gui" /* GUI */ ? 0.5 : display === "firstperson_lefthand" /* FIRSTPERSON_LEFTHAND */ || display === "firstperson_righthand" /* FIRSTPERSON_RIGHTHAND */ ? 0.75 : 1;
+          const factor = 1 / (16 * 128 * scale);
+          for (let index = 0; index < positions.count; index++) {
+            const x = positions.getX(index), y = positions.getY(index), z = positions.getZ(index);
+            const nx = normals.getX(index), ny = normals.getY(index), nz = normals.getZ(index);
+            const ax = Math.abs(nx), ay = Math.abs(ny), az = Math.abs(nz);
+            let u, v;
+            if (ay >= az && ay >= ax) {
+              u = x;
+              v = ny < 0 ? -z : z;
+            } else if (az >= ax) {
+              u = nz < 0 ? -x : x;
+              v = -y;
+            } else {
+              u = nx < 0 ? -z : z;
+              v = -y;
+            }
+            mapped[index * 2] = u * factor;
+            mapped[index * 2 + 1] = v * factor;
+          }
+          geometry.setAttribute("glintUv", new import_three14.Float32BufferAttribute(mapped, 2));
+          return;
+        }
+        for (const [faceIndex, face] of CUBE_FACES.entries()) {
+          const texture = faces[face]?.texture?.substring(1);
+          const position = texture && atlas.positions[texture] || [0, 0];
+          const size = texture && atlas.sizes[texture] || [atlas.image.width, atlas.image.height];
+          for (let corner = 0; corner < 4; corner++) {
+            const index = faceIndex * 4 + corner;
+            mapped[index * 2] = (uv.getX(index) * atlas.image.width - position[0]) / size[0] / 32;
+            mapped[index * 2 + 1] = ((1 - uv.getY(index)) * atlas.image.height - position[1]) / size[1] / 32;
+          }
+        }
+        geometry.setAttribute("glintUv", new import_three14.Float32BufferAttribute(mapped, 2));
+      }
+      updateTime() {
+        const time = Math.trunc(Date.now() * 4);
+        this.material.uniforms.glintOffset.value.set(-(time % 11e4) / 11e4, time % 3e4 / 3e4);
+      }
+      /** @internal */
+      updateSubscription(active) {
+        if (active && this.ticker === void 0) {
+          this.updateTime();
+          this.ticker = Ticker.add(() => {
+            this.updateTime();
+            this.owner.notifyDirty();
+          });
+        } else if (!active) {
+          Ticker.remove(this.ticker);
+          this.ticker = void 0;
+        }
+      }
+      dispose() {
+        Ticker.remove(this.ticker);
+        this.ticker = void 0;
+        this.material.dispose();
+      }
+    };
+  }
+});
+
+// src/texture/PalettedTextures.ts
+var PalettedTextures_exports = {};
+__export(PalettedTextures_exports, {
+  PalettedTextures: () => PalettedTextures
+});
+var PalettedTextures;
+var init_PalettedTextures = __esm({
+  "src/texture/PalettedTextures.ts"() {
+    init_ModelTextures();
+    init_Caching();
+    init_CanvasImage();
+    init_MineRenderError();
+    PalettedTextures = class {
+      /** Loads a texture with a palette permutation, sharing the resulting canvas between callers. */
+      static async get(texture, key, permutation2) {
+        return Caching.canvasImageDataCache.get(`palette:${texture.serialize()}:${key.serialize()}:${permutation2.serialize()}`, async () => {
+          const source = await ModelTextures.get(texture);
+          if (!source) return void 0;
+          const [palette, replacement] = await Promise.all([ModelTextures.get(key), ModelTextures.get(permutation2)]);
+          if (!palette) throw new MineRenderError(`Missing palette ${key.toNamespacedString()}`);
+          if (!replacement) throw new MineRenderError(`Missing palette ${permutation2.toNamespacedString()}`);
+          const pixels = source.data.getImageData(0, 0, source.width, source.height);
+          const colors2 = palette.data.getImageData(0, 0, palette.width, palette.height).data;
+          const replacements = replacement.data.getImageData(0, 0, replacement.width, replacement.height).data;
+          const image = new CanvasImage(source.width, source.height);
+          const output = image.context.createImageData(source.width, source.height);
+          output.data.set(this.permute(pixels.data, colors2, replacements));
+          image.putData(output);
+          return { data: image.context, width: image.width, height: image.height };
+        });
+      }
+      /** @internal */
+      static permute(pixels, key, permutation2) {
+        if (key.length !== permutation2.length) throw new MineRenderError("Palette images must have the same pixel count");
+        const mapping = /* @__PURE__ */ new Map();
+        for (let i = 0; i < key.length; i += 4) {
+          if (key[i + 3] !== 0) mapping.set(key[i] << 16 | key[i + 1] << 8 | key[i + 2], i);
+        }
+        const output = new Uint8ClampedArray(pixels);
+        for (let i = 0; i < pixels.length; i += 4) {
+          if (pixels[i + 3] === 0) continue;
+          const mapped = mapping.get(pixels[i] << 16 | pixels[i + 1] << 8 | pixels[i + 2]);
+          if (mapped === void 0) continue;
+          output.set(permutation2.subarray(mapped, mapped + 3), i);
+          output[i + 3] = Math.floor(pixels[i + 3] * permutation2[mapped + 3] / 255);
+        }
+        return output;
+      }
+    };
+  }
+});
+
 // src/entity/scene/EntityObject.ts
 var EntityObject_exports = {};
 __export(EntityObject_exports, {
@@ -5907,13 +6321,13 @@ __export(EntityObject_exports, {
 function isEntityObject(obj) {
   return obj.isEntityObject;
 }
-var import_three14, EntityObject;
+var import_three15, ItemGlintClass, PalettedTexturesClass, EntityObject;
 var init_EntityObject = __esm({
   "src/entity/scene/EntityObject.ts"() {
     init_SceneObject();
     init_Caching();
     init_merge();
-    import_three14 = require("three");
+    import_three15 = require("three");
     init_Ticker();
     init_model();
     init_ModelTextures();
@@ -5938,8 +6352,14 @@ var init_EntityObject = __esm({
         this.animationPlayers = [];
         this.partPoses = /* @__PURE__ */ new Map();
         this.options = (0, import_ts_deepmerge.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
-        this.addEventListener("added", () => this.updateScrollSubscription());
-        this.addEventListener("removed", () => this.updateScrollSubscription());
+        this.addEventListener("added", () => {
+          this.updateScrollSubscription();
+          this.glint?.updateSubscription(!!this.parent);
+        });
+        this.addEventListener("removed", () => {
+          this.updateScrollSubscription();
+          this.glint?.updateSubscription(!!this.parent);
+        });
       }
       static {
         this.DEFAULT_OPTIONS = (0, import_ts_deepmerge.default)({}, SceneObject.DEFAULT_OPTIONS);
@@ -5953,12 +6373,26 @@ var init_EntityObject = __esm({
             mesh.material = material;
           });
           this.notifyDirty();
-        } else await this.applyTextures();
+        } else {
+          await this.applyTextures();
+          const layers = Object.entries(this.entityLayers).filter(([, layer]) => layer.glint);
+          const meshes = [];
+          for (const [name] of layers) this.getLayerGroup(name)?.traverse((object4) => {
+            if (isMesh(object4)) meshes.push(object4);
+          });
+          if (meshes.length) {
+            const ItemGlint2 = ItemGlintClass ??= (await Promise.resolve().then(() => (init_ItemGlint(), ItemGlint_exports))).ItemGlint;
+            this.glint = await ItemGlint2.create(this, void 0, this.getTextureKey(layers[0][1]).root, meshes.map((mesh) => ({ mesh })), "armor");
+            this.glint.updateSubscription(!!this.parent);
+          }
+        }
       }
       dispose() {
         super.dispose();
       }
       disposeAndRemoveAllChildren() {
+        this.glint?.dispose();
+        this.glint = void 0;
         this.clearScrollMaterials();
         for (const geometry of this.geometries) geometry.dispose();
         this.geometries.clear();
@@ -6117,17 +6551,21 @@ var init_EntityObject = __esm({
         );
       }
       async loadTextures(layer = this.entity) {
+        if (layer.palette) {
+          const PalettedTextures2 = PalettedTexturesClass ??= (await Promise.resolve().then(() => (init_PalettedTextures(), PalettedTextures_exports))).PalettedTextures;
+          return PalettedTextures2.get(this.getTextureKey(layer), layer.palette.key, layer.palette.permutation);
+        }
         return ModelTextures.get(this.getTextureKey(layer));
       }
       createMeshes(force = false) {
         if (this.meshesCreated && !force) return;
-        const modelRoot = new import_three14.Object3D();
+        const modelRoot = new import_three15.Object3D();
         let transformNode = modelRoot;
         const transform = this.options.flip === void 0 ? this.entity.transform : void 0;
         if (transform) {
           for (const [index, op] of transform.entries()) {
             if (index > 0) {
-              const child = new import_three14.Object3D();
+              const child = new import_three15.Object3D();
               transformNode.add(child);
               transformNode = child;
             }
@@ -6189,10 +6627,10 @@ var init_EntityObject = __esm({
         this.clearScrollMaterials();
         const results = await Promise.allSettled(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 tint = (layer.tint === void 0 ? void 0 : this.options.tints?.[layer.tint]) ?? layer.color;
           const scroll = Materials.entityModeScroll(mode);
           const assetKeyStr = this.getTextureKey(layer).serialize();
-          const keyStr = `entity:${mode}:${tint === void 0 ? "" : new import_three14.Color(tint).getHexString()}:${assetKeyStr}`;
+          const keyStr = `entity:${mode}:${tint === void 0 ? "" : new import_three15.Color(tint).getHexString()}:${assetKeyStr}` + (layer.palette ? `:${layer.palette.key.serialize()}:${layer.palette.permutation.serialize()}` : "");
           let mat = scroll ? void 0 : Caching.materialCache.getIfPresent(keyStr);
           if (!mat) {
             const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
@@ -6255,7 +6693,7 @@ function getMinMax(attribute, start, count) {
         else if (a === 2) value = attribute.getZ(i);
         else if (a === 3) value = attribute.getW(i);
         if (attribute.normalized === true) {
-          value = import_three18.MathUtils.normalize(value, attribute.array);
+          value = import_three19.MathUtils.normalize(value, attribute.array);
         }
       }
       output.min[a] = Math.min(output.min[a], value);
@@ -6303,10 +6741,10 @@ function getToBlobPromise(canvas, mimeType) {
     return new Promise((resolve) => canvas.toBlob(resolve, mimeType));
   }
 }
-var import_three18, KHR_mesh_quantization_ExtraAttrTypes, GLTFExporter, WEBGL_CONSTANTS, KHR_MESH_QUANTIZATION, THREE_TO_WEBGL, PATH_PROPERTIES, DEFAULT_SPECULAR_COLOR, GLB_HEADER_BYTES, GLB_HEADER_MAGIC, GLB_VERSION, GLB_CHUNK_PREFIX_BYTES, GLB_CHUNK_TYPE_JSON, GLB_CHUNK_TYPE_BIN, GLTFWriter, GLTFLightExtension, GLTFMaterialsUnlitExtension, GLTFMaterialsClearcoatExtension, GLTFMaterialsDispersionExtension, GLTFMaterialsIridescenceExtension, GLTFMaterialsTransmissionExtension, GLTFMaterialsVolumeExtension, GLTFMaterialsIorExtension, GLTFMaterialsSpecularExtension, GLTFMaterialsSheenExtension, GLTFMaterialsAnisotropyExtension, GLTFMaterialsEmissiveStrengthExtension, GLTFMaterialsBumpExtension, GLTFMeshGpuInstancing;
+var import_three19, KHR_mesh_quantization_ExtraAttrTypes, GLTFExporter, WEBGL_CONSTANTS, KHR_MESH_QUANTIZATION, THREE_TO_WEBGL, PATH_PROPERTIES, DEFAULT_SPECULAR_COLOR, GLB_HEADER_BYTES, GLB_HEADER_MAGIC, GLB_VERSION, GLB_CHUNK_PREFIX_BYTES, GLB_CHUNK_TYPE_JSON, GLB_CHUNK_TYPE_BIN, GLTFWriter, GLTFLightExtension, GLTFMaterialsUnlitExtension, GLTFMaterialsClearcoatExtension, GLTFMaterialsDispersionExtension, GLTFMaterialsIridescenceExtension, GLTFMaterialsTransmissionExtension, GLTFMaterialsVolumeExtension, GLTFMaterialsIorExtension, GLTFMaterialsSpecularExtension, GLTFMaterialsSheenExtension, GLTFMaterialsAnisotropyExtension, GLTFMaterialsEmissiveStrengthExtension, GLTFMaterialsBumpExtension, GLTFMeshGpuInstancing;
 var init_GLTFExporter = __esm({
   "../../node_modules/three/examples/jsm/exporters/GLTFExporter.js"() {
-    import_three18 = require("three");
+    import_three19 = require("three");
     KHR_mesh_quantization_ExtraAttrTypes = {
       POSITION: [
         "byte",
@@ -6485,22 +6923,22 @@ var init_GLTFExporter = __esm({
     };
     KHR_MESH_QUANTIZATION = "KHR_mesh_quantization";
     THREE_TO_WEBGL = {};
-    THREE_TO_WEBGL[import_three18.NearestFilter] = WEBGL_CONSTANTS.NEAREST;
-    THREE_TO_WEBGL[import_three18.NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
-    THREE_TO_WEBGL[import_three18.NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
-    THREE_TO_WEBGL[import_three18.LinearFilter] = WEBGL_CONSTANTS.LINEAR;
-    THREE_TO_WEBGL[import_three18.LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
-    THREE_TO_WEBGL[import_three18.LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
-    THREE_TO_WEBGL[import_three18.ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
-    THREE_TO_WEBGL[import_three18.RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
-    THREE_TO_WEBGL[import_three18.MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
+    THREE_TO_WEBGL[import_three19.NearestFilter] = WEBGL_CONSTANTS.NEAREST;
+    THREE_TO_WEBGL[import_three19.NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
+    THREE_TO_WEBGL[import_three19.NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
+    THREE_TO_WEBGL[import_three19.LinearFilter] = WEBGL_CONSTANTS.LINEAR;
+    THREE_TO_WEBGL[import_three19.LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
+    THREE_TO_WEBGL[import_three19.LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
+    THREE_TO_WEBGL[import_three19.ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
+    THREE_TO_WEBGL[import_three19.RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
+    THREE_TO_WEBGL[import_three19.MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
     PATH_PROPERTIES = {
       scale: "scale",
       position: "translation",
       quaternion: "rotation",
       morphTargetInfluences: "weights"
     };
-    DEFAULT_SPECULAR_COLOR = new import_three18.Color();
+    DEFAULT_SPECULAR_COLOR = new import_three19.Color();
     GLB_HEADER_BYTES = 12;
     GLB_HEADER_MAGIC = 1179937895;
     GLB_VERSION = 2;
@@ -6524,7 +6962,7 @@ var init_GLTFExporter = __esm({
         this.json = {
           asset: {
             version: "2.0",
-            generator: "THREE.GLTFExporter r" + import_three18.REVISION
+            generator: "THREE.GLTFExporter r" + import_three19.REVISION
           }
         };
         this.cache = {
@@ -6676,7 +7114,7 @@ var init_GLTFExporter = __esm({
       isNormalizedNormalAttribute(normal) {
         const cache = this.cache;
         if (cache.attributesNormalized.has(normal)) return false;
-        const v = new import_three18.Vector3();
+        const v = new import_three19.Vector3();
         for (let i = 0, il = normal.count; i < il; i++) {
           if (Math.abs(v.fromBufferAttribute(normal, i).length() - 1) > 5e-4) return false;
         }
@@ -6693,7 +7131,7 @@ var init_GLTFExporter = __esm({
         const cache = this.cache;
         if (cache.attributesNormalized.has(normal)) return cache.attributesNormalized.get(normal);
         const attribute = normal.clone();
-        const v = new import_three18.Vector3();
+        const v = new import_three19.Vector3();
         for (let i = 0, il = attribute.count; i < il; i++) {
           v.fromBufferAttribute(attribute, i);
           if (v.x === 0 && v.y === 0 && v.z === 0) {
@@ -6737,7 +7175,7 @@ var init_GLTFExporter = __esm({
       async buildMetalRoughTextureAsync(metalnessMap, roughnessMap) {
         if (metalnessMap === roughnessMap) return metalnessMap;
         function getEncodingConversion(map) {
-          if (map.colorSpace === import_three18.SRGBColorSpace) {
+          if (map.colorSpace === import_three19.SRGBColorSpace) {
             return function SRGBToLinear(c) {
               return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
             };
@@ -6746,10 +7184,10 @@ var init_GLTFExporter = __esm({
             return c;
           };
         }
-        if (metalnessMap instanceof import_three18.CompressedTexture) {
+        if (metalnessMap instanceof import_three19.CompressedTexture) {
           metalnessMap = await this.decompressTextureAsync(metalnessMap);
         }
-        if (roughnessMap instanceof import_three18.CompressedTexture) {
+        if (roughnessMap instanceof import_three19.CompressedTexture) {
           roughnessMap = await this.decompressTextureAsync(roughnessMap);
         }
         const metalness = metalnessMap ? metalnessMap.image : null;
@@ -6784,8 +7222,8 @@ var init_GLTFExporter = __esm({
         context.putImageData(composite, 0, 0);
         const reference = metalnessMap || roughnessMap;
         const texture = reference.clone();
-        texture.source = new import_three18.TextureSource(canvas);
-        texture.colorSpace = import_three18.NoColorSpace;
+        texture.source = new import_three19.TextureSource(canvas);
+        texture.colorSpace = import_three19.NoColorSpace;
         texture.channel = (metalnessMap || roughnessMap).channel;
         if (metalnessMap && roughnessMap && metalnessMap.channel !== roughnessMap.channel) {
           console.warn("THREE.GLTFExporter: UV channels for metalnessMap and roughnessMap textures must match.");
@@ -6806,7 +7244,7 @@ var init_GLTFExporter = __esm({
        * @return {Promise<THREE.Texture>} The derived normal map texture.
        */
       async buildNormalMapTextureAsync(normalMap, flipX, flipY) {
-        if (normalMap instanceof import_three18.CompressedTexture) {
+        if (normalMap instanceof import_three19.CompressedTexture) {
           normalMap = await this.decompressTextureAsync(normalMap);
         }
         const image = normalMap.image;
@@ -6825,7 +7263,7 @@ var init_GLTFExporter = __esm({
         }
         context.putImageData(imageData, 0, 0);
         const texture = normalMap.clone();
-        texture.source = new import_three18.TextureSource(canvas);
+        texture.source = new import_three19.TextureSource(canvas);
         return texture;
       }
       async decompressTextureAsync(texture, maxTextureSize = Infinity) {
@@ -6889,7 +7327,7 @@ var init_GLTFExporter = __esm({
               else if (a === 2) value = attribute.getZ(i);
               else if (a === 3) value = attribute.getW(i);
               if (attribute.normalized === true) {
-                value = import_three18.MathUtils.normalize(value, attribute.array);
+                value = import_three19.MathUtils.normalize(value, attribute.array);
               }
             }
             if (componentType === WEBGL_CONSTANTS.FLOAT) {
@@ -7044,7 +7482,7 @@ var init_GLTFExporter = __esm({
             ctx.scale(1, -1);
           }
           if (image.data !== void 0) {
-            if (format2 !== import_three18.RGBAFormat) {
+            if (format2 !== import_three19.RGBAFormat) {
               console.error("GLTFExporter: Only RGBAFormat is supported.", format2);
             }
             if (image.width > options.maxTextureSize || image.height > options.maxTextureSize) {
@@ -7072,7 +7510,7 @@ var init_GLTFExporter = __esm({
               })
             );
           } else {
-            imageDef.uri = import_three18.ImageUtils.getDataURL(canvas, mimeType);
+            imageDef.uri = import_three19.ImageUtils.getDataURL(canvas, mimeType);
           }
           const index = json.images.push(imageDef) - 1;
           cachedImages[key] = index;
@@ -7109,7 +7547,7 @@ var init_GLTFExporter = __esm({
         const json = this.json;
         if (cache.textures.has(map)) return cache.textures.get(map);
         if (!json.textures) json.textures = [];
-        if (map instanceof import_three18.CompressedTexture) {
+        if (map instanceof import_three19.CompressedTexture) {
           map = await this.decompressTextureAsync(map, options.maxTextureSize);
         }
         const mimeType = map.userData.mimeType;
@@ -7242,7 +7680,7 @@ var init_GLTFExporter = __esm({
             materialDef.alphaCutoff = material.alphaTest;
           }
         }
-        if (material.side === import_three18.DoubleSide) materialDef.doubleSided = true;
+        if (material.side === import_three19.DoubleSide) materialDef.doubleSided = true;
         if (material.name !== "") materialDef.name = material.name;
         this.serializeUserData(material, materialDef);
         await this._invokeAllAsync(async function(ext) {
@@ -7491,7 +7929,7 @@ var init_GLTFExporter = __esm({
         } else {
           cameraDef.perspective = {
             aspectRatio: camera.aspect,
-            yfov: import_three18.MathUtils.degToRad(camera.fov),
+            yfov: import_three19.MathUtils.degToRad(camera.fov),
             zfar: camera.far <= 0 ? 1e-3 : camera.far,
             znear: camera.near < 0 ? 0 : camera.near
           };
@@ -7519,8 +7957,8 @@ var init_GLTFExporter = __esm({
         const samplers = [];
         for (let i = 0; i < tracks.length; ++i) {
           const track = tracks[i];
-          const trackBinding = import_three18.PropertyBinding.parseTrackName(track.name);
-          let trackNode = import_three18.PropertyBinding.findNode(root, trackBinding.nodeName);
+          const trackBinding = import_three19.PropertyBinding.parseTrackName(track.name);
+          let trackNode = import_three19.PropertyBinding.findNode(root, trackBinding.nodeName);
           const trackProperty = PATH_PROPERTIES[trackBinding.propertyName];
           if (trackBinding.objectName === "bones") {
             if (trackNode.isSkinnedMesh === true) {
@@ -7542,14 +7980,14 @@ var init_GLTFExporter = __esm({
           if (track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true) {
             interpolation = "CUBICSPLINE";
             outputItemSize /= 3;
-          } else if (track.getInterpolation() === import_three18.InterpolateDiscrete) {
+          } else if (track.getInterpolation() === import_three19.InterpolateDiscrete) {
             interpolation = "STEP";
           } else {
             interpolation = "LINEAR";
           }
           samplers.push({
-            input: this.processAccessor(new import_three18.BufferAttribute(track.times, inputItemSize)),
-            output: this.processAccessor(new import_three18.BufferAttribute(track.values, outputItemSize)),
+            input: this.processAccessor(new import_three19.BufferAttribute(track.times, inputItemSize)),
+            output: this.processAccessor(new import_three19.BufferAttribute(track.values, outputItemSize)),
             interpolation
           });
           channels.push({
@@ -7583,7 +8021,7 @@ var init_GLTFExporter = __esm({
         if (rootJoint === void 0) return null;
         const joints = [];
         const inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
-        const temporaryBoneInverse = new import_three18.Matrix4();
+        const temporaryBoneInverse = new import_three19.Matrix4();
         for (let i = 0; i < skeleton.bones.length; ++i) {
           joints.push(nodeMap.get(skeleton.bones[i]));
           temporaryBoneInverse.copy(skeleton.boneInverses[i]);
@@ -7591,7 +8029,7 @@ var init_GLTFExporter = __esm({
         }
         if (json.skins === void 0) json.skins = [];
         json.skins.push({
-          inverseBindMatrices: this.processAccessor(new import_three18.BufferAttribute(inverseBindMatrices, 16)),
+          inverseBindMatrices: this.processAccessor(new import_three19.BufferAttribute(inverseBindMatrices, 16)),
           joints,
           skeleton: nodeMap.get(rootJoint)
         });
@@ -7753,7 +8191,7 @@ var init_GLTFExporter = __esm({
        * @param {Array<THREE.Object3D>} objects List of objects to process
        */
       async processObjectsAsync(objects) {
-        const scene = new import_three18.Scene();
+        const scene = new import_three19.Scene();
         scene.name = "AuxScene";
         for (let i = 0; i < objects.length; i++) {
           scene.children.push(objects[i]);
@@ -7771,7 +8209,7 @@ var init_GLTFExporter = __esm({
         });
         const objectsWithoutScene = [];
         for (let i = 0; i < input.length; i++) {
-          if (input[i] instanceof import_three18.Scene) {
+          if (input[i] instanceof import_three19.Scene) {
             await this.processSceneAsync(input[i]);
           } else {
             objectsWithoutScene.push(input[i]);
@@ -8169,10 +8607,10 @@ var init_GLTFExporter = __esm({
         const translationAttr = new Float32Array(mesh.count * 3);
         const rotationAttr = new Float32Array(mesh.count * 4);
         const scaleAttr = new Float32Array(mesh.count * 3);
-        const matrix = new import_three18.Matrix4();
-        const position = new import_three18.Vector3();
-        const quaternion = new import_three18.Quaternion();
-        const scale = new import_three18.Vector3();
+        const matrix = new import_three19.Matrix4();
+        const position = new import_three19.Vector3();
+        const quaternion = new import_three19.Quaternion();
+        const scale = new import_three19.Vector3();
         for (let i = 0; i < mesh.count; i++) {
           mesh.getMatrixAt(i, matrix);
           matrix.decompose(position, quaternion, scale);
@@ -8181,9 +8619,9 @@ var init_GLTFExporter = __esm({
           scale.toArray(scaleAttr, i * 3);
         }
         const attributes = {
-          TRANSLATION: writer.processAccessor(new import_three18.BufferAttribute(translationAttr, 3)),
-          ROTATION: writer.processAccessor(new import_three18.BufferAttribute(rotationAttr, 4)),
-          SCALE: writer.processAccessor(new import_three18.BufferAttribute(scaleAttr, 3))
+          TRANSLATION: writer.processAccessor(new import_three19.BufferAttribute(translationAttr, 3)),
+          ROTATION: writer.processAccessor(new import_three19.BufferAttribute(rotationAttr, 4)),
+          SCALE: writer.processAccessor(new import_three19.BufferAttribute(scaleAttr, 3))
         };
         if (mesh.instanceColor)
           attributes._COLOR_0 = writer.processAccessor(mesh.instanceColor);
@@ -8248,8 +8686,8 @@ var init_GLTFExporter = __esm({
         const sourceTracks = clip.tracks;
         for (let i = 0; i < sourceTracks.length; ++i) {
           let sourceTrack = sourceTracks[i];
-          const sourceTrackBinding = import_three18.PropertyBinding.parseTrackName(sourceTrack.name);
-          const sourceTrackNode = import_three18.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
+          const sourceTrackBinding = import_three19.PropertyBinding.parseTrackName(sourceTrack.name);
+          const sourceTrackNode = import_three19.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
           if (sourceTrackBinding.propertyName !== "morphTargetInfluences" || sourceTrackBinding.propertyIndex === void 0) {
             tracks.push(sourceTrack);
             continue;
@@ -8260,7 +8698,7 @@ var init_GLTFExporter = __esm({
             }
             console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.");
             sourceTrack = sourceTrack.clone();
-            sourceTrack.setInterpolation(import_three18.InterpolateLinear);
+            sourceTrack.setInterpolation(import_three19.InterpolateLinear);
           }
           const targetCount = sourceTrackNode.morphTargetInfluences.length;
           const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex];
@@ -8294,7 +8732,7 @@ var init_GLTFExporter = __esm({
         return clip;
       },
       toTypedBufferAttribute: function(srcAttribute, TypedArray) {
-        const dstAttribute = new import_three18.BufferAttribute(new TypedArray(srcAttribute.count * srcAttribute.itemSize), srcAttribute.itemSize, false);
+        const dstAttribute = new import_three19.BufferAttribute(new TypedArray(srcAttribute.count * srcAttribute.itemSize), srcAttribute.itemSize, false);
         if (!srcAttribute.normalized && !srcAttribute.isInterleavedBufferAttribute) {
           dstAttribute.array.set(srcAttribute.array);
           return dstAttribute;
@@ -8372,7 +8810,7 @@ function createGuiTextGeometry(layout, shadow = true) {
         batch = { image: glyph?.image, positions: [], uvs: [], colors: [], indices: [] };
         batches.push(batch);
       }
-      const color2 = new import_three20.Color(isShadow ? (style.color & 16579836) >> 2 : style.color);
+      const color2 = new import_three21.Color(isShadow ? (style.color & 16579836) >> 2 : style.color);
       const offset = isShadow ? glyph?.shadowOffset ?? 1 : 0;
       const top = glyph ? 7 - glyph.ascent : 0;
       const height = glyph ? glyph.height * glyph.scale : 8;
@@ -8414,12 +8852,12 @@ function createGuiTextGeometry(layout, shadow = true) {
       }
     }
   }
-  return batches.map(({ image, positions, uvs, colors: colors2, indices }) => ({ image, geometry: new import_three20.BufferGeometry().setAttribute("position", new import_three20.Float32BufferAttribute(positions, 3)).setAttribute("uv", new import_three20.Float32BufferAttribute(uvs, 2)).setAttribute("color", new import_three20.Float32BufferAttribute(colors2, 3)).setIndex(indices) }));
+  return batches.map(({ image, positions, uvs, colors: colors2, indices }) => ({ image, geometry: new import_three21.BufferGeometry().setAttribute("position", new import_three21.Float32BufferAttribute(positions, 3)).setAttribute("uv", new import_three21.Float32BufferAttribute(uvs, 2)).setAttribute("color", new import_three21.Float32BufferAttribute(colors2, 3)).setIndex(indices) }));
 }
-var import_three20;
+var import_three21;
 var init_GuiText = __esm({
   "src/gui/GuiText.ts"() {
-    import_three20 = require("three");
+    import_three21 = require("three");
     init_Fonts();
   }
 });
@@ -8428,7 +8866,7 @@ var init_GuiText = __esm({
 function createGuiTextureGeometry(width, height, imageWidth, imageHeight, crop, scaling) {
   if (crop || !scaling || scaling.type === "stretch") {
     const [x, y, w, h] = crop ?? [0, 0, imageWidth, imageHeight];
-    const geometry = new import_three21.PlaneGeometry(width, height);
+    const geometry = new import_three22.PlaneGeometry(width, height);
     const uv = geometry.getAttribute("uv");
     for (let i = 0; i < uv.count; i++) {
       uv.setXY(
@@ -8499,12 +8937,12 @@ function createGuiTextureGeometry(width, height, imageWidth, imageHeight, crop,
       }
     }
   }
-  return new import_three21.BufferGeometry().setAttribute("position", new import_three21.Float32BufferAttribute(positions, 3)).setAttribute("normal", new import_three21.Float32BufferAttribute(normals, 3)).setAttribute("uv", new import_three21.Float32BufferAttribute(uvs, 2)).setIndex(indices);
+  return new import_three22.BufferGeometry().setAttribute("position", new import_three22.Float32BufferAttribute(positions, 3)).setAttribute("normal", new import_three22.Float32BufferAttribute(normals, 3)).setAttribute("uv", new import_three22.Float32BufferAttribute(uvs, 2)).setIndex(indices);
 }
-var import_three21;
+var import_three22;
 var init_GuiTextureGeometry = __esm({
   "src/gui/GuiTextureGeometry.ts"() {
-    import_three21 = require("three");
+    import_three22 = require("three");
   }
 });
 
@@ -8520,7 +8958,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three22.BufferGeometry();
+  const mergedGeometry = new import_three23.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -8644,7 +9082,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three22.BufferAttribute(array, itemSize, normalized);
+  return new import_three23.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -8660,7 +9098,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three22.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three23.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -8669,7 +9107,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three22.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three23.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -8753,13 +9191,13 @@ function mergeVertices(geometry, tolerance = 1e-4) {
     const name = attributeNames[i];
     const oldAttribute = geometry.getAttribute(name);
     const buffer = new oldAttribute.array.constructor(attrArrays[name]);
-    const attribute = new import_three22.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three23.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
     result.setAttribute(name, attribute);
     if (name in morphAttrsArrays) {
       for (let j = 0; j < morphAttrsArrays[name].length; j++) {
         const oldMorphAttribute = geometry.morphAttributes[name][j];
         const buffer2 = new oldMorphAttribute.array.constructor(morphAttrsArrays[name][j]);
-        const morphAttribute = new import_three22.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three23.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -8768,11 +9206,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three22.TrianglesDrawMode) {
+  if (drawMode === import_three23.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three22.TriangleFanDrawMode || drawMode === import_three22.TriangleStripDrawMode) {
+  if (drawMode === import_three23.TriangleFanDrawMode || drawMode === import_three23.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -8790,7 +9228,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three22.TriangleFanDrawMode) {
+    if (drawMode === import_three23.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -8826,15 +9264,15 @@ function computeMorphedAttributes(object4) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three22.Vector3();
-  const _vB = new import_three22.Vector3();
-  const _vC = new import_three22.Vector3();
-  const _tempA = new import_three22.Vector3();
-  const _tempB = new import_three22.Vector3();
-  const _tempC = new import_three22.Vector3();
-  const _morphA = new import_three22.Vector3();
-  const _morphB = new import_three22.Vector3();
-  const _morphC = new import_three22.Vector3();
+  const _vA = new import_three23.Vector3();
+  const _vB = new import_three23.Vector3();
+  const _vC = new import_three23.Vector3();
+  const _tempA = new import_three23.Vector3();
+  const _tempB = new import_three23.Vector3();
+  const _tempC = new import_three23.Vector3();
+  const _morphA = new import_three23.Vector3();
+  const _morphB = new import_three23.Vector3();
+  const _morphC = new import_three23.Vector3();
   function _calculateMorphedAttributeData(object5, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -9029,8 +9467,8 @@ function computeMorphedAttributes(object4) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three22.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three22.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three23.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three23.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -9038,25 +9476,25 @@ function computeMorphedAttributes(object4) {
     morphedNormalAttribute
   };
 }
-var import_three22;
+var import_three23;
 var init_BufferGeometryUtils = __esm({
   "src/three/BufferGeometryUtils.js"() {
-    import_three22 = require("three");
+    import_three23 = require("three");
   }
 });
 
 // src/model/ModelCulling.ts
-var import_three23, ModelCulling;
+var import_three24, ModelCulling;
 var init_ModelCulling = __esm({
   "src/model/ModelCulling.ts"() {
-    import_three23 = require("three");
+    import_three24 = require("three");
     init_CubeFace();
     ModelCulling = class {
       /** Rotates a world-direction bit mask into model space. Bits follow {@link CUBE_FACES}. */
       static toLocalMask(worldMask, rotation) {
         let localMask = 0;
         for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
-          const normal = new import_three23.Vector3(...offset).applyEuler(rotation);
+          const normal = new import_three24.Vector3(...offset).applyEuler(rotation);
           const worldFace = 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);
           if (worldFace < 0) return 0;
           if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
@@ -9319,10 +9757,10 @@ var init_SkinImage = __esm({
 });
 
 // src/skin/SkinTextures.ts
-var import_three24, SkinTextures;
+var import_three25, SkinTextures;
 var init_SkinTextures = __esm({
   "src/skin/SkinTextures.ts"() {
-    import_three24 = require("three");
+    import_three25 = require("three");
     init_Caching();
     init_CacheKey();
     init_MineRenderError();
@@ -9360,11 +9798,11 @@ var init_SkinTextures = __esm({
         });
       }
       static createMaterial(pixels, width, height, transparent = true) {
-        const texture = Textures.initTextureProps(new import_three24.DataTexture(pixels, width, height));
-        texture.colorSpace = import_three24.SRGBColorSpace;
+        const texture = Textures.initTextureProps(new import_three25.DataTexture(pixels, width, height));
+        texture.colorSpace = import_three25.SRGBColorSpace;
         texture.flipY = true;
         texture.needsUpdate = true;
-        return new import_three24.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three24.DoubleSide : import_three24.FrontSide, alphaTest: transparent ? 0.1 : 0 });
+        return new import_three25.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three25.DoubleSide : import_three25.FrontSide, alphaTest: transparent ? 0.1 : 0 });
       }
       static isSlim(image, scale) {
         for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -9417,7 +9855,7 @@ var init_SkinTextures = __esm({
         return pixels;
       }
       static makeBaseOpaque(pixels, width, scale) {
-        for (const [x0, y0, x1, y1] of [[0, 0, 32, 16], [0, 16, 64, 32], [16, 48, 48, 64]]) {
+        for (const [x0, y0, x1, y1] of [[0, 0, 32, 16], [0, 16, 64, 32], [16, 48, 48, 64], [32, 0, 38, 7]]) {
           for (let y = y0 * scale; y < y1 * scale; y++) {
             for (let x = x0 * scale; x < x1 * scale; x++) pixels[(y * width + x) * 4 + 3] = 255;
           }
@@ -9428,6 +9866,10 @@ var init_SkinTextures = __esm({
 });
 
 // src/skin/PlayerHeadTextures.ts
+var PlayerHeadTextures_exports = {};
+__export(PlayerHeadTextures_exports, {
+  PlayerHeadTextures: () => PlayerHeadTextures
+});
 var PlayerHeadTextures;
 var init_PlayerHeadTextures = __esm({
   "src/skin/PlayerHeadTextures.ts"() {
@@ -9548,10 +9990,10 @@ var init_PlayerHeadTextures = __esm({
 });
 
 // src/model/SpecialItems.ts
-var import_three25, SpecialItems;
+var import_three26, SpecialItems;
 var init_SpecialItems = __esm({
   "src/model/SpecialItems.ts"() {
-    import_three25 = require("three");
+    import_three26 = require("three");
     init_AssetKey();
     init_Entities();
     init_BannerPatterns();
@@ -9589,8 +10031,8 @@ var init_SpecialItems = __esm({
             const sideTextures = DecoratedPots.getSideTextures(components["minecraft:pot_decorations"], root);
             const baseTexture = texture("decorated_pot_base", "decorated_pot");
             const [base, sides] = await Promise.all([
-              load("decorated_pot_base", baseTexture, new import_three25.Matrix4()),
-              load("decorated_pot_sides", texture("decorated_pot_side", "decorated_pot"), new import_three25.Matrix4())
+              load("decorated_pot_base", baseTexture, new import_three26.Matrix4()),
+              load("decorated_pot_sides", texture("decorated_pot_side", "decorated_pot"), new import_three26.Matrix4())
             ]);
             const layers = {
               base: { key: base.model.key, texture: baseTexture, layer: base.model.layer, render: "solid" }
@@ -9618,7 +10060,7 @@ var init_SpecialItems = __esm({
             const part = await load(
               "player_head",
               skin.texture,
-              new import_three25.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three25.Matrix4().makeScale(-1, -1, 1)),
+              new import_three26.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three26.Matrix4().makeScale(-1, -1, 1)),
               { head: [0, Math.PI, 0] }
             );
             const main = { ...part.model, texture: skin.texture, render: "translucent" };
@@ -9635,7 +10077,7 @@ var init_SpecialItems = __esm({
             const statue = await load(
               special.pose === "standing" ? "copper_golem" : `copper_golem_${special.pose}`,
               key,
-              new import_three25.Matrix4().makeTranslation(8, 24, 8).multiply(new import_three25.Matrix4().makeScale(-1, -1, 1))
+              new import_three26.Matrix4().makeTranslation(8, 24, 8).multiply(new import_three26.Matrix4().makeScale(-1, -1, 1))
             );
             const pose = statue.model.layer.root.pose;
             statue.rotations.root = [pose.rotation[0], Math.PI, Math.PI];
@@ -9651,7 +10093,7 @@ var init_SpecialItems = __esm({
             const part = await load(
               trident ? "trident" : "conduit",
               texture(trident ? "trident" : "conduit/base", ""),
-              trident ? new import_three25.Matrix4().makeScale(1, -1, -1) : new import_three25.Matrix4().makeTranslation(8, 8, 8),
+              trident ? new import_three26.Matrix4().makeScale(1, -1, -1) : new import_three26.Matrix4().makeTranslation(8, 8, 8),
               {},
               trident ? ["main"] : ["shell"]
             );
@@ -9672,7 +10114,7 @@ var init_SpecialItems = __esm({
             const patterns = await BannerPatterns.getLayers(components["minecraft:banner_patterns"], banner ? "banner" : "shield", root);
             const patterned = banner || color2 !== void 0 || patterns.length > 0;
             const baseTexture = texture(banner ? "banner_base" : patterned ? "shield_base" : "shield_base_nopattern", "");
-            const transform = banner ? new import_three25.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three25.Matrix4().makeScale(2 / 3, -2 / 3, -2 / 3)) : new import_three25.Matrix4().makeScale(1, -1, -1);
+            const transform = banner ? new import_three26.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three26.Matrix4().makeScale(2 / 3, -2 / 3, -2 / 3)) : new import_three26.Matrix4().makeScale(1, -1, -1);
             const part = await load(banner ? "standing_banner" : "shield", baseTexture, transform, {}, banner ? ["main", "flag"] : ["main"]);
             const layers = Object.fromEntries(Object.entries(part.model.layers ?? { main: part.model }).map(([name, layer]) => [name, { ...layer, render: "solid" }]));
             let overlay2;
@@ -9710,7 +10152,7 @@ var init_SpecialItems = __esm({
           case "minecraft:chest":
           case "chest": {
             const angle = -(special.openness ?? 0) * Math.PI / 2;
-            const chest = await load("chest", texture(special.texture, "chest"), new import_three25.Matrix4(), {
+            const chest = await load("chest", texture(special.texture, "chest"), new import_three26.Matrix4(), {
               lid: [angle, 0, 0],
               lock: [angle, 0, 0]
             });
@@ -9732,18 +10174,18 @@ var init_SpecialItems = __esm({
             if (!Object.prototype.hasOwnProperty.call(directions, orientation)) throw new Error(`Unsupported shulker-box orientation ${orientation}`);
             if (typeof openness !== "number" || !Number.isFinite(openness)) throw new Error("Shulker-box openness must be finite");
             if (typeof special.texture !== "string" || !special.texture) throw new Error("Shulker-box texture is required");
-            const transform = new import_three25.Matrix4().makeTranslation(8, 8, 8).multiply(new import_three25.Matrix4().makeScale(0.9995, 0.9995, 0.9995)).multiply(new import_three25.Matrix4().makeRotationFromEuler(new import_three25.Euler(...directions[orientation], "XYZ"))).multiply(new import_three25.Matrix4().makeScale(1, -1, -1)).multiply(new import_three25.Matrix4().makeTranslation(0, -16, 0));
+            const transform = new import_three26.Matrix4().makeTranslation(8, 8, 8).multiply(new import_three26.Matrix4().makeScale(0.9995, 0.9995, 0.9995)).multiply(new import_three26.Matrix4().makeRotationFromEuler(new import_three26.Euler(...directions[orientation], "XYZ"))).multiply(new import_three26.Matrix4().makeScale(1, -1, -1)).multiply(new import_three26.Matrix4().makeTranslation(0, -16, 0));
             const box = await load("shulker_box", texture(special.texture, "shulker"), transform, { lid: [0, openness * Math.PI * 1.5, 0] });
             box.positions = { lid: [0, 24 - openness * 8, 0] };
             return [box];
           }
           case "minecraft:bed":
           case "bed": {
-            const transform = new import_three25.Matrix4().makeTranslation(0, 9, 0).multiply(new import_three25.Matrix4().makeRotationX(Math.PI / 2)).multiply(new import_three25.Matrix4().makeTranslation(8, 8, 8)).multiply(new import_three25.Matrix4().makeRotationZ(Math.PI)).multiply(new import_three25.Matrix4().makeTranslation(-8, -8, -8));
+            const transform = new import_three26.Matrix4().makeTranslation(0, 9, 0).multiply(new import_three26.Matrix4().makeRotationX(Math.PI / 2)).multiply(new import_three26.Matrix4().makeTranslation(8, 8, 8)).multiply(new import_three26.Matrix4().makeRotationZ(Math.PI)).multiply(new import_three26.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_three25.Matrix4().makeTranslation(0, 0, -16).multiply(transform))
+              load("bed_foot", key, new import_three26.Matrix4().makeTranslation(0, 0, -16).multiply(transform))
             ]);
           }
           case "minecraft:head":
@@ -9755,265 +10197,62 @@ var init_SpecialItems = __esm({
               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_three25.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three25.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/ItemGlint.ts
-var import_three26, ItemGlint;
-var init_ItemGlint = __esm({
-  "src/model/ItemGlint.ts"() {
-    import_three26 = require("three");
-    init_AssetKey();
-    init_Models();
-    init_ModelTextures();
-    init_Caching();
-    init_Textures();
-    init_Ticker();
-    init_CubeFace();
-    init_DisplayPosition();
-    ItemGlint = class _ItemGlint {
-      constructor(owner, material) {
-        this.owner = owner;
-        this.material = material;
-        this.updateTime();
-      }
-      /** Enables glint for enchantments or a lodestone compass unless a boolean component overrides them. */
-      static enabled(components = {}, itemId) {
-        const override = Models.componentValue(components, "enchantment_glint_override");
-        if (override !== void 0) {
-          if (typeof override !== "boolean") throw new Error("Item enchantment_glint_override must be a boolean");
-          return override;
-        }
-        if (itemId === "minecraft:compass") {
-          Models.componentValue(components, "lodestone_tracker");
-          if (Object.prototype.hasOwnProperty.call(components, "lodestone_tracker") || Object.prototype.hasOwnProperty.call(components, "minecraft:lodestone_tracker")) return true;
-        }
-        const enchantments = Models.componentValue(components, "enchantments");
-        if (enchantments === void 0) return false;
-        if (!enchantments || typeof enchantments !== "object" || Array.isArray(enchantments)) throw new Error("Item enchantments must be an object");
-        return Object.keys(enchantments).length > 0;
-      }
-      /** @internal */
-      static async create(owner, baseMap, root, entityMeshes) {
-        const key = new AssetKey("minecraft", "enchanted_glint_item", "textures", "misc", "assets", ".png", root);
-        const assetKey = key.serialize(), textureKey = `item-glint:${assetKey}`;
-        let texture = Caching.textureCache.getIfPresent(textureKey);
-        if (!texture) {
-          const pending = ModelTextures.get(key);
-          const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKey);
-          const [image, metadata] = await Promise.all([pending, ModelTextures.getMeta(key)]);
-          if (!image) throw new Error(`Missing item glint texture ${key.toNamespacedString()}`);
-          if (cachedAsset && Caching.textureAssetCache.getIfPresent(assetKey) !== cachedAsset) return this.create(owner, baseMap, root, entityMeshes);
-          texture = Caching.textureCache.get(textureKey, () => {
-            const texture2 = Textures.createCanvasTexture(image.data.canvas);
-            texture2.wrapS = texture2.wrapT = metadata?.texture?.clamp ? import_three26.ClampToEdgeWrapping : import_three26.RepeatWrapping;
-            if (metadata?.texture?.blur) texture2.magFilter = texture2.minFilter = import_three26.LinearFilter;
-            return texture2;
-          });
-        }
-        const material = new import_three26.ShaderMaterial({
-          name: "item-glint",
-          transparent: true,
-          depthWrite: false,
-          depthFunc: import_three26.EqualDepth,
-          side: import_three26.DoubleSide,
-          forceSinglePass: true,
-          blending: import_three26.CustomBlending,
-          blendSrc: import_three26.SrcColorFactor,
-          blendDst: import_three26.OneFactor,
-          blendSrcAlpha: import_three26.ZeroFactor,
-          blendDstAlpha: import_three26.OneFactor,
-          toneMapped: false,
-          defines: entityMeshes ? { ENTITY_GLINT: true } : {},
-          uniforms: {
-            ...!entityMeshes && { baseMap: { value: baseMap } },
-            glintMap: { value: texture },
-            glintOffset: { value: new import_three26.Vector2() },
-            glintAlpha: { value: 0.75 }
-          },
-          vertexShader: `
-                uniform vec2 glintOffset;
-                #ifndef ENTITY_GLINT
-                attribute vec4 uvBounds;
-                attribute vec2 glintUv;
-                flat out vec4 vUvBounds;
-                centroid out vec2 vUv;
-                #endif
-                varying vec2 vGlintUv;
-                void main() {
-                    #ifdef ENTITY_GLINT
-                    vec2 p = vec2(uv.x, 1.0 - uv.y) * 0.5;
-                    #else
-                    vUv = uv;
-                    vUvBounds = uvBounds;
-                    vec2 p = glintUv * 8.0;
-                    #endif
-                    float angle = radians(10.0);
-                    vGlintUv = vec2(cos(angle) * p.x - sin(angle) * p.y, sin(angle) * p.x + cos(angle) * p.y) + glintOffset;
-                    vec4 mvPosition = vec4(position, 1.0);
-                    mvPosition = modelViewMatrix * mvPosition;
-                    gl_Position = projectionMatrix * mvPosition;
-                }
-            `,
-          fragmentShader: `
-                #ifndef ENTITY_GLINT
-                uniform sampler2D baseMap;
-                flat in vec4 vUvBounds;
-                centroid in vec2 vUv;
-                #endif
-                uniform sampler2D glintMap;
-                uniform float glintAlpha;
-                varying vec2 vGlintUv;
-                void main() {
-                    #ifndef ENTITY_GLINT
-                    vec2 mapUv = clamp(vUv, vUvBounds.xy, vUvBounds.zw);
-                    if (texture2D(baseMap, mapUv).a < 0.01) discard;
-                    #endif
-                    vec4 color = texture2D(glintMap, vec2(vGlintUv.x, 1.0 - vGlintUv.y));
-                    if (color.a < 0.1) discard;
-                    gl_FragColor = color;
-                    #include <colorspace_fragment>
-                    gl_FragColor.rgb *= glintAlpha;
-                }
-            `
-        });
-        if (!entityMeshes) Object.assign(material.defaultAttributeValues, { uvBounds: [0, 0, 1, 1] });
-        const targets = entityMeshes ? [...entityMeshes] : [];
-        if (!entityMeshes) owner.iterateAllMeshes((mesh) => targets.push({ mesh }));
-        for (const { mesh: base, parent = base } of targets) {
-          const pass = new import_three26.Mesh(base.geometry, material);
-          pass.name = `${base.name}:glint`;
-          pass.userData.minerenderItemGlint = true;
-          pass.raycast = () => {
-          };
-          pass.renderOrder = parent.renderOrder + 0.5;
-          parent.add(pass);
-        }
-        return new _ItemGlint(owner, material);
-      }
-      /**
-       * Maps glint before model centering and display transforms. Ordinary sprites approximate Minecraft's shared atlas density.
-       * @internal
-       */
-      static mapUvs(geometry, faces, atlas, itemId, display) {
-        const uv = geometry.getAttribute("uv");
-        const mapped = new Float32Array(uv.count * 2);
-        if (itemId === "minecraft:compass" || itemId === "minecraft:recovery_compass" || itemId === "minecraft:clock") {
-          const positions = geometry.getAttribute("position"), normals = geometry.getAttribute("normal");
-          const scale = display === "gui" /* GUI */ ? 0.5 : display === "firstperson_lefthand" /* FIRSTPERSON_LEFTHAND */ || display === "firstperson_righthand" /* FIRSTPERSON_RIGHTHAND */ ? 0.75 : 1;
-          const factor = 1 / (16 * 128 * scale);
-          for (let index = 0; index < positions.count; index++) {
-            const x = positions.getX(index), y = positions.getY(index), z = positions.getZ(index);
-            const nx = normals.getX(index), ny = normals.getY(index), nz = normals.getZ(index);
-            const ax = Math.abs(nx), ay = Math.abs(ny), az = Math.abs(nz);
-            let u, v;
-            if (ay >= az && ay >= ax) {
-              u = x;
-              v = ny < 0 ? -z : z;
-            } else if (az >= ax) {
-              u = nz < 0 ? -x : x;
-              v = -y;
-            } else {
-              u = nx < 0 ? -z : z;
-              v = -y;
-            }
-            mapped[index * 2] = u * factor;
-            mapped[index * 2 + 1] = v * factor;
-          }
-          geometry.setAttribute("glintUv", new import_three26.Float32BufferAttribute(mapped, 2));
-          return;
-        }
-        for (const [faceIndex, face] of CUBE_FACES.entries()) {
-          const texture = faces[face]?.texture?.substring(1);
-          const position = texture && atlas.positions[texture] || [0, 0];
-          const size = texture && atlas.sizes[texture] || [atlas.image.width, atlas.image.height];
-          for (let corner = 0; corner < 4; corner++) {
-            const index = faceIndex * 4 + corner;
-            mapped[index * 2] = (uv.getX(index) * atlas.image.width - position[0]) / size[0] / 32;
-            mapped[index * 2 + 1] = ((1 - uv.getY(index)) * atlas.image.height - position[1]) / size[1] / 32;
+            };
+            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_three26.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three26.Matrix4().makeScale(-1, -1, 1)),
+              rotations
+            )];
           }
         }
-        geometry.setAttribute("glintUv", new import_three26.Float32BufferAttribute(mapped, 2));
-      }
-      updateTime() {
-        const time = Math.trunc(Date.now() * 4);
-        this.material.uniforms.glintOffset.value.set(-(time % 11e4) / 11e4, time % 3e4 / 3e4);
       }
-      /** @internal */
-      updateSubscription(active) {
-        if (active && this.ticker === void 0) {
-          this.updateTime();
-          this.ticker = Ticker.add(() => {
-            this.updateTime();
-            this.owner.notifyDirty();
-          });
-        } else if (!active) {
-          Ticker.remove(this.ticker);
-          this.ticker = void 0;
+      /** 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";
         }
-      }
-      dispose() {
-        Ticker.remove(this.ticker);
-        this.ticker = void 0;
-        this.material.dispose();
+        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
 var ModelObject_exports = {};
 __export(ModelObject_exports, {
@@ -11159,17 +11398,25 @@ var init_BlockObject = __esm({
         if (!key || this.options.displayPosition) return false;
         const generation = this._entityGeneration;
         const created = [];
+        const placement = new import_three34.Matrix4();
         let resolved;
         try {
           resolved = BlockEntities.resolve(await BlockEntities.getIndex(key.root), key.toNamespacedString(), this.state);
           if (!resolved) return false;
+          BlockEntities.matrix(resolved, placement);
           for (const part of resolved.parts) {
             const [namespace, path] = part.model.includes(":") ? part.model.split(":") : [key.namespace, part.model];
-            const texture = part.textureLocation === void 0 ? void 0 : AssetKey.parse("textures", part.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+            let texture = part.textureLocation === void 0 ? void 0 : AssetKey.parse("textures", part.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+            if (part.textureLocation === void 0 && namespace === "minecraft" && path === "player_head") {
+              const { PlayerHeadTextures: PlayerHeadTextures2 } = await Promise.resolve().then(() => (init_PlayerHeadTextures(), PlayerHeadTextures_exports));
+              texture = (await PlayerHeadTextures2.get(void 0, key.root)).texture;
+            }
             if (texture) texture.root = key.root;
             const entity = await Entities.getEntity(new BasicAssetKey(namespace, path), texture, { layer: part.layer });
             if (!entity) throw new MineRenderError(`Missing entity model ${part.model}`);
-            created.push(await this.scene.addEntity(entity, { wireframe: this.options.wireframe }));
+            const object4 = await this.scene.addEntity(entity, { wireframe: this.options.wireframe });
+            this.placeEntity(object4, placement);
+            created.push(object4);
           }
         } catch (error) {
           log15.warn(`Could not draw block entity ${key.toNamespacedString()}, using its block model`, error);
@@ -11180,18 +11427,21 @@ var init_BlockObject = __esm({
           this.removeEntities(created);
           return true;
         }
-        BlockEntities.matrix(resolved, this._entityPlacement);
+        this._entityPlacement.copy(placement);
         this._entities = created;
         this.placeEntities();
         this.setVisible(this.visible);
         return true;
       }
       placeEntities() {
-        const matrix = new import_three34.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);
+          this.placeEntity(entity, this._entityPlacement);
         }
       }
+      placeEntity(entity, placement) {
+        const matrix = new import_three34.Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(placement);
+        matrix.decompose(entity.position, entity.quaternion, entity.scale);
+      }
       get isOccluding() {
         if (!this.visible) {
           return false;
@@ -11481,6 +11731,7 @@ __export(index_node_exports, {
   AnvilParser: () => AnvilParser,
   AnvilWorldSource: () => AnvilWorldSource,
   ArchiveAssetSource: () => ArchiveAssetSource,
+  Armor: () => Armor,
   AssetKey: () => AssetKey,
   AssetLoadError: () => AssetLoadError,
   AssetLoader: () => AssetLoader,
@@ -11564,6 +11815,7 @@ __export(index_node_exports, {
   OrbitControls: () => OrbitControls,
   PackFormats: () => PackFormats,
   PackMetadata: () => PackMetadata,
+  PalettedTextures: () => PalettedTextures,
   PersistentCache: () => PersistentCache,
   PlayerHeadTextures: () => PlayerHeadTextures,
   Renames: () => Renames,
@@ -11706,6 +11958,7 @@ init_PersistentCache();
 var NodeCache = class extends PersistentCache {
   constructor(backing) {
     super(backing);
+    this.pendingWrites = /* @__PURE__ */ new Map();
   }
   ready() {
     return this.initialized ??= this.backing.init();
@@ -11716,7 +11969,14 @@ var NodeCache = class extends PersistentCache {
   }
   async put(key, value) {
     await this.ready();
-    return this.backing.setItem(key, value).then((res) => res.content);
+    const previous = this.pendingWrites.get(key);
+    const write = (previous ? previous.catch(() => void 0) : Promise.resolve()).then(() => this.backing.setItem(key, value)).then(() => value);
+    this.pendingWrites.set(key, write);
+    try {
+      return await write;
+    } finally {
+      if (this.pendingWrites.get(key) === write) this.pendingWrites.delete(key);
+    }
   }
   async delete(key) {
     await this.ready();
@@ -11762,7 +12022,10 @@ var NodeEnv = class {
   openCache(name, version2) {
     return new NodeCache(import_node_persist.default.create({
       dir: name + version2,
-      encoding: "utf8"
+      encoding: "utf8",
+      // node-persist's unref'd one-second write queue delays loads and lets Node exit before writes finish.
+      // NodeCache serializes writes to each key while allowing different files to write concurrently.
+      writeQueue: false
     }));
   }
 };
@@ -11839,6 +12102,9 @@ function shutdown() {
   Caching.end();
 }
 
+// src/armor/index.ts
+init_Armor();
+
 // src/assets/index.ts
 init_AssetDefaults();
 init_AssetKey();
@@ -11930,10 +12196,10 @@ init_EntityObject();
 init_MineRenderError();
 
 // src/export/SceneExporter.ts
-var import_three19 = require("three");
+var import_three20 = require("three");
 
 // ../../node_modules/three/examples/jsm/exporters/OBJExporter.js
-var import_three16 = require("three");
+var import_three17 = require("three");
 var OBJExporter = class {
   /**
    * Parses the given 3D object and generates the OBJ output.
@@ -11948,17 +12214,17 @@ var OBJExporter = class {
     let indexVertex = 0;
     let indexVertexUvs = 0;
     let indexNormals = 0;
-    const vertex = new import_three16.Vector3();
-    const color2 = new import_three16.Color();
-    const normal = new import_three16.Vector3();
-    const uv = new import_three16.Vector2();
+    const vertex = new import_three17.Vector3();
+    const color2 = new import_three17.Color();
+    const normal = new import_three17.Vector3();
+    const uv = new import_three17.Vector2();
     const face = [];
     function parseMesh(mesh) {
       let nbVertex = 0;
       let nbNormals = 0;
       let nbVertexUvs = 0;
       const geometry = mesh.geometry;
-      const normalMatrixWorld = new import_three16.Matrix3();
+      const normalMatrixWorld = new import_three17.Matrix3();
       const vertices = geometry.getAttribute("position");
       const normals = geometry.getAttribute("normal");
       const uvs = geometry.getAttribute("uv");
@@ -12049,7 +12315,7 @@ var OBJExporter = class {
           output += "v " + vertex.x + " " + vertex.y + " " + vertex.z;
           if (colors2 !== void 0) {
             color2.fromBufferAttribute(colors2, i);
-            import_three16.ColorManagement.workingToColorSpace(color2, import_three16.SRGBColorSpace);
+            import_three17.ColorManagement.workingToColorSpace(color2, import_three17.SRGBColorSpace);
             output += " " + color2.r + " " + color2.g + " " + color2.b;
           }
           output += "\n";
@@ -12078,7 +12344,7 @@ var OBJExporter = class {
 };
 
 // ../../node_modules/three/examples/jsm/exporters/PLYExporter.js
-var import_three17 = require("three");
+var import_three18 = require("three");
 var PLYExporter = class {
   /**
    * Parses the given 3D object and generates the PLY output.
@@ -12179,7 +12445,7 @@ var PLYExporter = class {
         includeIndices = false;
       }
     });
-    const tempColor = new import_three17.Color();
+    const tempColor = new import_three18.Color();
     includeIndices = includeIndices && excludeAttributes.indexOf("index") === -1;
     includeNormals = includeNormals && excludeAttributes.indexOf("normal") === -1;
     includeColors = includeColors && excludeAttributes.indexOf("color") === -1;
@@ -12228,8 +12494,8 @@ property list uchar int vertex_index
 `;
     }
     header += "end_header\n";
-    const vertex = new import_three17.Vector3();
-    const normalMatrixWorld = new import_three17.Matrix3();
+    const vertex = new import_three18.Vector3();
+    const normalMatrixWorld = new import_three18.Matrix3();
     let result = null;
     if (options.binary === true) {
       const headerBin = new TextEncoder().encode(header);
@@ -12307,7 +12573,7 @@ property list uchar int vertex_index
           if (includeColors === true) {
             if (colors2 != null) {
               tempColor.fromBufferAttribute(colors2, i);
-              import_three17.ColorManagement.workingToColorSpace(tempColor, import_three17.SRGBColorSpace);
+              import_three18.ColorManagement.workingToColorSpace(tempColor, import_three18.SRGBColorSpace);
               const r = colorIsFloat ? tempColor.r : Math.round(tempColor.r * colorScale);
               const g = colorIsFloat ? tempColor.g : Math.round(tempColor.g * colorScale);
               const b = colorIsFloat ? tempColor.b : Math.round(tempColor.b * colorScale);
@@ -12409,7 +12675,7 @@ property list uchar int vertex_index
           if (includeColors === true) {
             if (colors2 != null) {
               tempColor.fromBufferAttribute(colors2, i);
-              import_three17.ColorManagement.workingToColorSpace(tempColor, import_three17.SRGBColorSpace);
+              import_three18.ColorManagement.workingToColorSpace(tempColor, import_three18.SRGBColorSpace);
               const r = colorIsFloat ? tempColor.r : Math.round(tempColor.r * colorScale);
               const g = colorIsFloat ? tempColor.g : Math.round(tempColor.g * colorScale);
               const b = colorIsFloat ? tempColor.b : Math.round(tempColor.b * colorScale);
@@ -12561,10 +12827,10 @@ var SceneExporter = class {
   }
 };
 function localMatrix(object4) {
-  return object4.matrixAutoUpdate ? new import_three19.Matrix4().compose(object4.position, object4.quaternion, object4.scale) : object4.matrix.clone();
+  return object4.matrixAutoUpdate ? new import_three20.Matrix4().compose(object4.position, object4.quaternion, object4.scale) : object4.matrix.clone();
 }
 function createSnapshot(root, gltf, bakeColors = false) {
-  const scene = new import_three19.Scene();
+  const scene = new import_three20.Scene();
   const geometries = [];
   const materials = [];
   const textures = [];
@@ -12582,7 +12848,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
       if (!uniforms.map?.value?.isTexture || !uniforms.SHADE || !uniforms.BRIGHTNESS || !uniforms.EMISSIVE) {
         throw new MineRenderError("glTF export does not support this custom ShaderMaterial");
       }
-      material = new import_three19.MeshBasicMaterial({
+      material = new import_three20.MeshBasicMaterial({
         map: uniforms.map.value,
         vertexColors: source.vertexColors,
         transparent: source.transparent,
@@ -12592,7 +12858,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
       });
       material.name = source.name;
     } else if (shader.isShaderMaterial) {
-      material = new import_three19.MeshBasicMaterial({ vertexColors: source.vertexColors });
+      material = new import_three20.MeshBasicMaterial({ vertexColors: source.vertexColors });
       material.name = source.name;
     } else {
       const copySource = Object.create(source);
@@ -12646,11 +12912,11 @@ function createSnapshot(root, gltf, bakeColors = false) {
       const material = copyMaterial(sourceMaterial, geometry);
       if (!sourceMaterial.vertexColors) geometry.deleteAttribute("color");
       if (bakeColors || instanceColor) {
-        const tint = (material.color ?? new import_three19.Color()).clone();
+        const tint = (material.color ?? new import_three20.Color()).clone();
         if (instanceColor) tint.multiply(instanceColor);
         if (bakeColors) {
           const original = geometry.getAttribute("color");
-          const colors2 = new import_three19.Float32BufferAttribute(new Float32Array(geometry.getAttribute("position").count * 3), 3);
+          const colors2 = new import_three20.Float32BufferAttribute(new Float32Array(geometry.getAttribute("position").count * 3), 3);
           for (let i = 0; i < colors2.count; i++) {
             colors2.setXYZ(i, (original?.getX(i) ?? 1) * tint.r, (original?.getY(i) ?? 1) * tint.g, (original?.getZ(i) ?? 1) * tint.b);
           }
@@ -12659,7 +12925,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
           material.color.copy(tint);
         }
       }
-      const copy = new import_three19.Mesh(geometry, material);
+      const copy = new import_three20.Mesh(geometry, material);
       copy.name = mesh.name;
       copy.renderOrder = mesh.renderOrder;
       scene.add(copy);
@@ -12673,9 +12939,9 @@ function createSnapshot(root, gltf, bakeColors = false) {
       const instanced = mesh;
       if (instanced.isInstancedMesh) {
         for (let i = 0; i < instanced.count; i++) {
-          const matrix = new import_three19.Matrix4();
+          const matrix = new import_three20.Matrix4();
           instanced.getMatrixAt(i, matrix);
-          const color2 = instanced.instanceColor ? new import_three19.Color().fromBufferAttribute(instanced.instanceColor, i) : void 0;
+          const color2 = instanced.instanceColor ? new import_three20.Color().fromBufferAttribute(instanced.instanceColor, i) : void 0;
           addMesh(mesh, world.clone().multiply(matrix), color2);
         }
       } else {
@@ -12687,7 +12953,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
   try {
     const ancestors = [];
     for (let parent = root.parent; parent; parent = parent.parent) ancestors.unshift(parent);
-    const world = new import_three19.Matrix4();
+    const world = new import_three20.Matrix4();
     for (const ancestor of ancestors) {
       if (!ancestor.visible) return { scene, dispose };
       world.multiply(localMatrix(ancestor));
@@ -12701,7 +12967,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
 }
 function selectAlphaMode(material, geometry) {
   const texture = material.map;
-  if (material.type !== "MeshBasicMaterial" || !material.transparent || !material.depthWrite || material.opacity !== 1 || material.alphaMap || !texture?.isDataTexture || texture.format !== import_three19.RGBAFormat || texture.type !== import_three19.UnsignedByteType || texture.wrapS !== import_three19.ClampToEdgeWrapping || texture.wrapT !== import_three19.ClampToEdgeWrapping || texture.magFilter !== import_three19.NearestFilter || texture.minFilter !== import_three19.NearestFilter || texture.anisotropy > 1 || texture.offset.x !== 0 || texture.offset.y !== 0 || texture.repeat.x !== 1 || texture.repeat.y !== 1 || texture.rotation !== 0 || !texture.matrixAutoUpdate && !texture.matrix.elements.every((value, i) => value === (i % 4 === 0 ? 1 : 0))) return;
+  if (material.type !== "MeshBasicMaterial" || !material.transparent || !material.depthWrite || material.opacity !== 1 || material.alphaMap || !texture?.isDataTexture || texture.format !== import_three20.RGBAFormat || texture.type !== import_three20.UnsignedByteType || texture.wrapS !== import_three20.ClampToEdgeWrapping || texture.wrapT !== import_three20.ClampToEdgeWrapping || texture.magFilter !== import_three20.NearestFilter || texture.minFilter !== import_three20.NearestFilter || texture.anisotropy > 1 || texture.offset.x !== 0 || texture.offset.y !== 0 || texture.repeat.x !== 1 || texture.repeat.y !== 1 || texture.rotation !== 0 || !texture.matrixAutoUpdate && !texture.matrix.elements.every((value, i) => value === (i % 4 === 0 ? 1 : 0))) return;
   const uv = geometry.getAttribute(texture.channel === 0 ? "uv" : `uv${texture.channel}`);
   const colors2 = geometry.getAttribute("color");
   if (!uv || material.vertexColors && colors2?.itemSize === 4) return;
@@ -12738,7 +13004,7 @@ function selectAlphaMode(material, geometry) {
 }
 function copyDataTexture(source) {
   const image = source.image;
-  if (!image.data || source.format !== import_three19.RGBAFormat || source.type !== import_three19.UnsignedByteType) {
+  if (!image.data || source.format !== import_three20.RGBAFormat || source.type !== import_three20.UnsignedByteType) {
     throw new MineRenderError("glTF export requires RGBA unsigned-byte data textures");
   }
   const canvas = createCanvas2(image.width, image.height);
@@ -12749,8 +13015,8 @@ function copyDataTexture(source) {
   context.putImageData(pixels, 0, 0);
   const copySource = Object.create(source);
   copySource.userData = {};
-  copySource.source = new import_three19.TextureSource(canvas);
-  return new import_three19.Texture().copy(copySource);
+  copySource.source = new import_three20.TextureSource(canvas);
+  return new import_three20.Texture().copy(copySource);
 }
 
 // src/export/VideoExporter.ts
@@ -14360,12 +14626,13 @@ function isFlyControls(obj) {
 }
 
 // src/renderer/MineRenderScene.ts
-var import_three36 = require("three");
+var import_three37 = require("three");
 init_SceneObject();
 init_merge();
 
 // src/skin/scene/SkinObject.ts
 init_SceneObject();
+var import_three36 = require("three");
 
 // src/skin/SkinPart.ts
 var SkinPart = /* @__PURE__ */ ((SkinPart2) => {
@@ -14382,11 +14649,21 @@ var SkinPart = /* @__PURE__ */ ((SkinPart2) => {
   SkinPart2["RIGHT_TROUSERS"] = "rightTrousers";
   SkinPart2["LEFT_TROUSERS"] = "leftTrousers";
   SkinPart2["CAPE"] = "cape";
+  SkinPart2["LEFT_EAR"] = "leftEar";
+  SkinPart2["RIGHT_EAR"] = "rightEar";
   return SkinPart2;
 })(SkinPart || {});
 var SKIN_PARTS = Object.values(SkinPart);
 
 // src/skin/SkinTextureCoordinates.ts
+var earCoordinates = {
+  west: { uv: [24, 1, 25, 7] },
+  east: { uv: [31, 1, 32, 7] },
+  south: { uv: [25, 1, 31, 7] },
+  north: { uv: [32, 1, 38, 7] },
+  up: { uv: [25, 0, 31, 1] },
+  down: { uv: [31, 1, 37, 0] }
+};
 var baseSkinCoordinates = {
   head: {
     west: {
@@ -15007,7 +15284,9 @@ var baseSkinCoordinates = {
     south: { uv: [12, 1, 22, 17] },
     up: { uv: [11, 1, 1, 0] },
     down: { uv: [21, 0, 11, 1] }
-  }
+  },
+  leftEar: earCoordinates,
+  rightEar: earCoordinates
 };
 var classicSkinTextureCoordinates = {
   ...baseSkinCoordinates
@@ -15058,6 +15337,7 @@ var box4_12_4outer = [4.5, 12.5, 4.5];
 var box3_12_4inner = [3, 12, 4];
 var box3_12_4outer = [3.5, 12.5, 4.5];
 var box10_16_1 = [10, 16, 1];
+var box8_8_3ear = [8, 8, 3];
 var baseSkinGeometries = {
   head: box8inner,
   hat: box8outer,
@@ -15071,7 +15351,9 @@ var baseSkinGeometries = {
   leftTrousers: box4_12_4outer,
   rightLeg: box4_12_4inner,
   rightTrousers: box4_12_4outer,
-  cape: box10_16_1
+  cape: box10_16_1,
+  leftEar: box8_8_3ear,
+  rightEar: box8_8_3ear
 };
 var classicSkinGeometries = { ...{}, ...baseSkinGeometries };
 var slimSkinGeometries = {
@@ -15100,6 +15382,12 @@ var capeTextureSizes = {
 };
 
 // src/skin/scene/SkinObject.ts
+var ArmorClass;
+var EntityObjectClass;
+function hasCubes(part) {
+  return part.cubes.length > 0 || Object.values(part.children).some(hasCubes);
+}
+var UPSIDE_DOWN_OFFSET = (1.8 + 0.1) * 16 / 0.9375;
 var SkinObject = class extends SceneObject {
   constructor(options) {
     super();
@@ -15107,27 +15395,42 @@ var SkinObject = class extends SceneObject {
     this.detectedSlim = false;
     this.skinLoad = 0;
     this.capeLoad = 0;
+    this.armorLoad = 0;
+    this.armorObjects = [];
     this.options = (0, import_ts_deepmerge.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
     this.slim = this.options.slim ?? false;
   }
   async init() {
     const cape = this.getGroupByName("cape" /* CAPE */);
+    const capeOnBody = cape?.parent === this.getGroupByName("body" /* BODY */);
     this.createMeshes();
-    if (cape) this.getGroupByName("body" /* BODY */).attach(cape);
+    if (cape) {
+      const body = this.getGroupByName("body" /* BODY */);
+      if (capeOnBody) body.add(cape);
+      else body.attach(cape);
+    }
+    for (const { part, object: object4 } of this.armorObjects) this.getGroupByName(part).add(object4);
+    this.updateEars();
+    this.updateUpsideDown();
   }
   removeMeshes() {
   }
   createMeshes() {
     const mat = this.skinMaterial ?? Materials.MISSING_TEXTURE;
+    this.model?.removeFromParent();
+    const model = this.model = new import_three36.Object3D();
+    this.add(model);
     {
-      const headGroup = this.createAndAddGroup("head", 0, 28, 0, "y" /* Y */, -4);
+      const headGroup = this.createGroup("head", 0, 28, 0, "y" /* Y */, -4);
+      model.add(headGroup);
       const headGeo = this.getBoxGeometry("head" /* HEAD */);
       const head = this.createAndAddMesh("head", headGroup, headGeo, mat, "y" /* Y */, 4);
       const hatGeo = this.getBoxGeometry("hat" /* HAT */);
       const hat = this.createAndAddMesh("hat", headGroup, hatGeo, mat, "y" /* Y */, 4);
     }
     {
-      const bodyGroup = this.createAndAddGroup("body", 0, 24, 0);
+      const bodyGroup = this.createGroup("body", 0, 24, 0);
+      model.add(bodyGroup);
       const bodyGeo = this.getBoxGeometry("body" /* BODY */);
       const body = this.createAndAddMesh("body", bodyGroup, bodyGeo, mat, "y" /* Y */, -6);
       const jacketGeo = this.getBoxGeometry("jacket" /* JACKET */);
@@ -15135,7 +15438,8 @@ var SkinObject = class extends SceneObject {
     }
     {
       {
-        const leftArmGroup = this.createAndAddGroup("leftArm", 5, 22, 0);
+        const leftArmGroup = this.createGroup("leftArm", 5, 22, 0);
+        model.add(leftArmGroup);
         const leftArmGeo = this.getBoxGeometry("leftArm" /* LEFT_ARM */);
         const leftArm = this.createAndAddMesh("leftArm", leftArmGroup, leftArmGeo, mat, "y" /* Y */, -4);
         leftArm.position.x = this.slim ? 0.5 : 1;
@@ -15144,7 +15448,8 @@ var SkinObject = class extends SceneObject {
         leftSleeve.position.x = this.slim ? 0.5 : 1;
       }
       {
-        const rightArmGroup = this.createAndAddGroup("rightArm", -5, 22, 0);
+        const rightArmGroup = this.createGroup("rightArm", -5, 22, 0);
+        model.add(rightArmGroup);
         const rightArmGeo = this.getBoxGeometry("rightArm" /* RIGHT_ARM */);
         const rightArm = this.createAndAddMesh("rightArm", rightArmGroup, rightArmGeo, mat, "y" /* Y */, -4);
         rightArm.position.x = this.slim ? -0.5 : -1;
@@ -15155,14 +15460,16 @@ var SkinObject = class extends SceneObject {
     }
     {
       {
-        const leftLegGroup = this.createAndAddGroup("leftLeg", 1.9, 12, 0);
+        const leftLegGroup = this.createGroup("leftLeg", 1.9, 12, 0);
+        model.add(leftLegGroup);
         const leftLegGeo = this.getBoxGeometry("leftLeg" /* LEFT_LEG */);
         const leftLeg = this.createAndAddMesh("leftLeg", leftLegGroup, leftLegGeo, mat, "y" /* Y */, -6);
         const leftTrousersGeo = this.getBoxGeometry("leftTrousers" /* LEFT_TROUSERS */);
         const leftTrousers = this.createAndAddMesh("leftTrousers", leftLegGroup, leftTrousersGeo, mat, "y" /* Y */, -6);
       }
       {
-        const rightLegGroup = this.createAndAddGroup("rightLeg", -1.9, 12, 0);
+        const rightLegGroup = this.createGroup("rightLeg", -1.9, 12, 0);
+        model.add(rightLegGroup);
         const rightLegGeo = this.getBoxGeometry("rightLeg" /* RIGHT_LEG */);
         const rightLeg = this.createAndAddMesh("rightLeg", rightLegGroup, rightLegGeo, mat, "y" /* Y */, -6);
         const rightTrousersGeo = this.getBoxGeometry("rightTrousers" /* RIGHT_TROUSERS */);
@@ -15229,6 +15536,54 @@ var SkinObject = class extends SceneObject {
     }
     this.notifyDirty();
   }
+  /**
+   * Loads armor from 1.21.4+ equipment assets, or pass undefined to remove it.
+   * Each piece moves with the skin part it covers.
+   */
+  async setArmor(armor) {
+    const load = ++this.armorLoad;
+    const objects = [];
+    if (armor) {
+      const Armor2 = ArmorClass ??= (await Promise.resolve().then(() => (init_Armor(), Armor_exports))).Armor;
+      const EntityObject2 = EntityObjectClass ??= (await Promise.resolve().then(() => (init_EntityObject(), EntityObject_exports))).EntityObject;
+      const model = await Armor2.getEntity(armor);
+      if (model) {
+        const parts = { head: "head", body: "body", left_arm: "leftArm", right_arm: "rightArm", left_leg: "leftLeg", right_leg: "rightLeg" };
+        for (const [name, part] of Object.entries(parts)) {
+          const layers = {};
+          for (const [draw, layer] of Object.entries(model.layers)) {
+            const child = layer.layer.root.children[name];
+            if (!child || !hasCubes(child)) continue;
+            const pose = { offset: [0, 0, 0], rotation: [0, 0, 0] };
+            layers[draw] = { ...layer, layer: { ...layer.layer, root: {
+              pose,
+              cubes: [],
+              children: { [name]: { ...child, pose } }
+            } } };
+          }
+          const first = Object.values(layers)[0];
+          if (!first) continue;
+          const object4 = new EntityObject2({ ...first, id: model.id, layers }, { flip: false });
+          object4.rotation.x = Math.PI;
+          objects.push({ part, object: object4 });
+        }
+      }
+    }
+    const results = await Promise.allSettled(objects.map(({ object: object4 }) => object4.init()));
+    const failure = results.find((result) => result.status === "rejected");
+    if (load !== this.armorLoad || failure) {
+      for (const { object: object4 } of objects) object4.dispose();
+      if (load === this.armorLoad && failure?.status === "rejected") throw failure.reason;
+      return;
+    }
+    for (const { object: object4 } of this.armorObjects) {
+      object4.dispose();
+      object4.removeFromParent();
+    }
+    this.armorObjects = objects;
+    for (const { part, object: object4 } of objects) this.getGroupByName(part)?.add(object4);
+    this.notifyDirty();
+  }
   /** Select the arm model, or pass undefined to use texture detection. */
   setSlim(slim) {
     this.options.slim = slim;
@@ -15247,6 +15602,39 @@ var SkinObject = class extends SceneObject {
     }
     this.notifyDirty();
   }
+  /** Shows or hides deadmau5's ears, which vanilla draws from the skin texture at 24,0 for that player only. */
+  setEars(ears) {
+    if (ears === (this.options.ears ?? false)) return;
+    this.options.ears = ears;
+    this.updateEars();
+  }
+  updateEars() {
+    const head = this.getGroupByName("head" /* HEAD */);
+    if (!head) return;
+    for (const [part, x] of [["leftEar" /* LEFT_EAR */, 6], ["rightEar" /* RIGHT_EAR */, -6]]) {
+      const ear = this.getMeshByName(part);
+      if (!this.options.ears) {
+        ear?.removeFromParent();
+      } else if (!ear) {
+        const mesh = this.createAndAddMesh(part, head, this.getBoxGeometry(part), this.skinMaterial ?? Materials.MISSING_TEXTURE);
+        mesh.position.set(x, 9, 0.5);
+      }
+    }
+    this.notifyDirty();
+  }
+  /** Turns the player upside down, as vanilla does for players named Dinnerbone or Grumm. */
+  setUpsideDown(upsideDown) {
+    if (upsideDown === (this.options.upsideDown ?? false)) return;
+    this.options.upsideDown = upsideDown;
+    this.updateUpsideDown();
+  }
+  updateUpsideDown() {
+    if (!this.model) return;
+    const upsideDown = this.options.upsideDown ?? false;
+    this.model.position.y = upsideDown ? UPSIDE_DOWN_OFFSET : 0;
+    this.model.rotation.z = upsideDown ? Math.PI : 0;
+    this.notifyDirty();
+  }
   /** Select the texture layout, or pass undefined to detect it from image dimensions. */
   async setLegacy(legacy) {
     if (legacy === this.options.legacy) return;
@@ -15256,6 +15644,11 @@ var SkinObject = class extends SceneObject {
   dispose() {
     this.skinLoad++;
     this.capeLoad++;
+    this.armorLoad++;
+    for (const { object: object4 } of this.armorObjects.splice(0)) {
+      object4.dispose();
+      object4.removeFromParent();
+    }
     super.dispose();
   }
   //TODO: layer toggles
@@ -15275,10 +15668,10 @@ function isBlockObject2(obj) {
 }
 var ModelObjectClass;
 var BlockObjectClass;
-var EntityObjectClass;
+var EntityObjectClass2;
 var GuiObjectClass;
 var ItemTintsClass;
-var MineRenderScene = class _MineRenderScene extends import_three36.Scene {
+var MineRenderScene = class _MineRenderScene extends import_three37.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -15419,7 +15812,7 @@ var MineRenderScene = class _MineRenderScene extends import_three36.Scene {
   }
   /** Adds an entity loaded with {@link Entities.getEntity}, using its selected layers and textures. */
   async addEntity(entity, options, parent = this) {
-    const EntityObject2 = EntityObjectClass ??= (await Promise.resolve().then(() => (init_EntityObject(), EntityObject_exports))).EntityObject;
+    const EntityObject2 = EntityObjectClass2 ??= (await Promise.resolve().then(() => (init_EntityObject(), EntityObject_exports))).EntityObject;
     return this.addSceneObject(entity, () => new EntityObject2(entity, options), options, parent);
   }
   /**
@@ -15441,7 +15834,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three38 = require("three");
+var import_three39 = require("three");
 init_merge();
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
@@ -15450,11 +15843,11 @@ init_Model();
 init_three();
 
 // src/three/OrbitControls.js
-var import_three37 = require("three");
+var import_three38 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three37.EventDispatcher {
+var OrbitControls = class extends import_three38.EventDispatcher {
   constructor(object4, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -15463,7 +15856,7 @@ var OrbitControls = class extends import_three37.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three37.Vector3();
+    this.target = new import_three38.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -15485,8 +15878,8 @@ var OrbitControls = class extends import_three37.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three37.MOUSE.ROTATE, MIDDLE: import_three37.MOUSE.DOLLY, RIGHT: import_three37.MOUSE.PAN };
-    this.touches = { ONE: import_three37.TOUCH.ROTATE, TWO: import_three37.TOUCH.DOLLY_PAN };
+    this.mouseButtons = { LEFT: import_three38.MOUSE.ROTATE, MIDDLE: import_three38.MOUSE.DOLLY, RIGHT: import_three38.MOUSE.PAN };
+    this.touches = { ONE: import_three38.TOUCH.ROTATE, TWO: import_three38.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -15515,11 +15908,11 @@ var OrbitControls = class extends import_three37.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three37.Vector3();
-      const quat = new import_three37.Quaternion().setFromUnitVectors(object4.up, new import_three37.Vector3(0, 1, 0));
+      const offset = new import_three38.Vector3();
+      const quat = new import_three38.Quaternion().setFromUnitVectors(object4.up, new import_three38.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three37.Vector3();
-      const lastQuaternion = new import_three37.Quaternion();
+      const lastPosition = new import_three38.Vector3();
+      const lastQuaternion = new import_three38.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -15605,20 +15998,20 @@ var OrbitControls = class extends import_three37.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three37.Spherical();
-    const sphericalDelta = new import_three37.Spherical();
+    const spherical = new import_three38.Spherical();
+    const sphericalDelta = new import_three38.Spherical();
     let scale = 1;
-    const panOffset = new import_three37.Vector3();
+    const panOffset = new import_three38.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three37.Vector2();
-    const rotateEnd = new import_three37.Vector2();
-    const rotateDelta = new import_three37.Vector2();
-    const panStart = new import_three37.Vector2();
-    const panEnd = new import_three37.Vector2();
-    const panDelta = new import_three37.Vector2();
-    const dollyStart = new import_three37.Vector2();
-    const dollyEnd = new import_three37.Vector2();
-    const dollyDelta = new import_three37.Vector2();
+    const rotateStart = new import_three38.Vector2();
+    const rotateEnd = new import_three38.Vector2();
+    const rotateDelta = new import_three38.Vector2();
+    const panStart = new import_three38.Vector2();
+    const panEnd = new import_three38.Vector2();
+    const panDelta = new import_three38.Vector2();
+    const dollyStart = new import_three38.Vector2();
+    const dollyEnd = new import_three38.Vector2();
+    const dollyDelta = new import_three38.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -15634,7 +16027,7 @@ var OrbitControls = class extends import_three37.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three37.Vector3();
+      const v = new import_three38.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -15642,7 +16035,7 @@ var OrbitControls = class extends import_three37.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three37.Vector3();
+      const v = new import_three38.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -15655,7 +16048,7 @@ var OrbitControls = class extends import_three37.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three37.Vector3();
+      const offset = new import_three38.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -15904,12 +16297,12 @@ var OrbitControls = class extends import_three37.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three37.MOUSE.DOLLY:
+        case import_three38.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three37.MOUSE.ROTATE:
+        case import_three38.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -15920,7 +16313,7 @@ var OrbitControls = class extends import_three37.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three37.MOUSE.PAN:
+        case import_three38.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -15976,12 +16369,12 @@ var OrbitControls = class extends import_three37.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three37.TOUCH.ROTATE:
+            case import_three38.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three37.TOUCH.PAN:
+            case import_three38.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -15992,12 +16385,12 @@ var OrbitControls = class extends import_three37.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three37.TOUCH.DOLLY_PAN:
+            case import_three38.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three37.TOUCH.DOLLY_ROTATE:
+            case import_three38.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -16064,7 +16457,7 @@ var OrbitControls = class extends import_three37.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three37.Vector2();
+        position = new import_three38.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -16084,10 +16477,10 @@ var MapControls = class extends OrbitControls {
   constructor(object4, domElement) {
     super(object4, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three37.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three37.MOUSE.ROTATE;
-    this.touches.ONE = import_three37.TOUCH.PAN;
-    this.touches.TWO = import_three37.TOUCH.DOLLY_ROTATE;
+    this.mouseButtons.LEFT = import_three38.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three38.MOUSE.ROTATE;
+    this.touches.ONE = import_three38.TOUCH.PAN;
+    this.touches.TWO = import_three38.TOUCH.DOLLY_ROTATE;
   }
 };
 
@@ -16168,8 +16561,8 @@ var Renderer = class _Renderer {
           top: void 0,
           bottom: void 0
         },
-        position: new import_three38.Vector3(50, 50, 50),
-        lookingAt: new import_three38.Vector3(0, 0, 0)
+        position: new import_three39.Vector3(50, 50, 50),
+        lookingAt: new import_three39.Vector3(0, 0, 0)
       },
       render: {
         fpsLimit: 60,
@@ -16201,14 +16594,14 @@ var Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three38.PerspectiveCamera(
+        return new import_three39.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_three38.OrthographicCamera(
+        return new import_three39.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,
@@ -16224,7 +16617,7 @@ var Renderer = class _Renderer {
     }
     const pixelRatio = this.options.render.pixelRatio ?? 1;
     this._surface?.resize?.(Math.floor(this.viewWidth * pixelRatio), Math.floor(this.viewHeight * pixelRatio));
-    const renderer = new import_three38.WebGLRenderer({
+    const renderer = new import_three39.WebGLRenderer({
       canvas: this._surface?.canvas,
       context: this._surface?.context,
       antialias: this.options.render.antialias,
@@ -16234,8 +16627,8 @@ var Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three38.PCFShadowMap;
-    renderer.outputColorSpace = import_three38.SRGBColorSpace;
+    renderer.shadowMap.type = import_three39.PCFShadowMap;
+    renderer.outputColorSpace = import_three39.SRGBColorSpace;
     if (this._surface) {
       renderer.setDrawingBufferSize(this.viewWidth, this.viewHeight, pixelRatio);
     } else {
@@ -16258,8 +16651,8 @@ var Renderer = class _Renderer {
   initialTarget() {
     const target = this.options.camera.lookingAt;
     if (isVector3(target)) return target.clone();
-    if (isTripleArray(target)) return new import_three38.Vector3(target[0], target[1], target[2]);
-    return new import_three38.Vector3();
+    if (isTripleArray(target)) return new import_three39.Vector3(target[0], target[1], target[2]);
+    return new import_three39.Vector3();
   }
   createControlsFor(mode, target) {
     let controls;
@@ -16292,7 +16685,7 @@ var Renderer = class _Renderer {
     let target;
     if (isFlyControls(current)) {
       const distance = this._orbitDistance ?? (this.camera.position.distanceTo(this.initialTarget()) || 1);
-      target = new import_three38.Vector3(0, 0, -distance).applyQuaternion(this.camera.quaternion).add(this.camera.position);
+      target = new import_three39.Vector3(0, 0, -distance).applyQuaternion(this.camera.quaternion).add(this.camera.position);
     } else {
       target = current.target.clone();
       this._orbitDistance = this.camera.position.distanceTo(target);
@@ -16332,20 +16725,20 @@ var Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three38.GridHelper(128, 16);
+      const gridHelper = new import_three39.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three38.GridHelper(128, 16);
+      const gridHelper2 = new import_three39.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three38.GridHelper(128, 16);
+      const gridHelper3 = new import_three39.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_three38.AxesHelper(64);
+      const axesHelper = new import_three39.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -16766,6 +17159,23 @@ var itemContext = (withDisplayContext) => (value, path) => {
     }
   });
 };
+function entityAnimation(value, path) {
+  const animation = object3(value, path);
+  if (["name", "clips"].filter((key) => animation[key] !== void 0).length !== 1) {
+    fail(path, "expected exactly one of name or clips");
+  }
+  fields(value, path, { name: text, clips: (value2, path2) => {
+    list((value3, path3) => {
+      fields(value3, path3, { name: text, weight: nonnegative }, ["name"]);
+    })(value2, path2);
+    if (!value2.length) fail(path2, "expected at least one clip");
+    const names = /* @__PURE__ */ new Set();
+    for (const [index, clip] of value2.entries()) {
+      if (names.has(clip.name)) fail(`${path2}[${index}].name`, `duplicate clip "${clip.name}"`);
+      names.add(clip.name);
+    }
+  }, loop: boolean, speed: nonnegative, time: nonnegative, paused: boolean });
+}
 function guiLayer(value, path) {
   const layer = object3(value, path);
   if (["texture", "item", "text"].filter((key) => layer[key] !== void 0).length !== 1) {
@@ -16806,13 +17216,27 @@ function validateObject(value, path) {
   const required = ["id", "type"];
   const renderOptions = { wireframe: boolean };
   switch (input.type) {
-    case "skin":
+    case "skin": {
+      const piece = (value2, path2) => {
+        if (typeof value2 === "string") asset(value2, path2);
+        else fields(value2, path2, {
+          asset,
+          color,
+          glint: boolean,
+          trim: (value3, path3) => {
+            fields(value3, path3, { pattern: asset, material: asset }, ["pattern", "material"]);
+          }
+        }, ["asset"]);
+      };
       fields(value, path, {
         ...common,
         skin: text,
         cape: (value2, path2) => {
           fields(value2, path2, { texture: text, layout: enumeration(["minecraft", "optifine", "labymod"]) }, ["texture"]);
         },
+        armor: (value2, path2) => {
+          fields(value2, path2, { head: piece, chest: piece, legs: piece, feet: piece });
+        },
         hiddenParts: list(enumeration(SKIN_PARTS)),
         pose: (value2, path2) => {
           fields(value2, path2, {
@@ -16826,10 +17250,11 @@ function validateObject(value, path) {
           });
         },
         options: (value2, path2) => {
-          fields(value2, path2, { slim: boolean, legacy: boolean });
+          fields(value2, path2, { slim: boolean, legacy: boolean, ears: boolean, upsideDown: boolean });
         }
       }, required);
       break;
+    }
     case "block":
       fields(value, path, {
         ...common,
@@ -16868,9 +17293,7 @@ function validateObject(value, path) {
             })
           });
         },
-        animation: (value2, path2) => {
-          fields(value2, path2, { name: text, loop: boolean, speed: nonnegative, time: nonnegative, paused: boolean }, ["name"]);
-        }
+        animation: entityAnimation
       }, [...required, "asset"]);
       if (Array.isArray(input.layers) && !input.layers.length) fail(`${path}.layers`, "expected at least one layer");
       break;
@@ -16978,7 +17401,7 @@ async function decodeSceneDocument(value) {
 }
 
 // src/scene/SceneDocumentLoader.ts
-var import_three40 = require("three");
+var import_three41 = require("three");
 init_AssetKey();
 init_AssetLoader();
 init_BlockStates();
@@ -17040,7 +17463,7 @@ var SceneDocumentLoader = class {
     if (definition.minecraftVersion !== void 0 && definition.minecraftVersion !== AssetLoader.version) {
       throw new Error(`Scene requires Minecraft ${definition.minecraftVersion}; call AssetLoader.setVersion("${definition.minecraftVersion}") before loading it`);
     }
-    const root = new import_three40.Group();
+    const root = new import_three41.Group();
     root.name = "MineRender scene document";
     const objects = [];
     let disposed = false;
@@ -17080,7 +17503,7 @@ var SceneDocumentLoader = class {
     return this.loadValidatedObject(scene, definition, parent);
   }
   static async loadValidatedObject(scene, definition, parent) {
-    const root = new import_three40.Group();
+    const root = new import_three41.Group();
     root.name = definition.name ?? definition.id;
     root.userData.sceneObjectId = definition.id;
     root.position.fromArray(definition.position ?? [0, 0, 0]);
@@ -17099,6 +17522,7 @@ var SceneDocumentLoader = class {
           await skin.setSkinTexture(texture);
           await content.initialize(skin);
           if (definition.cape) await skin.setCapeTexture(await skinTexture(definition.cape.texture, true), definition.cape.layout);
+          if (definition.armor) await skin.setArmor(definition.armor);
           for (const [part, rotation] of Object.entries(definition.pose ?? {})) {
             skin.getGroupByName(part)?.rotation.set(...rotation, "XYZ");
           }
@@ -17137,10 +17561,20 @@ var SceneDocumentLoader = class {
           const entity = await content.addEntity(model, { ...definition.options, instanceMeshes: false });
           object4 = entity;
           if (definition.animation) {
+            const animation = definition.animation;
             const animations = await Entities.getAnimations(key);
-            const clip = animations?.[definition.animation.name];
-            if (!clip) throw new Error(`Entity ${definition.asset} has no animation "${definition.animation.name}"`);
-            entity.playAnimation(clip, definition.animation);
+            if (animation.name !== void 0) {
+              const clip = animations && Object.prototype.hasOwnProperty.call(animations, animation.name) ? animations[animation.name] : void 0;
+              if (!clip) throw new Error(`Entity ${definition.asset} has no animation "${animation.name}"`);
+              entity.playAnimation(clip, animation);
+            } else {
+              const clips = animation.clips.map(({ name }) => {
+                const clip = animations && Object.prototype.hasOwnProperty.call(animations, name) ? animations[name] : void 0;
+                if (!clip) throw new Error(`Entity ${definition.asset} has no animation "${name}"`);
+                return clip;
+              });
+              entity.playAnimations(clips, { ...animation, weights: animation.clips.map((clip) => clip.weight ?? 1) });
+            }
           }
           break;
         }
@@ -17189,6 +17623,7 @@ init_Skins();
 
 // src/texture/index.ts
 init_Colormaps();
+init_PalettedTextures();
 init_TextureAtlas();
 init_TextureLoader();
 init_Textures();
@@ -17978,7 +18413,7 @@ var AnvilWorldSource = class {
     read.waiters++;
     return new Promise((resolve, reject) => {
       let finished = false;
-      const release2 = () => {
+      const release = () => {
         if (finished) return false;
         finished = true;
         signal?.removeEventListener("abort", abort);
@@ -17986,7 +18421,7 @@ var AnvilWorldSource = class {
         return true;
       };
       const abort = () => {
-        if (!release2()) return;
+        if (!release()) return;
         if (!read.waiters && !read.settled) {
           if (this.pending.get(key) === read) this.pending.delete(key);
           read.controller.abort(signal.reason);
@@ -17996,10 +18431,10 @@ var AnvilWorldSource = class {
       signal?.addEventListener("abort", abort, { once: true });
       read.promise.then(
         (data) => {
-          if (release2()) resolve(data);
+          if (release()) resolve(data);
         },
         (error) => {
-          if (release2()) reject(error);
+          if (release()) reject(error);
         }
       );
       if (signal?.aborted) abort();
@@ -18021,20 +18456,22 @@ var AnvilWorldSource = class {
 };
 
 // src/world/Chunk.ts
-var import_three47 = require("three");
+init_BlockObject();
+var import_three48 = require("three");
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
-var import_three45 = require("three");
+var import_three46 = require("three");
 init_Model();
 init_util();
 init_AssetKey();
 init_BlockStates();
+init_BlockEntities();
 init_CubeFace();
 
 // src/world/SectionModels.ts
-var import_three41 = require("three");
+var import_three42 = require("three");
 init_AssetKey();
 init_Models();
 init_CubeFace();
@@ -18060,7 +18497,7 @@ function cached(map, key, load) {
 }
 function compactQuads(geometry, keep) {
   const quads = keep.flatMap((kept, index) => kept ? [index] : []);
-  const compact = new import_three41.BufferGeometry();
+  const compact = new import_three42.BufferGeometry();
   for (const [name, size] of Object.entries({ position: 3, normal: 3, uv: 2, uvBounds: 4, color: 3, shade: 1 })) {
     const source2 = geometry.getAttribute(name);
     const defaults = name === "uvBounds" ? [0, 0, 1, 1] : name === "color" ? [1, 1, 1] : name === "shade" ? [1] : void 0;
@@ -18072,7 +18509,7 @@ function compactQuads(geometry, keep) {
         }
       }
     }
-    compact.setAttribute(name, new import_three41.BufferAttribute(values, size));
+    compact.setAttribute(name, new import_three42.BufferAttribute(values, size));
   }
   const source = geometry.getIndex();
   const indices = [];
@@ -18128,6 +18565,10 @@ var SectionModels = class {
       biomeTint: source ? [...templates.values()].some((template) => template.biomeTint?.some((value) => value === 1)) || void 0 : void 0
     };
   }
+  /** Starts loading the state's models and atlases so a later `prepareState` with the same properties finds them loaded. */
+  async preload(blockState3, properties = {}) {
+    await this.state(blockState3, properties);
+  }
   async state(blockState3, properties) {
     let states = this.states.get(blockState3);
     if (!states) this.states.set(blockState3, states = /* @__PURE__ */ new Map());
@@ -18150,22 +18591,24 @@ var SectionModels = class {
   async prepare(blockState3, properties) {
     const state = { ...await BlockStateResolver.defaults(blockState3), ...properties };
     const groups = BlockStateResolver.matching(blockState3, state);
-    if (!groups.length) return void 0;
+    if (!groups.length || groups.some((group) => Array.isArray(group) && !group.length)) return void 0;
+    const variants = groups.flatMap((group) => Array.isArray(group) ? group : [group]);
+    if (variants.some((variant) => !variant.model)) return void 0;
+    const settled = await Promise.allSettled(variants.map(async (variant) => {
+      const modelKey = AssetKey.parse("models", variant.model);
+      modelKey.root = blockState3.key?.root;
+      const model = await Models.getMerged(modelKey);
+      if (!model?.elements?.length) return void 0;
+      const atlas = await UVMapper.getAtlas(model);
+      const rotation = BlockStateResolver.rotation(variant);
+      if (!atlas || atlas.image.width > this.maxAtlasSize || atlas.image.height > this.maxAtlasSize) return void 0;
+      return { model, atlas, rotation };
+    }));
     const prepared = /* @__PURE__ */ new Map();
-    for (const group of groups) {
-      const choices = Array.isArray(group) ? group : [group];
-      if (!choices.length) return void 0;
-      for (const variant of choices) {
-        if (!variant.model) return void 0;
-        const modelKey = AssetKey.parse("models", variant.model);
-        modelKey.root = blockState3.key?.root;
-        const model = await Models.getMerged(modelKey);
-        if (!model?.elements?.length) return void 0;
-        const atlas = await UVMapper.getAtlas(model);
-        const rotation = BlockStateResolver.rotation(variant);
-        if (!atlas || atlas.image.width > this.maxAtlasSize || atlas.image.height > this.maxAtlasSize) return void 0;
-        prepared.set(variant, { model, atlas, rotation });
-      }
+    for (const [i, result] of settled.entries()) {
+      if (result.status === "rejected") throw result.reason;
+      if (!result.value) return void 0;
+      prepared.set(variants[i], result.value);
     }
     return { state, groups, choices: prepared };
   }
@@ -18182,7 +18625,7 @@ var SectionModels = class {
       });
       await object4.init();
       let geometry = object4.children[0].geometry;
-      geometry.applyMatrix4(new import_three41.Matrix4().makeRotationFromEuler(rotation));
+      geometry.applyMatrix4(new import_three42.Matrix4().makeRotationFromEuler(rotation));
       object4.clear();
       const keep = [];
       const cullFaces = [];
@@ -18198,7 +18641,7 @@ var SectionModels = class {
             cullFaces.push(0);
             continue;
           }
-          const normal = new import_three41.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const normal = new import_three42.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);
           cullFaces.push(world < 0 ? 0 : 1 << world);
         }
@@ -18302,10 +18745,10 @@ function resolveSavedEntity(entity) {
 
 // src/world/_entities/WorldEntities.ts
 init_BannerPatterns();
-var import_three44 = require("three");
+var import_three45 = require("three");
 
 // src/world/_picking/Picking.ts
-var import_three42 = require("three");
+var import_three43 = require("three");
 init_three();
 function pickableMeshes(root, scene, raycaster) {
   const result = [];
@@ -18333,11 +18776,11 @@ function hitNormal(hit) {
   const mesh = hit.object;
   const matrix = mesh.matrixWorld.clone();
   if (isInstancedMesh(mesh) && hit.instanceId !== void 0) {
-    const instance = new import_three42.Matrix4();
+    const instance = new import_three43.Matrix4();
     mesh.getMatrixAt(hit.instanceId, instance);
     matrix.multiply(instance);
   }
-  return hit.face.normal.clone().applyNormalMatrix(new import_three42.Matrix3().getNormalMatrix(matrix));
+  return hit.face.normal.clone().applyNormalMatrix(new import_three43.Matrix3().getNormalMatrix(matrix));
 }
 
 // src/world/_entities/WorldEntities.ts
@@ -18363,7 +18806,7 @@ var WorldEntities = class {
       const owner = owners.get(mesh);
       return {
         type: owner.type,
-        position: new import_three44.Vector3(...owner.position),
+        position: new import_three45.Vector3(...owner.position),
         object: owner.object,
         point: hit.point.clone(),
         normal: hitNormal(hit),
@@ -18625,6 +19068,7 @@ function skipsBlockFace(data, rule, block, neighbor, face) {
 // src/world/MineRenderWorld.ts
 init_log();
 var log18 = logger("MineRenderWorld");
+var YIELD_INTERVAL_MS = 8;
 var MineRenderWorld = class {
   constructor(scene, options = {}) {
     this._chunks = /* @__PURE__ */ new Map();
@@ -18738,7 +19182,7 @@ var MineRenderWorld = class {
             failures.set(chunk, error);
             if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) === chunk) this.pendingBiomes.set(chunk, void 0);
           }
-          if (performance.now() - sliceStart > 8) {
+          if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
             await yieldToEventLoop();
             sliceStart = performance.now();
           }
@@ -18751,25 +19195,25 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three45.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three46.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three45.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three46.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   getBiomeAt(posOrX, y, z) {
-    if (typeof posOrX === "number") return this.getBiomeAt(new import_three45.Vector3(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getBiomeAt(new import_three45.Vector3(...posOrX));
+    if (typeof posOrX === "number") return this.getBiomeAt(new import_three46.Vector3(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new import_three46.Vector3(...posOrX));
     this.validatePosBounds(posOrX);
     const cx = Math.floor(posOrX.x / 16), cy = Math.floor(posOrX.y / 16), cz = Math.floor(posOrX.z / 16);
     const lx = posOrX.x - cx * 16, ly = posOrX.y - cy * 16, lz = posOrX.z - cz * 16;
     return this.biomes.get(`${cx}_${cz}`)?.get(cy)?.[Math.floor(lx / 4) + Math.floor(lz / 4) * 4 + Math.floor(ly / 4) * 16];
   }
   getLightAt(posOrX, y, z) {
-    if (typeof posOrX === "number") return this.getLightAt(new import_three45.Vector3(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getLightAt(new import_three45.Vector3(...posOrX));
+    if (typeof posOrX === "number") return this.getLightAt(new import_three46.Vector3(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getLightAt(new import_three46.Vector3(...posOrX));
     this.validatePosBounds(posOrX);
     const { x, y: py, z: pz } = posOrX;
     const cx = Math.floor(x / 16), cy = Math.floor(py / 16), cz = Math.floor(pz / 16);
@@ -18787,10 +19231,10 @@ var MineRenderWorld = class {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three45.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three46.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three45.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three46.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -18801,10 +19245,10 @@ var MineRenderWorld = class {
   }
   async setBlockVisibleAt(posOrX, yOrVisible, z, visible) {
     if (typeof posOrX === "number") {
-      return this.setBlockVisibleAt(new import_three45.Vector3(posOrX, yOrVisible, z), visible);
+      return this.setBlockVisibleAt(new import_three46.Vector3(posOrX, yOrVisible, z), visible);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockVisibleAt(new import_three45.Vector3(...posOrX), yOrVisible);
+      return this.setBlockVisibleAt(new import_three46.Vector3(...posOrX), yOrVisible);
     }
     this.validatePosBounds(posOrX);
     await this.getChunkAt(posOrX)?.setBlockVisibleAt(posOrX, yOrVisible);
@@ -18830,7 +19274,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_three45.Vector3(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new import_three46.Vector3(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     const types = /* @__PURE__ */ new Set();
     for (const block of multiblock.blocks) {
@@ -18839,15 +19283,18 @@ var MineRenderWorld = class {
       const key = AssetKey.parse("blockstates", block.type);
       keys.set(key.serialize(), key);
     }
-    await BlockStates.getAll(keys.values());
+    const loaded = await BlockStates.getAll(keys.values());
+    const states = new Map([...keys.keys()].map((key, i) => [key, loaded[i]]));
     if (!useBatches) {
       for (const block of multiblock.blocks) await place(block);
       return;
     }
     if (!executor) {
       const groups2 = /* @__PURE__ */ new Map();
-      const position = new import_three45.Vector3();
+      const distinct = /* @__PURE__ */ new Map();
+      const position = new import_three46.Vector3();
       for (const block of multiblock.blocks) {
+        if (this.sectionModels && !Chunk.isAir(block)) distinct.set(ChunkData.paletteKey(block), block);
         const [x, y, z] = block.position;
         this.validatePosBounds(position.set(x, y, z));
         const cx = Math.floor(x / 16), cy = Math.floor(y / 16), cz = Math.floor(z / 16);
@@ -18858,6 +19305,16 @@ var MineRenderWorld = class {
         if (!group) groups2.set(chunk, group = []);
         group.push({ index: (y - cy * 16) * 256 + (z - cz * 16) * 16 + x - cx * 16, block });
       }
+      if (this.sectionModels) {
+        for (const block of distinct.values()) {
+          const state = states.get(AssetKey.parse("blockstates", block.type).serialize());
+          if (!state) continue;
+          void (async () => {
+            if (state.key && BlockEntities.entry(await BlockEntities.getIndex(state.key.root), state.key.toNamespacedString())) return;
+            await this.sectionModels.preload(state, block.properties);
+          })().catch(() => void 0);
+        }
+      }
       await this.placeChunkGroups(groups2, changes);
       return;
     }
@@ -18886,14 +19343,14 @@ var MineRenderWorld = class {
       try {
         positions = await chunk.placeBlocks(blocks);
       } finally {
-        positions ??= blocks.map(({ index }) => new import_three45.Vector3(
+        positions ??= blocks.map(({ index }) => new import_three46.Vector3(
           chunk.x * 16 + index % 16,
           chunk.y * 16 + Math.floor(index / 256),
           chunk.z * 16 + Math.floor(index / 16) % 16
         ));
         for (const pos of positions) changes.set(`${pos.x},${pos.y},${pos.z}`, pos);
       }
-      if (performance.now() - sliceStart > 8) {
+      if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
         await yieldToEventLoop();
         sliceStart = performance.now();
       }
@@ -18901,6 +19358,62 @@ var MineRenderWorld = class {
   }
   /** Replaces a chunk column's blocks, biomes, and saved light and, with `renderEntities`, its supported saved mobs. */
   async placeChunk(chunk, executor) {
+    return this.placeColumn(chunk, executor);
+  }
+  /**
+   * Replaces parsed columns in input order, then refreshes neighboring geometry once.
+   * Duplicate coordinates retain their order. A failed column stops placement; queued refreshes finish before rejection.
+   */
+  async placeChunks(chunks) {
+    const columns = [];
+    for (const chunk of chunks) {
+      const { x, z } = chunk ?? {};
+      if (![x, z].every(Number.isSafeInteger)) {
+        throw new RangeError("Chunk column coordinates must be safe integers");
+      }
+      const sections = Array.from(chunk.sections, (section) => {
+        const { y } = section ?? {};
+        if (!Number.isSafeInteger(y)) throw new RangeError("Chunk section coordinates must be safe integers");
+        return { ...section, y };
+      });
+      columns.push({ ...chunk, x, z, sections });
+    }
+    if (!columns.length) return;
+    await this.culling;
+    let failed = false, failure, sliceStart = performance.now();
+    try {
+      for (const column of columns) {
+        await this.placeColumn(column, void 0, true);
+        if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
+          await yieldToEventLoop();
+          sliceStart = performance.now();
+        }
+      }
+    } catch (error) {
+      failed = true;
+      failure = error;
+    } finally {
+      try {
+        const failures = await this.refreshBiomes(true);
+        if (failures.size) log18.warn("Failed to refresh biome colors", failures.values().next().value);
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+      try {
+        await this.updateCulling([]);
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+    }
+    if (failed) throw failure;
+  }
+  async placeColumn(chunk, executor, deferCulling = false) {
     if (![chunk.x, chunk.z].every(Number.isSafeInteger)) {
       throw new RangeError("Chunk column coordinates must be safe integers");
     }
@@ -18938,7 +19451,7 @@ var MineRenderWorld = class {
       }
       for (const section of chunk.sections) {
         if (section.biomes) {
-          const position = new import_three45.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
+          const position = new import_three46.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
           this.validatePosBounds(position);
           const copy = [...section.biomes];
           if (copy.length !== 64 || !copy.every((id) => typeof id === "string" && id.length > 0)) {
@@ -18954,7 +19467,7 @@ var MineRenderWorld = class {
       for (const section of chunk.sections) {
         if (!executor) {
           if (!occupiedSections.has(section.y)) continue;
-          const position = new import_three45.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
+          const position = new import_three46.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
           this.validatePosBounds(position);
           const target = this.getOrCreateChunkAt(position);
           try {
@@ -18962,7 +19475,7 @@ var MineRenderWorld = class {
           } finally {
             this.markSectionChanged(target);
           }
-          if (performance.now() - sliceStart > 8) {
+          if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
             await yieldToEventLoop();
             sliceStart = performance.now();
           }
@@ -18985,9 +19498,12 @@ var MineRenderWorld = class {
       await placeEntities?.();
     } finally {
       this.markBiomesChanged(chunk.x, chunk.z, void 0, false);
-      const failures = await this.refreshBiomes();
-      if (failures.size) log18.warn("Failed to refresh biome colors", failures.values().next().value);
-      await this.updateCulling([...changes.values()]);
+      if (deferCulling) await this.updateCulling([...changes.values()], true);
+      else {
+        const failures = await this.refreshBiomes();
+        if (failures.size) log18.warn("Failed to refresh biome colors", failures.values().next().value);
+        await this.updateCulling([...changes.values()]);
+      }
     }
   }
   /**
@@ -19017,7 +19533,7 @@ var MineRenderWorld = class {
       for (const { x, z } of columns.values()) {
         this.entities?.clearColumn(x, z);
         await this.clearChunkColumn(x, z);
-        if (performance.now() - sliceStart > 8) {
+        if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
           await yieldToEventLoop();
           sliceStart = performance.now();
         }
@@ -19087,7 +19603,7 @@ var MineRenderWorld = class {
     this.sectionModels?.clear();
   }
   updateCulling(positions, defer = false) {
-    const neighbor = new import_three45.Vector3();
+    const neighbor = new import_three46.Vector3();
     for (const pos of positions) {
       const cx = Math.floor(pos.x / 16), cy = Math.floor(pos.y / 16), cz = Math.floor(pos.z / 16);
       const chunk = this._chunks.get(`${cx}_${cy}_${cz}`);
@@ -19156,15 +19672,25 @@ var MineRenderWorld = class {
               for (const [index, mask] of masks) await chunk.setCullMaskIndex(index, mask);
               await chunk.refreshLight(indices === "all" ? void 0 : indices);
               chunk.refreshAmbientOcclusion(this._ambientOcclusion);
-              if ((this._ambientOcclusion || this.ambientOcclusionPending) && performance.now() - sliceStart > 8) {
+              if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
                 await yieldToEventLoop();
                 sliceStart = performance.now();
               }
             }
-            const builds = await Promise.allSettled([...batch.keys()].map(async (chunk) => {
-              await chunk.rebuildSectionMesh();
-              batch.delete(chunk);
-            }));
+            const pending = [];
+            for (const chunk of [...batch.keys()]) {
+              const build = (async () => {
+                await chunk.rebuildSectionMesh();
+                batch.delete(chunk);
+              })();
+              void build.catch(() => void 0);
+              pending.push(build);
+              if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
+                await yieldToEventLoop();
+                sliceStart = performance.now();
+              }
+            }
+            const builds = await Promise.allSettled(pending);
             const failure = builds.find((result) => result.status === "rejected");
             if (failure?.status === "rejected") throw failure.reason;
           } catch (error) {
@@ -19247,7 +19773,7 @@ var MineRenderWorld = class {
   }
   /** Converts block coordinates to scene units by multiplying each component by 16. */
   static worldToScenePosition(pos) {
-    return new import_three45.Vector3(
+    return new import_three46.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
@@ -19255,7 +19781,7 @@ var MineRenderWorld = class {
   }
   /** Converts scene units to block coordinates without rounding to an integer block. */
   static sceneToWorldPosition(pos) {
-    return new import_three45.Vector3(
+    return new import_three46.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -19279,7 +19805,7 @@ init_Model();
 init_BlockEntities();
 
 // src/world/SectionMesh.ts
-var import_three46 = require("three");
+var import_three47 = require("three");
 init_CanvasCompat();
 init_Materials();
 
@@ -19556,6 +20082,8 @@ function sectionGeometryTransferables(pages) {
 
 // src/world/SectionWorker.ts
 init_Env();
+init_log();
+var log19 = logger("SectionWorker");
 var SectionWorker = class _SectionWorker {
   constructor(worker) {
     this.worker = worker;
@@ -19569,8 +20097,12 @@ var SectionWorker = class _SectionWorker {
       if (reply.type === "pages") pending.resolve(reply.pages);
       else pending.reject(new Error(reply.message));
     });
-    worker.addEventListener("error", (event) => this.fail(event.message || "Section worker failed"));
-    worker.addEventListener("messageerror", () => this.fail("Section worker message could not be deserialized"));
+    const fallBack = (message) => {
+      log19.warn(`${message}, so sections build on the main thread`);
+      this.fail(message);
+    };
+    worker.addEventListener("error", (event) => fallBack(event.message || "Section worker failed"));
+    worker.addEventListener("messageerror", () => fallBack("Section worker message could not be deserialized"));
   }
   static {
     this.initialized = false;
@@ -19608,8 +20140,11 @@ var SectionWorker = class _SectionWorker {
 };
 
 // src/world/SectionMesh.ts
+var BLOCK_SIZE = 16;
+var QUAD_VERTICES = 4;
+var QUAD_INDICES = 6;
 var templateCache = /* @__PURE__ */ new WeakMap();
-var WATER_TINT = new import_three46.Color(4159204).toArray();
+var WATER_TINT = new import_three47.Color(4159204).toArray();
 function toInput(entries, maxAtlasSize, fluids, lighting) {
   if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
   const atlases2 = [];
@@ -19644,8 +20179,8 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
       if (!data) {
         const indices = template.geometry.getIndex();
         const position = template.geometry.getAttribute("position");
-        const quads = indices.count / 6;
-        if (indices.count % 6 !== 0 || position.count !== quads * 4) {
+        const quads = indices.count / QUAD_INDICES;
+        if (indices.count % QUAD_INDICES !== 0 || position.count !== quads * QUAD_VERTICES) {
           throw new RangeError("Section template geometry must hold four vertices and six indices per quad");
         }
         data = {
@@ -19655,8 +20190,8 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
           uvs: new Float32Array(quads * 8),
           uvBounds: new Float32Array(quads * 16),
           colors: new Float32Array(quads * 12),
-          shade: new Float32Array(quads * 4),
-          indices: new Uint16Array(quads * 6),
+          shade: new Float32Array(quads * QUAD_VERTICES),
+          indices: new Uint16Array(quads * QUAD_INDICES),
           cullFaces: new Uint8Array(template.cullFaces),
           biomeTint: template.biomeTint ? new Uint8Array(template.biomeTint) : void 0,
           atlas: 0,
@@ -19668,7 +20203,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
         const bounds = template.geometry.getAttribute("uvBounds");
         const color2 = template.geometry.getAttribute("color");
         const shade = template.geometry.getAttribute("shade");
-        for (let vertex = 0; vertex < quads * 4; vertex++) {
+        for (let vertex = 0; vertex < quads * QUAD_VERTICES; vertex++) {
           data.positions.set([position.getX(vertex), position.getY(vertex), position.getZ(vertex)], vertex * 3);
           data.normals.set([normal.getX(vertex), normal.getY(vertex), normal.getZ(vertex)], vertex * 3);
           data.uvs.set([uv.getX(vertex), uv.getY(vertex)], vertex * 2);
@@ -19681,7 +20216,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
           data.colors.set([color2?.getX(vertex) ?? 1, color2?.getY(vertex) ?? 1, color2?.getZ(vertex) ?? 1], vertex * 3);
           data.shade[vertex] = shade?.getX(vertex) ?? 1;
         }
-        for (let i2 = 0; i2 < data.indices.length; i2++) data.indices[i2] = indices.getX(i2) - 4 * Math.floor(i2 / 6);
+        for (let i2 = 0; i2 < data.indices.length; i2++) data.indices[i2] = indices.getX(i2) - QUAD_VERTICES * Math.floor(i2 / QUAD_INDICES);
         templateCache.set(template, data);
       }
       id = input.templateData.length;
@@ -19714,7 +20249,55 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
   }
   return { input, atlases: atlases2 };
 }
-var SectionMesh = class _SectionMesh extends import_three46.Group {
+function sortTransparentQuads(mesh) {
+  const index = mesh.geometry.getIndex();
+  if (index.count <= QUAD_INDICES) return;
+  index.setUsage(import_three47.DynamicDrawUsage);
+  const count = index.count / QUAD_INDICES;
+  let source, centers, depths, order;
+  const view = new import_three47.Matrix4(), localCamera = new import_three47.Vector3(), key = new import_three47.Vector3(), previous = new import_three47.Vector3();
+  let previousOrthographic;
+  mesh.onBeforeRender = (_renderer, _scene, camera) => {
+    localCamera.setFromMatrixPosition(camera.matrixWorld).applyMatrix4(view.copy(mesh.matrixWorld).invert());
+    const orthographic = !!camera.isOrthographicCamera;
+    if (orthographic) {
+      view.multiplyMatrices(camera.matrixWorldInverse, mesh.matrixWorld);
+      key.set(view.elements[2], view.elements[6], view.elements[10]);
+    } else {
+      key.copy(localCamera).divideScalar(BLOCK_SIZE).floor();
+    }
+    if (orthographic === previousOrthographic && key.equals(previous)) return;
+    previous.copy(key);
+    previousOrthographic = orthographic;
+    if (!centers) {
+      source = new Uint32Array(index.array);
+      centers = new Float32Array(count * 3);
+      depths = new Float32Array(count);
+      order = Uint32Array.from({ length: count }, (_, quad) => quad);
+      const positions = mesh.geometry.getAttribute("position");
+      for (let quad = 0; quad < count; quad++) {
+        for (let axis = 0; axis < 3; axis++) {
+          let center = 0;
+          for (let corner = 0; corner < QUAD_VERTICES; corner++) center += positions.getComponent(quad * QUAD_VERTICES + corner, axis);
+          centers[quad * 3 + axis] = center / QUAD_VERTICES;
+        }
+      }
+    }
+    for (let quad = 0; quad < count; quad++) {
+      const x = centers[quad * 3], y = centers[quad * 3 + 1], z = centers[quad * 3 + 2];
+      depths[quad] = orthographic ? key.x * x + key.y * y + key.z * z : -((x - localCamera.x) ** 2 + (y - localCamera.y) ** 2 + (z - localCamera.z) ** 2);
+    }
+    order.sort((a, b) => depths[a] - depths[b] || a - b);
+    if (!order.some((quad, offset) => index.array[offset * QUAD_INDICES] !== source[quad * QUAD_INDICES])) return;
+    for (let offset = 0; offset < count; offset++) {
+      for (let indexOffset = 0; indexOffset < QUAD_INDICES; indexOffset++) {
+        index.array[offset * QUAD_INDICES + indexOffset] = source[order[offset] * QUAD_INDICES + indexOffset];
+      }
+    }
+    index.needsUpdate = true;
+  };
+}
+var SectionMesh = class _SectionMesh extends import_three47.Group {
   constructor() {
     super(...arguments);
     this.ownedMeshes = [];
@@ -19723,7 +20306,11 @@ var SectionMesh = class _SectionMesh extends import_three46.Group {
   /** Returns the owning section cell for a triangle hit on this mesh's merged geometry. */
   getBlockIndex(hit) {
     if (hit.faceIndex === void 0 || hit.faceIndex === null) return void 0;
-    return this.blockIndices.get(hit.object)?.[Math.floor(hit.faceIndex / 2)];
+    const mesh = hit.object;
+    const owners = this.blockIndices.get(mesh);
+    if (!owners) return void 0;
+    const vertex = mesh.geometry.getIndex().getX(hit.faceIndex * 3);
+    return owners[Math.floor(vertex / QUAD_VERTICES)];
   }
   /** Builds section-local meshes from visible quads. `maxAtlasSize` limits each atlas dimension in pixels. */
   static build(entries, maxAtlasSize = 2048, fluids, lighting) {
@@ -19745,27 +20332,28 @@ var SectionMesh = class _SectionMesh extends import_three46.Group {
       for (const { atlas, x, y } of page.placements) {
         context.drawImage(atlases2[atlas].image.canvas, x, y);
       }
-      const geometry = new import_three46.BufferGeometry();
-      geometry.setAttribute("position", new import_three46.Float32BufferAttribute(page.positions.buffer, 3));
-      geometry.setAttribute("normal", new import_three46.Float32BufferAttribute(page.normals.buffer, 3));
-      geometry.setAttribute("uv", new import_three46.Float32BufferAttribute(page.uvs.buffer, 2));
-      geometry.setAttribute("uvBounds", new import_three46.Float32BufferAttribute(page.uvBounds.buffer, 4));
-      geometry.setAttribute("color", new import_three46.Float32BufferAttribute(page.colors.buffer, 3));
-      geometry.setAttribute("shade", new import_three46.Float32BufferAttribute(page.shade.buffer, 1));
-      geometry.setIndex(new import_three46.Uint32BufferAttribute(page.indices.buffer, 1));
+      const geometry = new import_three47.BufferGeometry();
+      geometry.setAttribute("position", new import_three47.Float32BufferAttribute(page.positions.buffer, 3));
+      geometry.setAttribute("normal", new import_three47.Float32BufferAttribute(page.normals.buffer, 3));
+      geometry.setAttribute("uv", new import_three47.Float32BufferAttribute(page.uvs.buffer, 2));
+      geometry.setAttribute("uvBounds", new import_three47.Float32BufferAttribute(page.uvBounds.buffer, 4));
+      geometry.setAttribute("color", new import_three47.Float32BufferAttribute(page.colors.buffer, 3));
+      geometry.setAttribute("shade", new import_three47.Float32BufferAttribute(page.shade.buffer, 1));
+      geometry.setIndex(new import_three47.Uint32BufferAttribute(page.indices.buffer, 1));
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
       const transparent = page.layer === 2 ? atlases2[page.placements[0].atlas].hasTranslucency : page.layer === 1;
       const material = Materials.createShadedCanvasMaterial(canvas, transparent, false, true);
-      material.side = import_three46.FrontSide;
+      material.side = import_three47.FrontSide;
       if (page.layer === 2) {
-        material.side = import_three46.DoubleSide;
-        material.forceSinglePass = true;
         material.depthWrite = !material.transparent;
+        material.side = import_three47.DoubleSide;
+        material.forceSinglePass = true;
       }
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
-      const mesh = new import_three46.Mesh(geometry, material);
+      const mesh = new import_three47.Mesh(geometry, material);
+      if (transparent) sortTransparentQuads(mesh);
       section.add(mesh);
       section.blockIndices.set(mesh, page.blockIndices);
       const unsubscribe = [];
@@ -19806,7 +20394,7 @@ init_CubeFace();
 init_BlockTints();
 init_Biomes();
 init_InstanceReference();
-var WATER_TINT2 = new import_three47.Color(4159204).toArray();
+var WATER_TINT2 = new import_three48.Color(4159204).toArray();
 var Chunk = class _Chunk {
   constructor(scene, x, y, z, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0, biomeBlend) {
     this.onBlocksChanged = onBlocksChanged;
@@ -19824,7 +20412,7 @@ var Chunk = class _Chunk {
     this.sectionBlocks = /* @__PURE__ */ new Map();
     this.hiddenBlocks = /* @__PURE__ */ new Set();
     this.fluidCells = new Uint8Array(4096);
-    this.blockPosition = new import_three47.Vector3();
+    this.blockPosition = new import_three48.Vector3();
     this.meshDirty = false;
     this.meshGeneration = 0;
     this.blockChanges = /* @__PURE__ */ new Set();
@@ -19884,7 +20472,7 @@ var Chunk = class _Chunk {
       const info = owner.chunk.renderedBlocks.get(owner.index);
       if (!info) continue;
       return {
-        position: new import_three47.Vector3(
+        position: new import_three48.Vector3(
           owner.chunk.x * 16 + owner.index % 16,
           owner.chunk.y * 16 + Math.floor(owner.index / 256),
           owner.chunk.z * 16 + Math.floor(owner.index / 16) % 16
@@ -19899,18 +20487,18 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three47.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three48.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three47.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three48.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.blockPosition.set(posOrX.x - this.x * 16, posOrX.y - this.y * 16, posOrX.z - this.z * 16);
     const index = _Chunk.chunkPosToBlockIndex(pos);
     return this.renderedBlocks.get(index);
   }
   getBiomeAt(posOrX, y, z) {
-    if (typeof posOrX === "number") return this.getBiomeAt(new import_three47.Vector3(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getBiomeAt(new import_three47.Vector3(...posOrX));
+    if (typeof posOrX === "number") return this.getBiomeAt(new import_three48.Vector3(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new import_three48.Vector3(...posOrX));
     const pos = this.worldPosToChunkPos(posOrX);
     _Chunk.chunkPosToBlockIndex(pos);
     return this.biomeAt ? this.biomeAt(posOrX.x, posOrX.y, posOrX.z) : this.biomes?.[Math.floor(pos.x / 4) + Math.floor(pos.z / 4) * 4 + Math.floor(pos.y / 4) * 16];
@@ -19988,17 +20576,17 @@ var Chunk = class _Chunk {
         this.hiddenBlocks.add(index);
         this.renderedBlocks.get(index)?.object?.setVisible(false);
       }
-      const positions = blocks.map(({ index }) => new import_three47.Vector3(...this.positionAt(index)));
+      const positions = blocks.map(({ index }) => new import_three48.Vector3(...this.positionAt(index)));
       if (this.onBlocksChanged) await this.onBlocksChanged(positions, deferCulling);
       else await this.rebuildSectionMesh();
     }
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three47.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three48.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three47.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three48.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -20060,8 +20648,10 @@ var Chunk = class _Chunk {
       if (rejected?.status === "rejected") throw rejected.reason;
     }
     const positions = [];
-    let failed = false, failure;
-    for (const { index, key, block } of placements) {
+    const jobs = /* @__PURE__ */ new Map();
+    let failureOrder = Infinity, failure;
+    for (const [order, { index, key, block }] of placements.entries()) {
+      jobs.delete(index);
       this.hiddenBlocks.delete(index);
       this.data.assign(index, this.data.intern(block), block?.nbt);
       const readBlock = this.data.snapshot(index);
@@ -20071,13 +20661,12 @@ var Chunk = class _Chunk {
       this.fluidCells[index] = 0;
       this.renderedBlocks.delete(index);
       this.objectBlocks.delete(index);
-      const worldPos = new import_three47.Vector3(
+      const worldPos = new import_three48.Vector3(
         this.x * 16 + index % 16,
         this.y * 16 + Math.floor(index / 256),
         this.z * 16 + Math.floor(index / 16) % 16
       );
       positions.push(worldPos);
-      let object4;
       try {
         if (!readBlock) continue;
         const resolved = resolutions.get(key);
@@ -20099,7 +20688,7 @@ var Chunk = class _Chunk {
           this.sectionBlocks.set(index, templates.map((template) => ({ index, template, cullMask: 0, biomeTint: context?.tint })));
           this.meshDirty = true;
         } else {
-          object4 = await this.scene.addBlock(blockState3, {
+          jobs.set(index, { order, readBlock, blockState: blockState3, position: MineRenderWorld.worldToScenePosition(worldPos), options: {
             mergeMeshes: true,
             instanceMeshes: true,
             maxInstanceCount: 2e3,
@@ -20107,13 +20696,12 @@ var Chunk = class _Chunk {
             variantPosition,
             biome: context?.biome,
             biomePosition: this.biomePosition(index, blockState3, stored)
-          });
-          object4.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
+          } });
+          continue;
         }
         this.renderedBlocks.set(index, { get block() {
           return readBlock();
-        }, object: object4 });
-        if (object4) this.objectBlocks.add(index);
+        }, object: void 0 });
       } catch (error) {
         if (preserveDataOnFailure && readBlock) {
           this.renderedBlocks.set(index, { get block() {
@@ -20121,12 +20709,35 @@ var Chunk = class _Chunk {
           }, object: void 0 });
         } else this.data.assign(index, 0);
         this.fluidCells[index] = 0;
-        object4?.removeFromScene();
-        if (!failed) failure = error;
-        failed = true;
+        if (order < failureOrder) {
+          failureOrder = order;
+          failure = error;
+        }
       }
     }
-    if (failed) throw failure;
+    const pending = [...jobs];
+    const objects = await Promise.allSettled(pending.map(([, job]) => this.createBlockObject(job.blockState, job.position, job.options)));
+    for (const [i, [index, { order, readBlock }]] of pending.entries()) {
+      const result = objects[i];
+      if (result.status === "fulfilled") {
+        this.renderedBlocks.set(index, { get block() {
+          return readBlock();
+        }, object: result.value });
+        this.objectBlocks.add(index);
+      } else {
+        if (preserveDataOnFailure) {
+          this.renderedBlocks.set(index, { get block() {
+            return readBlock();
+          }, object: void 0 });
+        } else this.data.assign(index, 0);
+        this.fluidCells[index] = 0;
+        if (order < failureOrder) {
+          failureOrder = order;
+          failure = result.reason;
+        }
+      }
+    }
+    if (failureOrder < Infinity) throw failure;
     return positions;
   }
   /** Replaces every cell from parsed section data. The caller refreshes neighbor culling. */
@@ -20197,37 +20808,42 @@ var Chunk = class _Chunk {
         failed = true;
       }
     }
-    for (const { index, blockState: blockState3, biome } of perBlocks) {
-      let object4;
-      try {
-        object4 = await this.scene.addBlock(blockState3, {
-          mergeMeshes: true,
-          instanceMeshes: true,
-          maxInstanceCount: 2e3,
-          initialState: this.data.stateAt(this.data.idAt(index)).properties,
-          variantPosition: this.positionAt(index),
-          biome,
-          biomePosition: this.biomePosition(index, blockState3, this.data.stateAt(this.data.idAt(index)))
-        });
-        object4.setPosition(new import_three47.Vector3(
-          this.x * 256 + index % 16 * 16,
-          this.y * 256 + Math.floor(index / 256) * 16,
-          this.z * 256 + Math.floor(index / 16) % 16 * 16
-        ));
-        this.renderedBlocks.get(index).object = object4;
+    const objects = await Promise.allSettled(perBlocks.map(({ index, blockState: blockState3, biome }) => this.createBlockObject(blockState3, new import_three48.Vector3(
+      this.x * 256 + index % 16 * 16,
+      this.y * 256 + Math.floor(index / 256) * 16,
+      this.z * 256 + Math.floor(index / 16) % 16 * 16
+    ), {
+      mergeMeshes: true,
+      instanceMeshes: true,
+      maxInstanceCount: 2e3,
+      initialState: this.data.stateAt(this.data.idAt(index)).properties,
+      variantPosition: this.positionAt(index),
+      biome,
+      biomePosition: this.biomePosition(index, blockState3, this.data.stateAt(this.data.idAt(index)))
+    })));
+    for (const [i, { index }] of perBlocks.entries()) {
+      const result = objects[i];
+      if (result.status === "fulfilled") {
+        this.renderedBlocks.get(index).object = result.value;
         this.objectBlocks.add(index);
-      } catch (error) {
+      } else {
         this.data.assign(index, 0);
         this.fluidCells[index] = 0;
         this.renderedBlocks.delete(index);
         this.objectBlocks.delete(index);
-        object4?.removeFromScene();
-        if (!failed) failure = error;
+        if (!failed) failure = result.reason;
         failed = true;
       }
     }
     if (failed) throw failure;
   }
+  createBlockObject(blockState3, position, options) {
+    return this.scene.addSceneObject(blockState3, () => {
+      const object4 = new BlockObject(blockState3, options);
+      object4.position.copy(position);
+      return object4;
+    }, options);
+  }
   positionAt(index) {
     return [this.x * 16 + index % 16, this.y * 16 + Math.floor(index / 256), this.z * 16 + Math.floor(index / 16) % 16];
   }
@@ -20282,11 +20898,11 @@ var Chunk = class _Chunk {
           const context = {};
           if (source && prepared2?.biomeTint) {
             const color2 = await biomeColor(source);
-            if (color2 !== void 0) context.tint = new import_three47.Color(color2).toArray();
+            if (color2 !== void 0) context.tint = new import_three48.Color(color2).toArray();
           }
           if (fluid?.kind === "water") {
             const color2 = await biomeColor("water");
-            if (color2 !== void 0 && color2 !== 4159204) context.waterTint = new import_three47.Color(color2).toArray();
+            if (color2 !== void 0 && color2 !== 4159204) context.waterTint = new import_three48.Color(color2).toArray();
           }
           contexts.set(index, context);
         }));
@@ -20324,7 +20940,7 @@ var Chunk = class _Chunk {
         context.prepared = await prepare(async () => await available() ? BlockTints.getBiomeColor(blockState3?.key, biome, position) : void 0);
         if (fluid?.kind === "water" && await available()) {
           const color2 = await Biomes.getColor(biome, "water", blockState3?.key);
-          if (color2 !== void 0 && color2 !== 4159204) context.waterTint = new import_three47.Color(color2).toArray();
+          if (color2 !== void 0 && color2 !== 4159204) context.waterTint = new import_three48.Color(color2).toArray();
         }
       }
       for (const index of indices2) contexts.set(index, context);
@@ -20516,7 +21132,7 @@ var Chunk = class _Chunk {
   async clear(notify = true) {
     if (this.blockChanges.size) await Promise.allSettled(this.blockChanges);
     const positions = notify && this.onBlocksChanged ? [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new import_three47.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new import_three48.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();
@@ -20552,14 +21168,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three47.Vector3(
+    return new import_three48.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three47.Vector3(
+    return new import_three48.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z
@@ -20568,6 +21184,7 @@ var Chunk = class _Chunk {
 };
 
 // src/world/WorldStreamer.ts
+var MAX_PREFETCHED_COLUMNS = 4;
 var WorldStreamer = class {
   constructor(world, source, options = {}) {
     this.world = world;
@@ -20577,6 +21194,7 @@ var WorldStreamer = class {
     this.missing = /* @__PURE__ */ new Map();
     this.failed = /* @__PURE__ */ new Map();
     this.desired = [];
+    this.reads = /* @__PURE__ */ new Map();
     this.disposed = false;
     this.loadRadius = options.loadRadius ?? 2;
     this.unloadRadius = options.unloadRadius ?? Math.min(32, this.loadRadius + 1);
@@ -20621,6 +21239,12 @@ var WorldStreamer = class {
       if (this.loading && !this.within(this.loading.position, this.loadRadius)) {
         this.loading.controller.abort();
       }
+      for (const [key, read] of this.reads) {
+        if (!this.within(read.position, this.loadRadius)) {
+          read.controller.abort();
+          if (read.ready) this.reads.delete(key);
+        }
+      }
     }
     return this.running ??= Promise.resolve().then(() => this.drain());
   }
@@ -20641,8 +21265,11 @@ var WorldStreamer = class {
     this.desired = [];
     this.center = void 0;
     this.loading?.controller.abort();
+    for (const read of this.reads.values()) read.controller.abort();
     return this.disposal ??= Promise.resolve().then(async () => {
       await this.running?.catch(() => void 0);
+      await Promise.all([...this.reads.values()].map((read) => read.promise));
+      this.reads.clear();
       try {
         await this.unloadMany([...this.owned.values()]);
       } finally {
@@ -20668,6 +21295,10 @@ var WorldStreamer = class {
           await this.unloadMany(obsolete);
           continue;
         }
+        if (this.world.placeChunks) {
+          if (await this.placeReadyChunks()) continue;
+          return;
+        }
         const position = this.desired.find((position2) => this.needsLoad(position2));
         if (!position) return;
         let chunk;
@@ -20690,26 +21321,105 @@ var WorldStreamer = class {
           continue;
         }
         this.owned.set(this.key(position), position);
+        await this.placeOwnedColumns([position], () => this.world.placeChunk(chunk));
+      }
+    } finally {
+      for (const [key, read] of this.reads) {
+        read.controller.abort();
+        if (read.ready) this.reads.delete(key);
+      }
+      this.running = void 0;
+    }
+  }
+  fillReadSlots() {
+    while (!this.disposed && this.reads.size < MAX_PREFETCHED_COLUMNS) {
+      const position = this.desired.find((position2) => this.needsLoad(position2) && !this.reads.has(this.key(position2)));
+      if (!position) return;
+      const key = this.key(position);
+      const read = {
+        position,
+        controller: new AbortController(),
+        promise: Promise.resolve(),
+        ready: false,
+        failed: false
+      };
+      this.reads.set(key, read);
+      read.promise = (async () => {
         try {
-          await this.world.placeChunk(chunk);
-          this.loaded.set(this.key(position), position);
+          read.chunk = await this.source.getChunk(position.x, position.z, read.controller.signal);
+          if (read.chunk) this.validateChunk(read.chunk, position);
         } catch (error) {
-          try {
-            await this.unloadMany([position]);
-          } catch (cleanupError) {
-            const failure = error instanceof Error ? error : new Error(String(error));
-            try {
-              Object.defineProperty(failure, "cause", { value: cleanupError, configurable: true });
-            } catch {
-              throw Object.assign(new Error(failure.message), { cause: cleanupError });
-            }
-            throw failure;
+          read.failed = true;
+          read.error = error;
+        } finally {
+          read.ready = true;
+          if (read.controller.signal.aborted || this.disposed || !this.within(position, this.loadRadius)) {
+            this.reads.delete(key);
           }
-          throw error;
+        }
+      })();
+    }
+  }
+  /** Places only the ready prefix, so later source reads cannot delay the nearest ready column. */
+  async placeReadyChunks() {
+    this.fillReadSlots();
+    const position = this.desired.find((position2) => this.needsLoad(position2));
+    if (!position) {
+      if (!this.reads.size) return false;
+      await Promise.all([...this.reads.values()].map((read) => read.promise));
+      return true;
+    }
+    const head = this.reads.get(this.key(position));
+    if (!head) {
+      for (let index = this.desired.length - 1; index >= 0; index--) {
+        const key = this.key(this.desired[index]);
+        if (this.reads.get(key)?.ready) {
+          this.reads.delete(key);
+          return true;
         }
       }
-    } finally {
-      this.running = void 0;
+      await Promise.race([...this.reads.values()].map((read) => read.promise));
+      return true;
+    }
+    if (!head.ready) {
+      await head.promise;
+      return true;
+    }
+    const chunks = [], positions = [];
+    for (const desired of this.desired) {
+      if (!this.needsLoad(desired)) continue;
+      const key = this.key(desired), read = this.reads.get(key);
+      if (!read?.ready) break;
+      this.reads.delete(key);
+      if (read.failed) this.failed.set(key, { ...desired, error: read.error });
+      else if (!read.chunk) this.missing.set(key, desired);
+      else {
+        chunks.push(read.chunk);
+        positions.push(desired);
+      }
+    }
+    if (!chunks.length) return true;
+    for (const position2 of positions) this.owned.set(this.key(position2), position2);
+    await this.placeOwnedColumns(positions, () => this.world.placeChunks(chunks));
+    return true;
+  }
+  async placeOwnedColumns(positions, place) {
+    try {
+      await place();
+      for (const position of positions) this.loaded.set(this.key(position), position);
+    } catch (error) {
+      try {
+        await this.unloadMany(positions);
+      } catch (cleanupError) {
+        const failure = error instanceof Error ? error : new Error(String(error));
+        try {
+          Object.defineProperty(failure, "cause", { value: cleanupError, configurable: true });
+        } catch {
+          throw Object.assign(new Error(failure.message), { cause: cleanupError });
+        }
+        throw failure;
+      }
+      throw error;
     }
   }
   needsLoad(position) {
@@ -20911,6 +21621,7 @@ var NodeRenderer = class _NodeRenderer extends Renderer {
   AnvilParser,
   AnvilWorldSource,
   ArchiveAssetSource,
+  Armor,
   AssetKey,
   AssetLoadError,
   AssetLoader,
@@ -20994,6 +21705,7 @@ var NodeRenderer = class _NodeRenderer extends Renderer {
   OrbitControls,
   PackFormats,
   PackMetadata,
+  PalettedTextures,
   PersistentCache,
   PlayerHeadTextures,
   Renames,