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

package/dist/node/index.mjs

@@ -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();
@@ -242,6 +240,10 @@ var Caching;
 var init_Caching = __esm({
   "src/cache/Caching.ts"() {
     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;
       }
@@ -309,6 +311,9 @@ var init_Caching = __esm({
       static {
         this.blockEntityIndexCache = _Caching.createAssetCache();
       }
+      static {
+        this.entityDatasetVersionCache = _Caching.createAssetCache();
+      }
       static {
         this.unihexCache = _Caching.createAssetCache();
       }
@@ -318,6 +323,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();
       }
@@ -353,9 +364,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
@@ -2403,15 +2417,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() {
@@ -3331,23 +3351,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) {
@@ -3377,9 +3677,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`);
           }
@@ -3391,14 +3691,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) {
@@ -3730,22 +4028,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({
@@ -4526,6 +4808,7 @@ var log9, BlockEntities;
 var init_BlockEntities = __esm({
   "src/assets/BlockEntities.ts"() {
     init_AssetKey();
+    init_Entities();
     init_AssetLoader();
     init_source();
     init_Caching();
@@ -4542,6 +4825,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);
@@ -4627,136 +4911,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, {
@@ -5896,6 +6050,266 @@ var init_model = __esm({
   }
 });
 
+// src/model/ItemGlint.ts
+var ItemGlint_exports = {};
+__export(ItemGlint_exports, {
+  ItemGlint: () => ItemGlint
+});
+import { ClampToEdgeWrapping, CustomBlending as CustomBlending2, DoubleSide as DoubleSide2, EqualDepth, Float32BufferAttribute as Float32BufferAttribute3, LinearFilter, Mesh as Mesh4, OneFactor as OneFactor2, RepeatWrapping as RepeatWrapping2, ShaderMaterial as ShaderMaterial2, SrcColorFactor, Vector2 as Vector22, ZeroFactor } from "three";
+var ItemGlint;
+var init_ItemGlint = __esm({
+  "src/model/ItemGlint.ts"() {
+    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 ? ClampToEdgeWrapping : RepeatWrapping2;
+            if (metadata?.texture?.blur) texture2.magFilter = texture2.minFilter = LinearFilter;
+            return texture2;
+          });
+        }
+        const material = new ShaderMaterial2({
+          name: "item-glint",
+          transparent: true,
+          depthWrite: false,
+          depthFunc: EqualDepth,
+          side: DoubleSide2,
+          forceSinglePass: true,
+          blending: CustomBlending2,
+          blendSrc: SrcColorFactor,
+          blendDst: OneFactor2,
+          blendSrcAlpha: ZeroFactor,
+          blendDstAlpha: OneFactor2,
+          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 Vector22() },
+            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 Mesh4(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 Float32BufferAttribute3(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 Float32BufferAttribute3(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, {
@@ -5906,7 +6320,7 @@ import { Color as Color3, Object3D as Object3D3 } from "three";
 function isEntityObject(obj) {
   return obj.isEntityObject;
 }
-var EntityObject;
+var ItemGlintClass, PalettedTexturesClass, EntityObject;
 var init_EntityObject = __esm({
   "src/entity/scene/EntityObject.ts"() {
     init_SceneObject();
@@ -5936,8 +6350,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);
@@ -5951,12 +6371,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();
@@ -6115,6 +6549,10 @@ 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) {
@@ -6187,10 +6625,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 Color3(tint).getHexString()}:${assetKeyStr}`;
+          const keyStr = `entity:${mode}:${tint === void 0 ? "" : new Color3(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);
@@ -6228,13 +6666,13 @@ __export(GLTFExporter_exports, {
 });
 import {
   BufferAttribute as BufferAttribute3,
-  ClampToEdgeWrapping,
+  ClampToEdgeWrapping as ClampToEdgeWrapping2,
   Color as Color6,
-  DoubleSide as DoubleSide2,
+  DoubleSide as DoubleSide3,
   InterpolateDiscrete,
   InterpolateLinear,
   NoColorSpace,
-  LinearFilter,
+  LinearFilter as LinearFilter2,
   LinearMipmapLinearFilter,
   LinearMipmapNearestFilter,
   MathUtils,
@@ -6245,7 +6683,7 @@ import {
   NearestMipmapNearestFilter,
   PropertyBinding,
   RGBAFormat as RGBAFormat2,
-  RepeatWrapping as RepeatWrapping2,
+  RepeatWrapping as RepeatWrapping3,
   Scene as Scene2,
   SRGBColorSpace as SRGBColorSpace5,
   TextureSource,
@@ -6514,11 +6952,11 @@ var init_GLTFExporter = __esm({
     THREE_TO_WEBGL[NearestFilter2] = WEBGL_CONSTANTS.NEAREST;
     THREE_TO_WEBGL[NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
     THREE_TO_WEBGL[NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
-    THREE_TO_WEBGL[LinearFilter] = WEBGL_CONSTANTS.LINEAR;
+    THREE_TO_WEBGL[LinearFilter2] = WEBGL_CONSTANTS.LINEAR;
     THREE_TO_WEBGL[LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
     THREE_TO_WEBGL[LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
-    THREE_TO_WEBGL[ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
-    THREE_TO_WEBGL[RepeatWrapping2] = WEBGL_CONSTANTS.REPEAT;
+    THREE_TO_WEBGL[ClampToEdgeWrapping2] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
+    THREE_TO_WEBGL[RepeatWrapping3] = WEBGL_CONSTANTS.REPEAT;
     THREE_TO_WEBGL[MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
     PATH_PROPERTIES = {
       scale: "scale",
@@ -7268,7 +7706,7 @@ var init_GLTFExporter = __esm({
             materialDef.alphaCutoff = material.alphaTest;
           }
         }
-        if (material.side === DoubleSide2) materialDef.doubleSided = true;
+        if (material.side === DoubleSide3) materialDef.doubleSided = true;
         if (material.name !== "") materialDef.name = material.name;
         this.serializeUserData(material, materialDef);
         await this._invokeAllAsync(async function(ext) {
@@ -8337,7 +8775,7 @@ var init_GLTFExporter = __esm({
 });
 
 // src/gui/GuiText.ts
-import { BufferGeometry as BufferGeometry2, Color as Color8, Float32BufferAttribute as Float32BufferAttribute4 } from "three";
+import { BufferGeometry as BufferGeometry2, Color as Color8, Float32BufferAttribute as Float32BufferAttribute5 } from "three";
 async function layoutGuiText(text2, options = {}) {
   const maxWidth = options.maxWidth ?? Infinity, lineHeight = options.lineHeight ?? 9;
   if (!(maxWidth > 0) || !Number.isFinite(lineHeight) || lineHeight <= 0) {
@@ -8441,7 +8879,7 @@ function createGuiTextGeometry(layout, shadow = true) {
       }
     }
   }
-  return batches.map(({ image, positions, uvs, colors: colors2, indices }) => ({ image, geometry: new BufferGeometry2().setAttribute("position", new Float32BufferAttribute4(positions, 3)).setAttribute("uv", new Float32BufferAttribute4(uvs, 2)).setAttribute("color", new Float32BufferAttribute4(colors2, 3)).setIndex(indices) }));
+  return batches.map(({ image, positions, uvs, colors: colors2, indices }) => ({ image, geometry: new BufferGeometry2().setAttribute("position", new Float32BufferAttribute5(positions, 3)).setAttribute("uv", new Float32BufferAttribute5(uvs, 2)).setAttribute("color", new Float32BufferAttribute5(colors2, 3)).setIndex(indices) }));
 }
 var init_GuiText = __esm({
   "src/gui/GuiText.ts"() {
@@ -8450,7 +8888,7 @@ var init_GuiText = __esm({
 });
 
 // src/gui/GuiTextureGeometry.ts
-import { BufferGeometry as BufferGeometry3, Float32BufferAttribute as Float32BufferAttribute5, PlaneGeometry } from "three";
+import { BufferGeometry as BufferGeometry3, Float32BufferAttribute as Float32BufferAttribute6, PlaneGeometry } from "three";
 function createGuiTextureGeometry(width, height, imageWidth, imageHeight, crop, scaling) {
   if (crop || !scaling || scaling.type === "stretch") {
     const [x, y, w, h] = crop ?? [0, 0, imageWidth, imageHeight];
@@ -8525,7 +8963,7 @@ function createGuiTextureGeometry(width, height, imageWidth, imageHeight, crop,
       }
     }
   }
-  return new BufferGeometry3().setAttribute("position", new Float32BufferAttribute5(positions, 3)).setAttribute("normal", new Float32BufferAttribute5(normals, 3)).setAttribute("uv", new Float32BufferAttribute5(uvs, 2)).setIndex(indices);
+  return new BufferGeometry3().setAttribute("position", new Float32BufferAttribute6(positions, 3)).setAttribute("normal", new Float32BufferAttribute6(normals, 3)).setAttribute("uv", new Float32BufferAttribute6(uvs, 2)).setIndex(indices);
 }
 var init_GuiTextureGeometry = __esm({
   "src/gui/GuiTextureGeometry.ts"() {
@@ -8536,7 +8974,7 @@ var init_GuiTextureGeometry = __esm({
 import {
   BufferAttribute as BufferAttribute4,
   BufferGeometry as BufferGeometry4,
-  Float32BufferAttribute as Float32BufferAttribute6,
+  Float32BufferAttribute as Float32BufferAttribute7,
   InterleavedBuffer,
   InterleavedBufferAttribute,
   TriangleFanDrawMode,
@@ -9064,8 +9502,8 @@ function computeMorphedAttributes(object4) {
       }
     }
   }
-  const morphedPositionAttribute = new Float32BufferAttribute6(modifiedPosition, 3);
-  const morphedNormalAttribute = new Float32BufferAttribute6(modifiedNormal, 3);
+  const morphedPositionAttribute = new Float32BufferAttribute7(modifiedPosition, 3);
+  const morphedNormalAttribute = new Float32BufferAttribute7(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -9352,7 +9790,7 @@ var init_SkinImage = __esm({
 });
 
 // src/skin/SkinTextures.ts
-import { DataTexture as DataTexture3, DoubleSide as DoubleSide3, FrontSide as FrontSide2, MeshBasicMaterial as MeshBasicMaterial3, SRGBColorSpace as SRGBColorSpace6 } from "three";
+import { DataTexture as DataTexture3, DoubleSide as DoubleSide4, FrontSide as FrontSide2, MeshBasicMaterial as MeshBasicMaterial3, SRGBColorSpace as SRGBColorSpace6 } from "three";
 var SkinTextures;
 var init_SkinTextures = __esm({
   "src/skin/SkinTextures.ts"() {
@@ -9397,7 +9835,7 @@ var init_SkinTextures = __esm({
         texture.colorSpace = SRGBColorSpace6;
         texture.flipY = true;
         texture.needsUpdate = true;
-        return new MeshBasicMaterial3({ map: texture, transparent, side: transparent ? DoubleSide3 : FrontSide2, alphaTest: transparent ? 0.1 : 0 });
+        return new MeshBasicMaterial3({ map: texture, transparent, side: transparent ? DoubleSide4 : FrontSide2, alphaTest: transparent ? 0.1 : 0 });
       }
       static isSlim(image, scale) {
         for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -9450,7 +9888,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;
           }
@@ -9461,6 +9899,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"() {
@@ -9779,274 +10221,71 @@ var init_SpecialItems = __esm({
               load("bed_foot", key, new Matrix47().makeTranslation(0, 0, -16).multiply(transform))
             ]);
           }
-          case "minecraft:head":
-          case "head": {
-            const models = {
-              skeleton: "skeleton_skull",
-              wither_skeleton: "wither_skeleton_skull",
-              zombie: "zombie_head",
-              creeper: "creeper_head",
-              dragon: "dragon_skull",
-              piglin: "piglin_head"
-            };
-            const id = Object.prototype.hasOwnProperty.call(models, special.kind) ? models[special.kind] : void 0;
-            if (!id) throw new Error(`Unsupported special item head kind ${special.kind}`);
-            const animation = (special.animation ?? 0) * Math.PI * 0.2;
-            const rotations = { head: [0, Math.PI, 0] };
-            if (special.kind === "dragon") rotations.jaw = [(Math.sin(animation) + 1) * 0.2, 0, 0];
-            if (special.kind === "piglin") {
-              rotations.left_ear = [0, 0, -(Math.cos(animation * 1.2) + 2.5) * 0.2];
-              rotations.right_ear = [0, 0, (Math.cos(animation) + 2.5) * 0.2];
-            }
-            return [await load(
-              id,
-              special.texture ? texture(special.texture, "") : void 0,
-              new Matrix47().makeTranslation(8, 0, 8).multiply(new Matrix47().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
-import { ClampToEdgeWrapping as ClampToEdgeWrapping3, CustomBlending as CustomBlending2, DoubleSide as DoubleSide4, EqualDepth, Float32BufferAttribute as Float32BufferAttribute7, LinearFilter as LinearFilter2, Mesh as Mesh5, OneFactor as OneFactor2, RepeatWrapping as RepeatWrapping3, ShaderMaterial as ShaderMaterial3, SrcColorFactor, Vector2 as Vector23, ZeroFactor } from "three";
-var ItemGlint;
-var init_ItemGlint = __esm({
-  "src/model/ItemGlint.ts"() {
-    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 ? ClampToEdgeWrapping3 : RepeatWrapping3;
-            if (metadata?.texture?.blur) texture2.magFilter = texture2.minFilter = LinearFilter2;
-            return texture2;
-          });
-        }
-        const material = new ShaderMaterial3({
-          name: "item-glint",
-          transparent: true,
-          depthWrite: false,
-          depthFunc: EqualDepth,
-          side: DoubleSide4,
-          forceSinglePass: true,
-          blending: CustomBlending2,
-          blendSrc: SrcColorFactor,
-          blendDst: OneFactor2,
-          blendSrcAlpha: ZeroFactor,
-          blendDstAlpha: OneFactor2,
-          toneMapped: false,
-          defines: entityMeshes ? { ENTITY_GLINT: true } : {},
-          uniforms: {
-            ...!entityMeshes && { baseMap: { value: baseMap } },
-            glintMap: { value: texture },
-            glintOffset: { value: new Vector23() },
-            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 Mesh5(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 Float32BufferAttribute7(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;
+          case "minecraft:head":
+          case "head": {
+            const models = {
+              skeleton: "skeleton_skull",
+              wither_skeleton: "wither_skeleton_skull",
+              zombie: "zombie_head",
+              creeper: "creeper_head",
+              dragon: "dragon_skull",
+              piglin: "piglin_head"
+            };
+            const id = Object.prototype.hasOwnProperty.call(models, special.kind) ? models[special.kind] : void 0;
+            if (!id) throw new Error(`Unsupported special item head kind ${special.kind}`);
+            const animation = (special.animation ?? 0) * Math.PI * 0.2;
+            const rotations = { head: [0, Math.PI, 0] };
+            if (special.kind === "dragon") rotations.jaw = [(Math.sin(animation) + 1) * 0.2, 0, 0];
+            if (special.kind === "piglin") {
+              rotations.left_ear = [0, 0, -(Math.cos(animation * 1.2) + 2.5) * 0.2];
+              rotations.right_ear = [0, 0, (Math.cos(animation) + 2.5) * 0.2];
+            }
+            return [await load(
+              id,
+              special.texture ? texture(special.texture, "") : void 0,
+              new Matrix47().makeTranslation(8, 0, 8).multiply(new Matrix47().makeScale(-1, -1, 1)),
+              rotations
+            )];
           }
         }
-        geometry.setAttribute("glintUv", new Float32BufferAttribute7(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, {
@@ -11191,17 +11430,25 @@ var init_BlockObject = __esm({
         if (!key || this.options.displayPosition) return false;
         const generation = this._entityGeneration;
         const created = [];
+        const placement = new Matrix410();
         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);
@@ -11212,18 +11459,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 Matrix410().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 Matrix410().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;
@@ -11517,6 +11767,7 @@ init_PersistentCache();
 var NodeCache = class extends PersistentCache {
   constructor(backing) {
     super(backing);
+    this.pendingWrites = /* @__PURE__ */ new Map();
   }
   ready() {
     return this.initialized ??= this.backing.init();
@@ -11527,7 +11778,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();
@@ -11573,7 +11831,10 @@ var NodeEnv = class {
   openCache(name, version2) {
     return new NodeCache(NodePersist.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
     }));
   }
 };
@@ -11650,6 +11911,9 @@ function shutdown() {
   Caching.end();
 }
 
+// src/armor/index.ts
+init_Armor();
+
 // src/assets/index.ts
 init_AssetDefaults();
 init_AssetKey();
@@ -11741,7 +12005,7 @@ init_EntityObject();
 init_MineRenderError();
 
 // src/export/SceneExporter.ts
-import { ClampToEdgeWrapping as ClampToEdgeWrapping2, Color as Color7, Float32BufferAttribute as Float32BufferAttribute3, Matrix4 as Matrix46, Mesh as Mesh4, MeshBasicMaterial as MeshBasicMaterial2, NearestFilter as NearestFilter3, RGBAFormat as RGBAFormat3, Scene as Scene3, TextureSource as TextureSource2, Texture as Texture3, UnsignedByteType } from "three";
+import { ClampToEdgeWrapping as ClampToEdgeWrapping3, Color as Color7, Float32BufferAttribute as Float32BufferAttribute4, Matrix4 as Matrix46, Mesh as Mesh5, MeshBasicMaterial as MeshBasicMaterial2, NearestFilter as NearestFilter3, RGBAFormat as RGBAFormat3, Scene as Scene3, TextureSource as TextureSource2, Texture as Texture3, UnsignedByteType } from "three";
 
 // ../../node_modules/three/examples/jsm/exporters/OBJExporter.js
 import {
@@ -11749,7 +12013,7 @@ import {
   ColorManagement,
   Matrix3,
   SRGBColorSpace as SRGBColorSpace3,
-  Vector2 as Vector22,
+  Vector2 as Vector23,
   Vector3 as Vector37
 } from "three";
 var OBJExporter = class {
@@ -11769,7 +12033,7 @@ var OBJExporter = class {
     const vertex = new Vector37();
     const color2 = new Color4();
     const normal = new Vector37();
-    const uv = new Vector22();
+    const uv = new Vector23();
     const face = [];
     function parseMesh(mesh) {
       let nbVertex = 0;
@@ -12474,7 +12738,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
         if (instanceColor) tint.multiply(instanceColor);
         if (bakeColors) {
           const original = geometry.getAttribute("color");
-          const colors2 = new Float32BufferAttribute3(new Float32Array(geometry.getAttribute("position").count * 3), 3);
+          const colors2 = new Float32BufferAttribute4(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);
           }
@@ -12483,7 +12747,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
           material.color.copy(tint);
         }
       }
-      const copy = new Mesh4(geometry, material);
+      const copy = new Mesh5(geometry, material);
       copy.name = mesh.name;
       copy.renderOrder = mesh.renderOrder;
       scene.add(copy);
@@ -12525,7 +12789,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 !== RGBAFormat3 || texture.type !== UnsignedByteType || texture.wrapS !== ClampToEdgeWrapping2 || texture.wrapT !== ClampToEdgeWrapping2 || texture.magFilter !== NearestFilter3 || texture.minFilter !== NearestFilter3 || 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 !== RGBAFormat3 || texture.type !== UnsignedByteType || texture.wrapS !== ClampToEdgeWrapping3 || texture.wrapT !== ClampToEdgeWrapping3 || texture.magFilter !== NearestFilter3 || texture.minFilter !== NearestFilter3 || 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;
@@ -14190,6 +14454,7 @@ import { Scene as Scene4 } from "three";
 
 // src/skin/scene/SkinObject.ts
 init_SceneObject();
+import { Object3D as Object3D6 } from "three";
 
 // src/skin/SkinPart.ts
 var SkinPart = /* @__PURE__ */ ((SkinPart2) => {
@@ -14206,11 +14471,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: {
@@ -14831,7 +15106,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
@@ -14882,6 +15159,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,
@@ -14895,7 +15173,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 = {
@@ -14924,6 +15204,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();
@@ -14931,27 +15217,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 Object3D6();
+    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 */);
@@ -14959,7 +15260,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;
@@ -14968,7 +15270,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;
@@ -14979,14 +15282,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 */);
@@ -15053,6 +15358,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;
@@ -15071,6 +15424,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;
@@ -15080,6 +15466,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
@@ -15099,7 +15490,7 @@ function isBlockObject2(obj) {
 }
 var ModelObjectClass;
 var BlockObjectClass;
-var EntityObjectClass;
+var EntityObjectClass2;
 var GuiObjectClass;
 var ItemTintsClass;
 var MineRenderScene = class _MineRenderScene extends Scene4 {
@@ -15243,7 +15634,7 @@ var MineRenderScene = class _MineRenderScene extends Scene4 {
   }
   /** 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);
   }
   /**
@@ -16598,6 +16989,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) {
@@ -16638,13 +17046,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, {
@@ -16658,10 +17080,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,
@@ -16700,9 +17123,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;
@@ -16931,6 +17352,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");
           }
@@ -16969,10 +17391,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;
         }
@@ -17021,6 +17453,7 @@ init_Skins();
 
 // src/texture/index.ts
 init_Colormaps();
+init_PalettedTextures();
 init_TextureAtlas();
 init_TextureLoader();
 init_Textures();
@@ -17810,7 +18243,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);
@@ -17818,7 +18251,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);
@@ -17828,10 +18261,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();
@@ -17853,7 +18286,8 @@ var AnvilWorldSource = class {
 };
 
 // src/world/Chunk.ts
-import { Color as Color13, Vector3 as Vector320 } from "three";
+init_BlockObject();
+import { Color as Color13, Vector3 as Vector321 } from "three";
 init_BlockStates();
 init_AssetKey();
 
@@ -17863,6 +18297,7 @@ init_util();
 import { Vector3 as Vector319 } from "three";
 init_AssetKey();
 init_BlockStates();
+init_BlockEntities();
 init_CubeFace();
 
 // src/world/SectionModels.ts
@@ -17960,6 +18395,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());
@@ -17982,22 +18421,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 };
   }
@@ -18457,6 +18898,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();
@@ -18570,7 +19012,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();
           }
@@ -18671,15 +19113,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 distinct = /* @__PURE__ */ new Map();
       const position = new Vector319();
       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);
@@ -18690,6 +19135,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;
     }
@@ -18725,7 +19180,7 @@ var MineRenderWorld = class {
         ));
         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();
       }
@@ -18733,6 +19188,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");
     }
@@ -18794,7 +19305,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();
           }
@@ -18817,9 +19328,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()]);
+      }
     }
   }
   /**
@@ -18849,7 +19363,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();
         }
@@ -18988,15 +19502,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) {
@@ -19113,7 +19637,7 @@ init_BlockEntities();
 // src/world/SectionMesh.ts
 init_CanvasCompat();
 init_Materials();
-import { BufferGeometry as BufferGeometry9, Color as Color12, DoubleSide as DoubleSide8, Float32BufferAttribute as Float32BufferAttribute10, FrontSide as FrontSide4, Group as Group3, Mesh as Mesh12, Uint32BufferAttribute } from "three";
+import { BufferGeometry as BufferGeometry9, Color as Color12, DoubleSide as DoubleSide8, DynamicDrawUsage, Float32BufferAttribute as Float32BufferAttribute10, FrontSide as FrontSide4, Group as Group3, Matrix4 as Matrix413, Mesh as Mesh12, Uint32BufferAttribute, Vector3 as Vector320 } from "three";
 
 // src/world/SectionGeometry.ts
 init_FluidQuads();
@@ -19388,6 +19912,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;
@@ -19401,8 +19927,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;
@@ -19440,6 +19970,9 @@ 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 Color12(4159204).toArray();
 function toInput(entries, maxAtlasSize, fluids, lighting) {
@@ -19476,8 +20009,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 = {
@@ -19487,8 +20020,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,
@@ -19500,7 +20033,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);
@@ -19513,7 +20046,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;
@@ -19546,6 +20079,54 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
   }
   return { input, atlases: atlases2 };
 }
+function sortTransparentQuads(mesh) {
+  const index = mesh.geometry.getIndex();
+  if (index.count <= QUAD_INDICES) return;
+  index.setUsage(DynamicDrawUsage);
+  const count = index.count / QUAD_INDICES;
+  let source, centers, depths, order;
+  const view = new Matrix413(), localCamera = new Vector320(), key = new Vector320(), previous = new Vector320();
+  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 Group3 {
   constructor() {
     super(...arguments);
@@ -19555,7 +20136,11 @@ var SectionMesh = class _SectionMesh extends Group3 {
   /** 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) {
@@ -19591,13 +20176,14 @@ var SectionMesh = class _SectionMesh extends Group3 {
       const material = Materials.createShadedCanvasMaterial(canvas, transparent, false, true);
       material.side = FrontSide4;
       if (page.layer === 2) {
+        material.depthWrite = !material.transparent;
         material.side = DoubleSide8;
         material.forceSinglePass = true;
-        material.depthWrite = !material.transparent;
       }
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
       const mesh = new Mesh12(geometry, material);
+      if (transparent) sortTransparentQuads(mesh);
       section.add(mesh);
       section.blockIndices.set(mesh, page.blockIndices);
       const unsubscribe = [];
@@ -19656,7 +20242,7 @@ var Chunk = class _Chunk {
     this.sectionBlocks = /* @__PURE__ */ new Map();
     this.hiddenBlocks = /* @__PURE__ */ new Set();
     this.fluidCells = new Uint8Array(4096);
-    this.blockPosition = new Vector320();
+    this.blockPosition = new Vector321();
     this.meshDirty = false;
     this.meshGeneration = 0;
     this.blockChanges = /* @__PURE__ */ new Set();
@@ -19716,7 +20302,7 @@ var Chunk = class _Chunk {
       const info = owner.chunk.renderedBlocks.get(owner.index);
       if (!info) continue;
       return {
-        position: new Vector320(
+        position: new Vector321(
           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
@@ -19731,18 +20317,18 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector320(posOrX, y, z));
+      return this.getBlockAt(new Vector321(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector320(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector321(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 Vector320(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector320(...posOrX));
+    if (typeof posOrX === "number") return this.getBiomeAt(new Vector321(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector321(...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];
@@ -19820,17 +20406,17 @@ var Chunk = class _Chunk {
         this.hiddenBlocks.add(index);
         this.renderedBlocks.get(index)?.object?.setVisible(false);
       }
-      const positions = blocks.map(({ index }) => new Vector320(...this.positionAt(index)));
+      const positions = blocks.map(({ index }) => new Vector321(...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 Vector320(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector321(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector320(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector321(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -19892,8 +20478,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);
@@ -19903,13 +20491,12 @@ var Chunk = class _Chunk {
       this.fluidCells[index] = 0;
       this.renderedBlocks.delete(index);
       this.objectBlocks.delete(index);
-      const worldPos = new Vector320(
+      const worldPos = new Vector321(
         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);
@@ -19931,7 +20518,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,
@@ -19939,13 +20526,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() {
@@ -19953,12 +20539,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. */
@@ -20029,37 +20638,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 Vector320(
-          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 Vector321(
+      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];
   }
@@ -20348,7 +20962,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 Vector320(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new Vector321(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     )) : [];
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -20384,14 +20998,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new Vector320(
+    return new Vector321(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new Vector320(
+    return new Vector321(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z
@@ -20400,6 +21014,7 @@ var Chunk = class _Chunk {
 };
 
 // src/world/WorldStreamer.ts
+var MAX_PREFETCHED_COLUMNS = 4;
 var WorldStreamer = class {
   constructor(world, source, options = {}) {
     this.world = world;
@@ -20409,6 +21024,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);
@@ -20453,6 +21069,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());
   }
@@ -20473,8 +21095,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 {
@@ -20500,6 +21125,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;
@@ -20522,26 +21151,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) {
@@ -20742,6 +21450,7 @@ export {
   AnvilParser,
   AnvilWorldSource,
   ArchiveAssetSource,
+  Armor,
   AssetKey,
   AssetLoadError,
   AssetLoader,
@@ -20825,6 +21534,7 @@ export {
   OrbitControls,
   PackFormats,
   PackMetadata,
+  PalettedTextures,
   PersistentCache,
   PlayerHeadTextures,
   Renames,