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

package/dist/bundle.js

@@ -1896,40 +1896,6 @@ var MineRender = (() => {
     }
   });
 
-  // src/cache/PersistentCache.ts
-  var _PersistentCache, PersistentCache;
-  var init_PersistentCache = __esm({
-    "src/cache/PersistentCache.ts"() {
-      init_dirname();
-      init_buffer2();
-      init_process2();
-      init_Env();
-      _PersistentCache = class _PersistentCache {
-        constructor(backing) {
-          this.backing = backing;
-        }
-        /** Opens a named store in the active environment using the current cache schema version. */
-        static open(name2) {
-          return Env.provider.openCache(name2, _PersistentCache.VERSION);
-        }
-        /** Loads a missing entry and stores only non-nullish results. */
-        async getOrLoad(key, loader) {
-          let v5 = await this.get(key);
-          if (typeof v5 === "undefined" || v5 === null) {
-            v5 = await loader(key);
-            if (typeof v5 !== "undefined" && v5 !== null) {
-              await this.put(key, v5);
-            }
-          }
-          return v5;
-        }
-      };
-      /** Bump to invalidate every persisted entry. */
-      _PersistentCache.VERSION = 2;
-      PersistentCache = _PersistentCache;
-    }
-  });
-
   // src/util/log.ts
   function readSwitch() {
     switchRead = true;
@@ -2014,6 +1980,40 @@ var MineRender = (() => {
     }
   });
 
+  // src/cache/PersistentCache.ts
+  var _PersistentCache, PersistentCache;
+  var init_PersistentCache = __esm({
+    "src/cache/PersistentCache.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_Env();
+      _PersistentCache = class _PersistentCache {
+        constructor(backing) {
+          this.backing = backing;
+        }
+        /** Opens a named store in the active environment using the current cache schema version. */
+        static open(name2) {
+          return Env.provider.openCache(name2, _PersistentCache.VERSION);
+        }
+        /** Loads a missing entry and stores only non-nullish results. */
+        async getOrLoad(key, loader) {
+          let v5 = await this.get(key);
+          if (typeof v5 === "undefined" || v5 === null) {
+            v5 = await loader(key);
+            if (typeof v5 !== "undefined" && v5 !== null) {
+              await this.put(key, v5);
+            }
+          }
+          return v5;
+        }
+      };
+      /** Bump to invalidate every persisted entry. */
+      _PersistentCache.VERSION = 2;
+      PersistentCache = _PersistentCache;
+    }
+  });
+
   // ../../node_modules/localforage/dist/localforage.js
   var require_localforage = __commonJS({
     "../../node_modules/localforage/dist/localforage.js"(exports13, module2) {
@@ -4180,7 +4180,7 @@ var MineRender = (() => {
     canvas.style.display = "block";
     return canvas;
   }
-  function log2(...params) {
+  function log3(...params) {
     const message = "THREE." + params.shift();
     if (_setConsoleFunction) {
       _setConsoleFunction("log", message, ...params);
@@ -4852,7 +4852,7 @@ var MineRender = (() => {
     }
     throw new Error(`THREE.TextureUtils: Unknown texture type ${type}.`);
   }
-  var REVISION, MOUSE, TOUCH, CullFaceNone, CullFaceBack, CullFaceFront, PCFShadowMap, PCFSoftShadowMap, VSMShadowMap, FrontSide, BackSide, DoubleSide, NoBlending, NormalBlending, AdditiveBlending, SubtractiveBlending, MultiplyBlending, CustomBlending, AddEquation, SubtractEquation, ReverseSubtractEquation, MinEquation, MaxEquation, ZeroFactor, OneFactor, SrcColorFactor, OneMinusSrcColorFactor, SrcAlphaFactor, OneMinusSrcAlphaFactor, DstAlphaFactor, OneMinusDstAlphaFactor, DstColorFactor, OneMinusDstColorFactor, SrcAlphaSaturateFactor, ConstantColorFactor, OneMinusConstantColorFactor, ConstantAlphaFactor, OneMinusConstantAlphaFactor, NeverDepth, AlwaysDepth, LessDepth, LessEqualDepth, EqualDepth, GreaterEqualDepth, GreaterDepth, NotEqualDepth, MultiplyOperation, MixOperation, AddOperation, NoToneMapping, LinearToneMapping, ReinhardToneMapping, CineonToneMapping, ACESFilmicToneMapping, CustomToneMapping, AgXToneMapping, NeutralToneMapping, UVMapping, CubeReflectionMapping, CubeRefractionMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping, CubeUVReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, MirroredRepeatWrapping, NearestFilter, NearestMipmapNearestFilter, NearestMipmapLinearFilter, LinearFilter, LinearMipmapNearestFilter, LinearMipmapLinearFilter, UnsignedByteType, ByteType, ShortType, UnsignedShortType, IntType, UnsignedIntType, FloatType, HalfFloatType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedInt248Type, UnsignedInt5999Type, UnsignedInt101111Type, AlphaFormat, RGBFormat, RGBAFormat, DepthFormat, DepthStencilFormat, RedFormat, RedIntegerFormat, RGFormat, RGIntegerFormat, RGBAIntegerFormat, RGB_S3TC_DXT1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGB_PVRTC_4BPPV1_Format, RGB_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_PVRTC_2BPPV1_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGBA_ETC2_EAC_Format, R11_EAC_Format, SIGNED_R11_EAC_Format, RG11_EAC_Format, SIGNED_RG11_EAC_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_10x10_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_BPTC_Format, RGB_BPTC_SIGNED_Format, RGB_BPTC_UNSIGNED_Format, RED_RGTC1_Format, SIGNED_RED_RGTC1_Format, RED_GREEN_RGTC2_Format, SIGNED_RED_GREEN_RGTC2_Format, InterpolateDiscrete, InterpolateLinear, InterpolateSmooth, InterpolateBezier, ZeroCurvatureEnding, ZeroSlopeEnding, WrapAroundEnding, TrianglesDrawMode, TriangleStripDrawMode, TriangleFanDrawMode, BasicDepthPacking, TangentSpaceNormalMap, ObjectSpaceNormalMap, NoColorSpace, SRGBColorSpace, LinearSRGBColorSpace, LinearTransfer, SRGBTransfer, KeepStencilOp, AlwaysStencilFunc, NeverCompare, LessCompare, EqualCompare, LessEqualCompare, GreaterCompare, NotEqualCompare, GreaterEqualCompare, AlwaysCompare, StaticDrawUsage, GLSL3, WebGLCoordinateSystem, WebGPUCoordinateSystem, _cache, _setConsoleFunction, ReversedDepthFuncs, EventDispatcher, _lut, _seed, DEG2RAD, RAD2DEG, MathUtils, _Vector2, Vector2, Quaternion, _Vector3, Vector3, _vector$c, _quaternion$5, _Matrix3, Matrix3, _m3, LINEAR_REC709_TO_XYZ, XYZ_TO_LINEAR_REC709, ColorManagement, _canvas, ImageUtils, _sourceId, TextureSource, _textureId, _tempVec3, Texture, _Vector4, Vector4, RenderTarget, WebGLRenderTarget, DataArrayTexture, Data3DTexture, _Matrix4, Matrix4, _v1$7, _m1$2, _zero, _one, _x, _y, _z, _matrix$2, _quaternion$4, Euler, Layers, _object3DId, _v1$6, _q1, _m1$1, _target, _position$4, _scale$3, _quaternion$3, _xAxis, _yAxis, _zAxis, _addedEvent, _removedEvent, _childaddedEvent, _childremovedEvent, Object3D, Group, _moveEvent, WebXRController, _colorKeywords, _hslA, _hslB, Color, _color, Scene, _v0$2, _v1$5, _v2$4, _v3$2, _vab, _vac, _vbc, _vap, _vbp, _vcp, _v40, _v41, _v42, Triangle, Box3, _points, _vector$b, _box$4, _v0$1, _v1$4, _v2$3, _f0, _f1, _f2, _center, _extents, _triangleNormal, _testAxis, _vector$a, _vector2$1, _id$2, BufferAttribute, Uint16BufferAttribute, Uint32BufferAttribute, Float32BufferAttribute, _box$3, _v1$3, _v2$2, Sphere, _id$1, _m1, _obj, _offset, _box$2, _boxMorphTargets, _vector$9, BufferGeometry, InterleavedBuffer, _vector$8, InterleavedBufferAttribute, _vector1, _vector2, _normalMatrix, Plane, _materialId, Material, _vector$7, _segCenter, _segDir, _diff, Ray, MeshBasicMaterial, _inverseMatrix$3, _ray$3, _sphere$6, _sphereHitAt, _vA, _vB, _vC, _tempA, _morphA, _intersectionPoint, _intersectionPointWorld, Mesh, DataTexture, InstancedBufferAttribute, _instanceLocalMatrix, _instanceWorldMatrix, _instanceIntersects, _box3, _identity, _mesh$1, _sphere$4, InstancedMesh, _sphere$3, _defaultSpriteCenter, _vector$6, Frustum, LineBasicMaterial, _vStart, _vEnd, _inverseMatrix$1, _ray$1, _sphere$1, _intersectPointOnRay, _intersectPointOnSegment, Line, _start, _end, LineSegments, CompressedTexture, CubeTexture, CanvasTexture, DepthTexture, CubeDepthTexture, ExternalTexture, BoxGeometry, _v0, _v1$1, _normal, _triangle, EdgesGeometry, PlaneGeometry, UniformsUtils, default_vertex, default_fragment, ShaderMaterial, RawShaderMaterial, MeshStandardMaterial, MeshDepthMaterial, MeshDistanceMaterial, Interpolant, CubicInterpolant, LinearInterpolant, DiscreteInterpolant, BezierInterpolant, KeyframeTrack, BooleanKeyframeTrack, ColorKeyframeTrack, NumberKeyframeTrack, QuaternionLinearInterpolant, QuaternionKeyframeTrack, StringKeyframeTrack, VectorKeyframeTrack, LoadingManager, DefaultLoadingManager, Loader, _position$2, _quaternion$2, _scale$2, Camera, _v3$1, _minTarget, _maxTarget, PerspectiveCamera, OrthographicCamera, fov, aspect, CubeCamera, ArrayCamera, _RESERVED_CHARS_RE, _reservedRe, _wordChar, _wordCharOrDot, _directoryRe, _nodeRe, _objectRe, _propertyRe, _trackRe, _supportedObjectNames, Composite, PropertyBinding, _controlInterpolantsResultBuffer, Uniform, _matrix, Raycaster, Spherical, _Matrix2, Matrix2, _vector$4, Box2, GridHelper, AxesHelper, Controls;
+  var REVISION, MOUSE, TOUCH, CullFaceNone, CullFaceBack, CullFaceFront, PCFShadowMap, PCFSoftShadowMap, VSMShadowMap, FrontSide, BackSide, DoubleSide, NoBlending, NormalBlending, AdditiveBlending, SubtractiveBlending, MultiplyBlending, CustomBlending, AddEquation, SubtractEquation, ReverseSubtractEquation, MinEquation, MaxEquation, ZeroFactor, OneFactor, SrcColorFactor, OneMinusSrcColorFactor, SrcAlphaFactor, OneMinusSrcAlphaFactor, DstAlphaFactor, OneMinusDstAlphaFactor, DstColorFactor, OneMinusDstColorFactor, SrcAlphaSaturateFactor, ConstantColorFactor, OneMinusConstantColorFactor, ConstantAlphaFactor, OneMinusConstantAlphaFactor, NeverDepth, AlwaysDepth, LessDepth, LessEqualDepth, EqualDepth, GreaterEqualDepth, GreaterDepth, NotEqualDepth, MultiplyOperation, MixOperation, AddOperation, NoToneMapping, LinearToneMapping, ReinhardToneMapping, CineonToneMapping, ACESFilmicToneMapping, CustomToneMapping, AgXToneMapping, NeutralToneMapping, UVMapping, CubeReflectionMapping, CubeRefractionMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping, CubeUVReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, MirroredRepeatWrapping, NearestFilter, NearestMipmapNearestFilter, NearestMipmapLinearFilter, LinearFilter, LinearMipmapNearestFilter, LinearMipmapLinearFilter, UnsignedByteType, ByteType, ShortType, UnsignedShortType, IntType, UnsignedIntType, FloatType, HalfFloatType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedInt248Type, UnsignedInt5999Type, UnsignedInt101111Type, AlphaFormat, RGBFormat, RGBAFormat, DepthFormat, DepthStencilFormat, RedFormat, RedIntegerFormat, RGFormat, RGIntegerFormat, RGBAIntegerFormat, RGB_S3TC_DXT1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGB_PVRTC_4BPPV1_Format, RGB_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_PVRTC_2BPPV1_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGBA_ETC2_EAC_Format, R11_EAC_Format, SIGNED_R11_EAC_Format, RG11_EAC_Format, SIGNED_RG11_EAC_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_10x10_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_BPTC_Format, RGB_BPTC_SIGNED_Format, RGB_BPTC_UNSIGNED_Format, RED_RGTC1_Format, SIGNED_RED_RGTC1_Format, RED_GREEN_RGTC2_Format, SIGNED_RED_GREEN_RGTC2_Format, InterpolateDiscrete, InterpolateLinear, InterpolateSmooth, InterpolateBezier, ZeroCurvatureEnding, ZeroSlopeEnding, WrapAroundEnding, TrianglesDrawMode, TriangleStripDrawMode, TriangleFanDrawMode, BasicDepthPacking, TangentSpaceNormalMap, ObjectSpaceNormalMap, NoColorSpace, SRGBColorSpace, LinearSRGBColorSpace, LinearTransfer, SRGBTransfer, KeepStencilOp, AlwaysStencilFunc, NeverCompare, LessCompare, EqualCompare, LessEqualCompare, GreaterCompare, NotEqualCompare, GreaterEqualCompare, AlwaysCompare, StaticDrawUsage, DynamicDrawUsage, GLSL3, WebGLCoordinateSystem, WebGPUCoordinateSystem, _cache, _setConsoleFunction, ReversedDepthFuncs, EventDispatcher, _lut, _seed, DEG2RAD, RAD2DEG, MathUtils, _Vector2, Vector2, Quaternion, _Vector3, Vector3, _vector$c, _quaternion$5, _Matrix3, Matrix3, _m3, LINEAR_REC709_TO_XYZ, XYZ_TO_LINEAR_REC709, ColorManagement, _canvas, ImageUtils, _sourceId, TextureSource, _textureId, _tempVec3, Texture, _Vector4, Vector4, RenderTarget, WebGLRenderTarget, DataArrayTexture, Data3DTexture, _Matrix4, Matrix4, _v1$7, _m1$2, _zero, _one, _x, _y, _z, _matrix$2, _quaternion$4, Euler, Layers, _object3DId, _v1$6, _q1, _m1$1, _target, _position$4, _scale$3, _quaternion$3, _xAxis, _yAxis, _zAxis, _addedEvent, _removedEvent, _childaddedEvent, _childremovedEvent, Object3D, Group, _moveEvent, WebXRController, _colorKeywords, _hslA, _hslB, Color, _color, Scene, _v0$2, _v1$5, _v2$4, _v3$2, _vab, _vac, _vbc, _vap, _vbp, _vcp, _v40, _v41, _v42, Triangle, Box3, _points, _vector$b, _box$4, _v0$1, _v1$4, _v2$3, _f0, _f1, _f2, _center, _extents, _triangleNormal, _testAxis, _vector$a, _vector2$1, _id$2, BufferAttribute, Uint16BufferAttribute, Uint32BufferAttribute, Float32BufferAttribute, _box$3, _v1$3, _v2$2, Sphere, _id$1, _m1, _obj, _offset, _box$2, _boxMorphTargets, _vector$9, BufferGeometry, InterleavedBuffer, _vector$8, InterleavedBufferAttribute, _vector1, _vector2, _normalMatrix, Plane, _materialId, Material, _vector$7, _segCenter, _segDir, _diff, Ray, MeshBasicMaterial, _inverseMatrix$3, _ray$3, _sphere$6, _sphereHitAt, _vA, _vB, _vC, _tempA, _morphA, _intersectionPoint, _intersectionPointWorld, Mesh, DataTexture, InstancedBufferAttribute, _instanceLocalMatrix, _instanceWorldMatrix, _instanceIntersects, _box3, _identity, _mesh$1, _sphere$4, InstancedMesh, _sphere$3, _defaultSpriteCenter, _vector$6, Frustum, LineBasicMaterial, _vStart, _vEnd, _inverseMatrix$1, _ray$1, _sphere$1, _intersectPointOnRay, _intersectPointOnSegment, Line, _start, _end, LineSegments, CompressedTexture, CubeTexture, CanvasTexture, DepthTexture, CubeDepthTexture, ExternalTexture, BoxGeometry, _v0, _v1$1, _normal, _triangle, EdgesGeometry, PlaneGeometry, UniformsUtils, default_vertex, default_fragment, ShaderMaterial, RawShaderMaterial, MeshStandardMaterial, MeshDepthMaterial, MeshDistanceMaterial, Interpolant, CubicInterpolant, LinearInterpolant, DiscreteInterpolant, BezierInterpolant, KeyframeTrack, BooleanKeyframeTrack, ColorKeyframeTrack, NumberKeyframeTrack, QuaternionLinearInterpolant, QuaternionKeyframeTrack, StringKeyframeTrack, VectorKeyframeTrack, LoadingManager, DefaultLoadingManager, Loader, _position$2, _quaternion$2, _scale$2, Camera, _v3$1, _minTarget, _maxTarget, PerspectiveCamera, OrthographicCamera, fov, aspect, CubeCamera, ArrayCamera, _RESERVED_CHARS_RE, _reservedRe, _wordChar, _wordCharOrDot, _directoryRe, _nodeRe, _objectRe, _propertyRe, _trackRe, _supportedObjectNames, Composite, PropertyBinding, _controlInterpolantsResultBuffer, Uniform, _matrix, Raycaster, Spherical, _Matrix2, Matrix2, _vector$4, Box2, GridHelper, AxesHelper, Controls;
   var init_three_core = __esm({
     "../../node_modules/three/build/three.core.js"() {
       init_dirname();
@@ -5018,6 +5018,7 @@ var MineRender = (() => {
       GreaterEqualCompare = 518;
       AlwaysCompare = 519;
       StaticDrawUsage = 35044;
+      DynamicDrawUsage = 35048;
       GLSL3 = "300 es";
       WebGLCoordinateSystem = 2e3;
       WebGPUCoordinateSystem = 2001;
@@ -15869,7 +15870,7 @@ var MineRender = (() => {
          */
         clone(data) {
           if (data === void 0) {
-            log2("InterleavedBufferAttribute.clone(): Cloning an interleaved buffer attribute will de-interleave buffer data.");
+            log3("InterleavedBufferAttribute.clone(): Cloning an interleaved buffer attribute will de-interleave buffer data.");
             const array = [];
             for (let i4 = 0; i4 < this.count; i4++) {
               const index = i4 * this.data.stride + this.offset;
@@ -15898,7 +15899,7 @@ var MineRender = (() => {
          */
         toJSON(data) {
           if (data === void 0) {
-            log2("InterleavedBufferAttribute.toJSON(): Serializing an interleaved buffer attribute will de-interleave buffer data.");
+            log3("InterleavedBufferAttribute.toJSON(): Serializing an interleaved buffer attribute will de-interleave buffer data.");
             const array = [];
             for (let i4 = 0; i4 < this.count; i4++) {
               const index = i4 * this.data.stride + this.offset;
@@ -31889,11 +31890,11 @@ void main() {
           };
           function onContextLost(event) {
             event.preventDefault();
-            log2("WebGLRenderer: Context Lost.");
+            log3("WebGLRenderer: Context Lost.");
             _isContextLost = true;
           }
           function onContextRestore() {
-            log2("WebGLRenderer: Context Restored.");
+            log3("WebGLRenderer: Context Restored.");
             _isContextLost = false;
             const infoAutoReset = info.autoReset;
             const shadowMapEnabled = shadowMap.enabled;
@@ -34067,8 +34068,6 @@ void main() {
     });
   }
   function yieldToEventLoop() {
-    const scheduler = globalThis.scheduler;
-    if (scheduler?.yield) return scheduler.yield();
     return new Promise((resolve) => {
       if (typeof MessageChannel !== "undefined") {
         const channel = new MessageChannel();
@@ -35699,9 +35698,12 @@ void main() {
             this.entityTextureCache,
             this.entityAnimationCache,
             this.blockEntityIndexCache,
+            this.entityDatasetVersionCache,
             this.fontCache,
             this.unihexCache,
             this.bannerPatternCache,
+            this.equipmentCache,
+            this.trimCache,
             this.mineRenderDataCache,
             this.usernameUuidCache,
             this.biomeCache
@@ -35733,6 +35735,8 @@ void main() {
           };
         }
       };
+      /** Cached in place of a missing asset. The caches drop `undefined` results, which would request the asset again. */
+      _Caching.MISSING = false;
       _Caching._generation = 0;
       _Caching.rawImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(5)).buildAsync();
       _Caching.imageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
@@ -35754,9 +35758,12 @@ void main() {
       _Caching.entityTextureCache = _Caching.createAssetCache();
       _Caching.entityAnimationCache = _Caching.createAssetCache();
       _Caching.blockEntityIndexCache = _Caching.createAssetCache();
+      _Caching.entityDatasetVersionCache = _Caching.createAssetCache();
       _Caching.unihexCache = _Caching.createAssetCache();
       _Caching.fontCache = _Caching.createAssetCache();
       _Caching.bannerPatternCache = _Caching.createAssetCache();
+      _Caching.equipmentCache = _Caching.createAssetCache();
+      _Caching.trimCache = _Caching.createAssetCache();
       _Caching.mineRenderDataCache = _Caching.createAssetCache();
       _Caching.usernameUuidCache = Caches.builder().expireAfterWrite(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
       _Caching.biomeCache = _Caching.createAssetCache();
@@ -36231,7 +36238,7 @@ void main() {
       signal.removeEventListener("abort", abort2);
     }
   }
-  var import_jobqu, log3, RequestError, RequestQueue, Requests;
+  var import_jobqu, log4, RequestError, RequestQueue, Requests;
   var init_Requests = __esm({
     "src/request/Requests.ts"() {
       init_dirname();
@@ -36239,7 +36246,7 @@ void main() {
       init_process2();
       import_jobqu = __toESM(require_src());
       init_log();
-      log3 = logger("Requests");
+      log4 = logger("Requests");
       RequestError = class extends Error {
         constructor(message, response, cause) {
           super(message);
@@ -36266,7 +36273,7 @@ void main() {
               try {
                 return await abortable(this.queue.add(request), signal);
               } catch (error2) {
-                log3.debug("Request failed", error2);
+                log4.debug("Request failed", error2);
                 const delay = this.retryDelay(error2, request, retries);
                 if (delay === void 0) {
                   throw error2;
@@ -36454,7 +36461,7 @@ void main() {
   });
 
   // src/image/ImageLoader.ts
-  var log4, ImageLoader2;
+  var log5, ImageLoader2;
   var init_ImageLoader = __esm({
     "src/image/ImageLoader.ts"() {
       init_dirname();
@@ -36468,7 +36475,7 @@ void main() {
       init_WrappedImage();
       init_base64();
       init_log();
-      log4 = logger("ImageLoader");
+      log5 = logger("ImageLoader");
       ImageLoader2 = class _ImageLoader {
         static _createImage() {
           return createImage();
@@ -36493,7 +36500,7 @@ void main() {
           return image;
         }
         static async loadData(src) {
-          log4.debug("loadData", src);
+          log5.debug("loadData", src);
           const image = await this.loadCanvasData(src);
           return image.data.getImageData(0, 0, image.width, image.height);
         }
@@ -36600,7 +36607,7 @@ void main() {
   });
 
   // src/texture/TextureLoader.ts
-  var log5, TextureLoader2;
+  var log6, TextureLoader2;
   var init_TextureLoader = __esm({
     "src/texture/TextureLoader.ts"() {
       init_dirname();
@@ -36611,7 +36618,7 @@ void main() {
       init_ImageLoader();
       init_Textures();
       init_log();
-      log5 = logger("TextureLoader");
+      log6 = logger("TextureLoader");
       TextureLoader2 = class {
         /** Reports whether image loading failed, so cached textures can be retried. */
         static hasFailed(texture) {
@@ -36627,7 +36634,7 @@ void main() {
             texture.needsUpdate = true;
           }, (error2) => {
             this.failedTextures.add(texture);
-            log5.warn("Failed to load texture", src, error2);
+            log6.warn("Failed to load texture", src, error2);
           });
           texture.image = image;
           texture.format = format3;
@@ -36643,7 +36650,7 @@ void main() {
             texture.needsUpdate = true;
           }).catch((error2) => {
             this.failedTextures.add(texture);
-            log5.warn("Failed to load texture", src, error2);
+            log6.warn("Failed to load texture", src, error2);
           });
           texture.format = format3;
           texture.rotation = rotation;
@@ -36722,7 +36729,7 @@ void main() {
   });
 
   // src/Materials.ts
-  var log6, Materials;
+  var log7, Materials;
   var init_Materials = __esm({
     "src/Materials.ts"() {
       init_dirname();
@@ -36734,7 +36741,7 @@ void main() {
       init_TextureLoader();
       init_Caching();
       init_log();
-      log6 = logger("Materials");
+      log7 = logger("Materials");
       Materials = class _Materials {
         /** Shared checkerboard material, created on first access. */
         static get MISSING_TEXTURE() {
@@ -37005,7 +37012,7 @@ void main() {
             Object.assign(material.defaultAttributeValues, { shade: [1], uvBounds: [0, 0, 1, 1] });
             return material;
           } catch (e6) {
-            log6.warn(e6);
+            log7.warn(e6);
           }
           return this.createBasicCanvasMaterial(canvas, transparent, shade);
         }
@@ -58567,7 +58574,7 @@ void main() {
     exports$17.callbackify = callbackify2;
     return exports$17;
   }
-  var exports$c4, _dewExec$b4, exports$b4, _dewExec$a4, exports$a4, _dewExec$94, exports$94, _dewExec$84, exports$84, _dewExec$74, exports$74, _dewExec$64, exports$64, _dewExec$54, _global$22, exports$54, _dewExec$44, _global$12, exports$44, _dewExec$34, exports$34, _dewExec$25, exports$25, _dewExec$15, exports$17, _dewExec9, _global4, exports11, _extend, callbackify, debuglog, deprecate, format, inherits, inspect, isArray, isBoolean, isBuffer, isDate, isError, isFunction, isNull, isNullOrUndefined, isNumber, isObject, isPrimitive, isRegExp, isString, isSymbol, isUndefined, log7, promisify3, types, TextEncoder2, TextDecoder2;
+  var exports$c4, _dewExec$b4, exports$b4, _dewExec$a4, exports$a4, _dewExec$94, exports$94, _dewExec$84, exports$84, _dewExec$74, exports$74, _dewExec$64, exports$64, _dewExec$54, _global$22, exports$54, _dewExec$44, _global$12, exports$44, _dewExec$34, exports$34, _dewExec$25, exports$25, _dewExec$15, exports$17, _dewExec9, _global4, exports11, _extend, callbackify, debuglog, deprecate, format, inherits, inspect, isArray, isBoolean, isBuffer, isDate, isError, isFunction, isNull, isNullOrUndefined, isNumber, isObject, isPrimitive, isRegExp, isString, isSymbol, isUndefined, log8, promisify3, types, TextEncoder2, TextDecoder2;
   var init_util3 = __esm({
     "../../node_modules/@jspm/core/nodelibs/browser/util.js"() {
       init_dirname();
@@ -58651,7 +58658,7 @@ void main() {
       isString = exports11.isString;
       isSymbol = exports11.isSymbol;
       isUndefined = exports11.isUndefined;
-      log7 = exports11.log;
+      log8 = exports11.log;
       promisify3 = exports11.promisify;
       types = exports11.types;
       TextEncoder2 = exports11.TextEncoder = globalThis.TextEncoder;
@@ -71057,7 +71064,7 @@ return ${compiler2.callType("value", tagType)}
   });
 
   // src/assets/source/HostedAssetSource.ts
-  var BINARY_TIMEOUT, log8, DEFAULT_OPTIONS2, _HostedAssetSource, HostedAssetSource;
+  var BINARY_TIMEOUT, log9, DEFAULT_OPTIONS2, _HostedAssetSource, HostedAssetSource;
   var init_HostedAssetSource = __esm({
     "src/assets/source/HostedAssetSource.ts"() {
       init_dirname();
@@ -71074,7 +71081,7 @@ return ${compiler2.callType("value", tagType)}
       init_parser();
       init_merge();
       BINARY_TIMEOUT = 6e4;
-      log8 = logger("HostedAssetSource");
+      log9 = logger("HostedAssetSource");
       DEFAULT_OPTIONS2 = {
         retryDefaults: true
       };
@@ -71086,14 +71093,14 @@ return ${compiler2.callType("value", tagType)}
             return direct;
           }
           if (key.namespace !== DEFAULT_NAMESPACE) {
-            log8.debug("Retrying", key, "with default namespace");
+            log9.debug("Retrying", key, "with default namespace");
             const namespaceKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, key.root);
             const namespaced = await this.load(namespaceKey, parser);
             if (typeof namespaced !== "undefined") {
               return namespaced;
             }
             if (typeof key.root !== "undefined" && key.root !== AssetLoader.ROOT || typeof this.root !== "undefined" && this.root !== AssetLoader.ROOT) {
-              log8.debug("Retrying", key, "with default root+namespace");
+              log9.debug("Retrying", key, "with default root+namespace");
               const namespacedRootedKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, AssetLoader.ROOT);
               const namespacedRooted = await this.load(namespacedRootedKey, parser);
               if (typeof namespacedRooted !== "undefined") {
@@ -71101,7 +71108,7 @@ return ${compiler2.callType("value", tagType)}
               }
             }
           } else if (typeof key.root !== "undefined" && key.root !== AssetLoader.ROOT || typeof this.root !== "undefined" && this.root !== AssetLoader.ROOT) {
-            log8.debug("Retrying", key, "with default root");
+            log9.debug("Retrying", key, "with default root");
             const rootKey = new AssetKey(key.namespace, key.path, key.assetType, key.type, key.rootType, key.extension, AssetLoader.ROOT);
             const rooted = await this.load(rootKey, parser);
             if (typeof rooted !== "undefined") {
@@ -71112,7 +71119,7 @@ return ${compiler2.callType("value", tagType)}
         }
         async load(key, parser) {
           const url = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
-          log8.debug("Loading", url);
+          log9.debug("Loading", url);
           const request = { url };
           try {
             parser.config(request);
@@ -81238,7 +81245,7 @@ return ${compiler2.callType("value", tagType)}
   });
 
   // src/assets/AssetLoader.ts
-  var log9, AssetLoader;
+  var log10, AssetLoader;
   var init_AssetLoader = __esm({
     "src/assets/AssetLoader.ts"() {
       init_dirname();
@@ -81249,7 +81256,7 @@ return ${compiler2.callType("value", tagType)}
       init_log();
       init_source();
       init_Caching();
-      log9 = logger("AssetLoader");
+      log10 = logger("AssetLoader");
       AssetLoader = class {
         static get _SOURCES() {
           return this.sources ?? (this.sources = [{ key: "mcassets", source: new HostedAssetSource(this.ROOT, { retryDefaults: false }) }]);
@@ -81304,11 +81311,11 @@ ${key}` : key;
           if (override) {
             const existing = this.removeSource(key);
             if (existing) {
-              log9.info("Removed existing AssetSource", key);
+              log10.info("Removed existing AssetSource", key);
             }
           }
           this._SOURCES.unshift({ key, source });
-          log9.info("Added AssetSource", key);
+          log10.info("Added AssetSource", key);
         }
         /** Removes and returns the first source with this name. Call {@link Caching.clear} to reload assets. */
         static removeSource(key) {
@@ -81426,15 +81433,21 @@ ${key}` : key;
             key.extension += ".mcmeta";
           }
           const keyStr = key.serialize();
-          return Caching.textureMetaCache.get(keyStr, (k4) => {
-            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, (k4) => {
+            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() {
@@ -81494,14 +81507,14 @@ ${key}` : key;
   });
 
   // src/Ticker.ts
-  var log10, _Ticker, Ticker;
+  var log11, _Ticker, Ticker;
   var init_Ticker = __esm({
     "src/Ticker.ts"() {
       init_dirname();
       init_buffer2();
       init_process2();
       init_log();
-      log10 = logger("Ticker");
+      log11 = logger("Ticker");
       _Ticker = class _Ticker {
         static schedule(fn, ms) {
           const handle = setInterval(fn, ms);
@@ -81519,7 +81532,7 @@ ${key}` : key;
               try {
                 t5();
               } catch (e6) {
-                log10.warn(e6);
+                log11.warn(e6);
               }
             });
             _Ticker.oneSecondTicks++;
@@ -81773,7 +81786,7 @@ ${key}` : key;
   });
 
   // src/UVMapper.ts
-  var log11, X3, Y4, Z3, FACE_UV_AXES, UVMapper, MinecraftFaceUV;
+  var log12, X3, Y4, Z3, FACE_UV_AXES, UVMapper, MinecraftFaceUV;
   var init_UVMapper = __esm({
     "src/UVMapper.ts"() {
       init_dirname();
@@ -81791,7 +81804,7 @@ ${key}` : key;
       init_ModelGenerator();
       init_log();
       init_cubeUv();
-      log11 = logger("UVMapper");
+      log12 = logger("UVMapper");
       X3 = 0;
       Y4 = 1;
       Z3 = 2;
@@ -82024,7 +82037,7 @@ ${key}` : key;
             model.elements = originalModel.elements.map((element) => ({ ...element }));
           }
           const isItemModel = !("elements" in model);
-          log11.debug("Creating Atlas for", model.key);
+          log12.debug("Creating Atlas for", model.key);
           if (model.textures) {
             const promises = [];
             const uniqueTextureNames = [];
@@ -82038,7 +82051,7 @@ ${key}` : key;
                 const assetKey = AssetKey.parse("textures", textureValue, model.key);
                 promises.push(ModelTextures.get(assetKey).then((asset2) => {
                   if (!asset2) {
-                    log11.warn("Missing texture", assetKey);
+                    log12.warn("Missing texture", assetKey);
                     return;
                   }
                   textureMap[textureKey] = new WrappedImage(asset2);
@@ -82050,7 +82063,7 @@ ${key}` : key;
             }
             await Promise.all(promises);
             const textureCount = uniqueTextureNames.length;
-            log11.debug("Creating Atlas for", textureCount, "textures");
+            log12.debug("Creating Atlas for", textureCount, "textures");
             this.fillMissingTextureKeys(model.textures, textureMap);
             this.fillMissingTextureKeys(model.textures, metaMap);
             const sizes = {};
@@ -82081,7 +82094,7 @@ ${key}` : key;
             this.fillMissingTextureKeys(model.textures, sizes);
             const s4 = Math.ceil(Math.sqrt(textureCount + 1));
             const size = Math.ceil(s4 * maxWidth);
-            log11.debug("Atlas size:", size);
+            log12.debug("Atlas size:", size);
             const squaredSize = size * size;
             const image = new CanvasImage(size, size);
             const missing = Textures.getMissing().image;
@@ -82160,7 +82173,7 @@ ${key}` : key;
             }
             this.fillMissingTextureKeys(model.textures, positions);
             if (isItemModel) {
-              log11.debug("Generating item model for", model);
+              log12.debug("Generating item model for", model);
               model.elements = [];
               for (let layerName of ModelGenerator.ITEM_LAYERS) {
                 const textureImage = textureMap[layerName];
@@ -82176,7 +82189,7 @@ ${key}` : key;
                   ), layerName));
                 }
               }
-              log11.debug("Item model elements", model.elements);
+              log12.debug("Item model elements", model.elements);
             }
             if (!model.elements) {
             }
@@ -82233,7 +82246,7 @@ ${key}` : key;
               hasTranslucency
             );
           } else {
-            log11.warn("Model does not have any textures", model);
+            log12.warn("Model does not have any textures", model);
           }
           return void 0;
         }
@@ -82360,26 +82373,318 @@ ${key}` : key;
     }
   });
 
+  // src/assets/_versions/DatasetVersions.ts
+  var parseRelease, compare2, nearestRelease;
+  var init_DatasetVersions = __esm({
+    "src/assets/_versions/DatasetVersions.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      parseRelease = (value) => /^\d+\.\d+(?:\.\d+)?$/.test(value) ? value.split(".").map(Number) : void 0;
+      compare2 = (left, right) => {
+        for (let i4 = 0; i4 < 3; i4++) {
+          const difference = (left[i4] ?? 0) - (right[i4] ?? 0);
+          if (difference) return difference;
+        }
+        return 0;
+      };
+      nearestRelease = (requestedVersion, published) => {
+        const requested = parseRelease(requestedVersion);
+        if (!requested) return void 0;
+        const versions2 = published.map((name2) => ({ name: name2, number: parseRelease(name2) })).filter((entry) => !!entry.number).sort((left, right) => compare2(left.number, right.number));
+        const sameLine = versions2.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] ?? versions2.filter((entry) => compare2(entry.number, requested) <= 0).pop() ?? versions2[0];
+        return selected?.name;
+      };
+    }
+  });
+
+  // src/error/MineRenderError.ts
+  var MineRenderError;
+  var init_MineRenderError = __esm({
+    "src/error/MineRenderError.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      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_dirname();
+      init_buffer2();
+      init_process2();
+      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 name2 = pass.layer;
+            for (let n4 = 2; names.includes(name2); n4++) name2 = `${pass.layer}#${n4}`;
+            names.push(name2);
+            return { name: name2, layer, pass };
+          });
+          const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name: name2, layer, pass }, index) => {
+            const override = options?.textures?.[name2] ?? (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 [name2, { 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 name2 = path.split("/").pop();
+            for (const candidate of [path, `${path}/${name2}`]) {
+              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", `${name2}_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), `${name2}_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_dirname();
+      init_buffer2();
+      init_process2();
+      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 name2 = slots[slot], geometry = model?.layers[name2];
+            if (!geometry) throw new MineRenderError(`Missing armor geometry ${name2}; 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 ? name2 : `${name2}#${count}`] = { key: texture, texture, layer: geometry, ...settings };
+            };
+            let glint = piece.glint;
+            for (const layer of equipmentLayers) {
+              let color3;
+              if (layer.dyeable) {
+                const undyed = layer.dyeable.color_when_undyed;
+                color3 = 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 (color3 === void 0) continue;
+              }
+              const texture = this.identifier(layer.texture);
+              add(
+                new AssetKey(texture.namespace, `equipment/${layerType}/${texture.path}`, "textures", "entity", "assets", ".png"),
+                { ...color3 !== void 0 && { color: color3 }, ...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, release2, compare2, MineRenderData;
+  var object2, MineRenderData;
   var init_MineRenderData = __esm({
     "src/assets/MineRenderData.ts"() {
       init_dirname();
       init_buffer2();
       init_process2();
+      init_DatasetVersions();
       init_AssetKey();
       init_AssetLoader();
       init_AssetParsers();
       init_Caching();
       object2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-      release2 = (value) => /^\d+\.\d+(?:\.\d+)?$/.test(value) ? value.split(".").map(Number) : void 0;
-      compare2 = (left, right) => {
-        for (let i4 = 0; i4 < 3; i4++) {
-          const difference = (left[i4] ?? 0) - (right[i4] ?? 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) {
@@ -82409,9 +82714,9 @@ ${key}` : key;
           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 && release2(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 = release2(requestedVersion);
+            const requested = parseRelease(requestedVersion);
             if (!requested) {
               throw new Error(`No MineRender data is published for ${requestedVersion}; automatic fallback requires a release`);
             }
@@ -82423,14 +82728,12 @@ ${key}` : key;
               }
               return value.versions;
             });
-            const versions2 = index.map((entry) => ({ name: entry.name, number: release2(entry.name) })).filter((entry) => !!entry.number).sort((left, right) => compare2(left.number, right.number));
-            const sameLine = versions2.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] ?? versions2.filter((entry) => compare2(entry.number, requested) <= 0).pop() ?? versions2[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) {
@@ -82783,25 +83086,6 @@ ${key}` : key, async () => {
     }
   });
 
-  // src/error/MineRenderError.ts
-  var MineRenderError;
-  var init_MineRenderError = __esm({
-    "src/error/MineRenderError.ts"() {
-      init_dirname();
-      init_buffer2();
-      init_process2();
-      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({
@@ -83593,7 +83877,7 @@ ${key}` : key, async () => {
   });
 
   // src/assets/BlockEntities.ts
-  var log12, BlockEntities;
+  var log13, BlockEntities;
   var init_BlockEntities = __esm({
     "src/assets/BlockEntities.ts"() {
       init_dirname();
@@ -83601,11 +83885,12 @@ ${key}` : key, async () => {
       init_process2();
       init_three_module();
       init_AssetKey();
+      init_Entities();
       init_AssetLoader();
       init_source();
       init_Caching();
       init_log();
-      log12 = logger("BlockEntities");
+      log13 = logger("BlockEntities");
       BlockEntities = class {
         /**
          * Loads the block index of a version. Versions and sources without one yield an empty index, and so does
@@ -83617,9 +83902,10 @@ ${key}` : key, async () => {
           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 (error2) {
-              log12.warn("Could not load the block entity index; block entities are drawn as plain block models", error2);
+              log13.warn("Could not load the block entity index; block entities are drawn as plain block models", error2);
               return {};
             }
           });
@@ -83705,139 +83991,6 @@ ${key}` : key, async () => {
     }
   });
 
-  // src/assets/Entities.ts
-  var Entities;
-  var init_Entities = __esm({
-    "src/assets/Entities.ts"() {
-      init_dirname();
-      init_buffer2();
-      init_process2();
-      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 name2 = pass.layer;
-            for (let n4 = 2; names.includes(name2); n4++) name2 = `${pass.layer}#${n4}`;
-            names.push(name2);
-            return { name: name2, layer, pass };
-          });
-          const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name: name2, layer, pass }, index) => {
-            const override = options?.textures?.[name2] ?? (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 [name2, { 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 name2 = path.split("/").pop();
-            for (const candidate of [path, `${path}/${name2}`]) {
-              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", `${name2}_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), `${name2}_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, {
@@ -83896,7 +84049,7 @@ ${key}` : key, async () => {
       }
       return { indices, rows, metrics };
     } catch (error2) {
-      log13.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error2);
+      log14.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error2);
       return void 0;
     }
   }
@@ -83915,7 +84068,7 @@ ${key}` : key, async () => {
         return { ...override, from, to };
       });
     } catch (error2) {
-      log13.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error2);
+      log14.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error2);
       return glyphs;
     }
     const file = await Caching.unihexCache.get(key.serialize(), () => parseUnihex(key));
@@ -83963,7 +84116,7 @@ ${key}` : key, async () => {
     }
     return glyphs;
   }
-  var log13, ATLAS_SIZE, GLYPH_HEIGHT, UnihexAtlas, atlases;
+  var log14, ATLAS_SIZE, GLYPH_HEIGHT, UnihexAtlas, atlases;
   var init_Unihex = __esm({
     "src/assets/_fonts/Unihex.ts"() {
       init_dirname();
@@ -83977,7 +84130,7 @@ ${key}` : key, async () => {
       init_AssetParsers();
       init_CanvasCompat();
       init_log();
-      log13 = logger("Unihex");
+      log14 = logger("Unihex");
       ATLAS_SIZE = 512;
       GLYPH_HEIGHT = 16;
       UnihexAtlas = class {
@@ -85000,6 +85153,272 @@ ${key}` : key, async () => {
     }
   });
 
+  // src/model/ItemGlint.ts
+  var ItemGlint_exports = {};
+  __export(ItemGlint_exports, {
+    ItemGlint: () => ItemGlint
+  });
+  var ItemGlint;
+  var init_ItemGlint = __esm({
+    "src/model/ItemGlint.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_three_module();
+      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 : RepeatWrapping;
+              if (metadata?.texture?.blur) texture2.magFilter = texture2.minFilter = LinearFilter;
+              return texture2;
+            });
+          }
+          const material = new ShaderMaterial({
+            name: "item-glint",
+            transparent: true,
+            depthWrite: false,
+            depthFunc: EqualDepth,
+            side: DoubleSide,
+            forceSinglePass: true,
+            blending: CustomBlending,
+            blendSrc: SrcColorFactor,
+            blendDst: OneFactor,
+            blendSrcAlpha: ZeroFactor,
+            blendDstAlpha: OneFactor,
+            toneMapped: false,
+            // TextureTransform.ARMOR_ENTITY_GLINT_TEXTURING uses a smaller UV scale than item glint.
+            defines: entityMeshes ? { ENTITY_GLINT: true, ENTITY_GLINT_SCALE: kind === "armor" ? "0.16" : "0.5" } : {},
+            uniforms: {
+              ...!entityMeshes && { baseMap: { value: baseMap } },
+              glintMap: { value: texture },
+              glintOffset: { value: new Vector2() },
+              glintAlpha: { value: 0.75 }
+            },
+            vertexShader: `
+                uniform vec2 glintOffset;
+                #ifndef ENTITY_GLINT
+                attribute vec4 uvBounds;
+                attribute vec2 glintUv;
+                flat out vec4 vUvBounds;
+                centroid out vec2 vUv;
+                #endif
+                varying vec2 vGlintUv;
+                void main() {
+                    #ifdef ENTITY_GLINT
+                    vec2 p = vec2(uv.x, 1.0 - uv.y) * ENTITY_GLINT_SCALE;
+                    #else
+                    vUv = uv;
+                    vUvBounds = uvBounds;
+                    vec2 p = glintUv * 8.0;
+                    #endif
+                    float angle = radians(10.0);
+                    vGlintUv = vec2(cos(angle) * p.x - sin(angle) * p.y, sin(angle) * p.x + cos(angle) * p.y) + glintOffset;
+                    vec4 mvPosition = vec4(position, 1.0);
+                    mvPosition = modelViewMatrix * mvPosition;
+                    gl_Position = projectionMatrix * mvPosition;
+                }
+            `,
+            fragmentShader: `
+                #ifndef ENTITY_GLINT
+                uniform sampler2D baseMap;
+                flat in vec4 vUvBounds;
+                centroid in vec2 vUv;
+                #endif
+                uniform sampler2D glintMap;
+                uniform float glintAlpha;
+                varying vec2 vGlintUv;
+                void main() {
+                    #ifndef ENTITY_GLINT
+                    vec2 mapUv = clamp(vUv, vUvBounds.xy, vUvBounds.zw);
+                    if (texture2D(baseMap, mapUv).a < 0.01) discard;
+                    #endif
+                    vec4 color = texture2D(glintMap, vec2(vGlintUv.x, 1.0 - vGlintUv.y));
+                    if (color.a < 0.1) discard;
+                    gl_FragColor = color;
+                    #include <colorspace_fragment>
+                    gl_FragColor.rgb *= glintAlpha;
+                }
+            `
+          });
+          if (!entityMeshes) Object.assign(material.defaultAttributeValues, { uvBounds: [0, 0, 1, 1] });
+          const targets = entityMeshes ? [...entityMeshes] : [];
+          if (!entityMeshes) owner.iterateAllMeshes((mesh) => targets.push({ mesh }));
+          for (const { mesh: base, parent = base } of targets) {
+            const pass = new Mesh(base.geometry, material);
+            pass.name = `${base.name}:glint`;
+            pass.userData.minerenderItemGlint = true;
+            pass.raycast = () => {
+            };
+            pass.renderOrder = parent.renderOrder + 0.5;
+            parent.add(pass);
+          }
+          return new _ItemGlint(owner, material);
+        }
+        /**
+         * Maps glint before model centering and display transforms. Ordinary sprites approximate Minecraft's shared atlas density.
+         * @internal
+         */
+        static mapUvs(geometry, faces, atlas, itemId, display) {
+          const uv = geometry.getAttribute("uv");
+          const mapped = new Float32Array(uv.count * 2);
+          if (itemId === "minecraft:compass" || itemId === "minecraft:recovery_compass" || itemId === "minecraft:clock") {
+            const positions = geometry.getAttribute("position"), normals = geometry.getAttribute("normal");
+            const scale = display === "gui" /* GUI */ ? 0.5 : display === "firstperson_lefthand" /* FIRSTPERSON_LEFTHAND */ || display === "firstperson_righthand" /* FIRSTPERSON_RIGHTHAND */ ? 0.75 : 1;
+            const factor = 1 / (16 * 128 * scale);
+            for (let index = 0; index < positions.count; index++) {
+              const x4 = positions.getX(index), y5 = positions.getY(index), z4 = 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 u4, v5;
+              if (ay >= az && ay >= ax) {
+                u4 = x4;
+                v5 = ny < 0 ? -z4 : z4;
+              } else if (az >= ax) {
+                u4 = nz < 0 ? -x4 : x4;
+                v5 = -y5;
+              } else {
+                u4 = nx < 0 ? -z4 : z4;
+                v5 = -y5;
+              }
+              mapped[index * 2] = u4 * factor;
+              mapped[index * 2 + 1] = v5 * factor;
+            }
+            geometry.setAttribute("glintUv", new Float32BufferAttribute(mapped, 2));
+            return;
+          }
+          for (const [faceIndex, face] of CUBE_FACES.entries()) {
+            const texture = faces[face]?.texture?.substring(1);
+            const position = texture && atlas.positions[texture] || [0, 0];
+            const size = texture && atlas.sizes[texture] || [atlas.image.width, atlas.image.height];
+            for (let corner = 0; corner < 4; corner++) {
+              const index = faceIndex * 4 + corner;
+              mapped[index * 2] = (uv.getX(index) * atlas.image.width - position[0]) / size[0] / 32;
+              mapped[index * 2 + 1] = ((1 - uv.getY(index)) * atlas.image.height - position[1]) / size[1] / 32;
+            }
+          }
+          geometry.setAttribute("glintUv", new Float32BufferAttribute(mapped, 2));
+        }
+        updateTime() {
+          const time = Math.trunc(Date.now() * 4);
+          this.material.uniforms.glintOffset.value.set(-(time % 11e4) / 11e4, time % 3e4 / 3e4);
+        }
+        /** @internal */
+        updateSubscription(active) {
+          if (active && this.ticker === void 0) {
+            this.updateTime();
+            this.ticker = Ticker.add(() => {
+              this.updateTime();
+              this.owner.notifyDirty();
+            });
+          } else if (!active) {
+            Ticker.remove(this.ticker);
+            this.ticker = void 0;
+          }
+        }
+        dispose() {
+          Ticker.remove(this.ticker);
+          this.ticker = void 0;
+          this.material.dispose();
+        }
+      };
+    }
+  });
+
+  // src/texture/PalettedTextures.ts
+  var PalettedTextures_exports = {};
+  __export(PalettedTextures_exports, {
+    PalettedTextures: () => PalettedTextures
+  });
+  var PalettedTextures;
+  var init_PalettedTextures = __esm({
+    "src/texture/PalettedTextures.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      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 i4 = 0; i4 < key.length; i4 += 4) {
+            if (key[i4 + 3] !== 0) mapping.set(key[i4] << 16 | key[i4 + 1] << 8 | key[i4 + 2], i4);
+          }
+          const output = new Uint8ClampedArray(pixels);
+          for (let i4 = 0; i4 < pixels.length; i4 += 4) {
+            if (pixels[i4 + 3] === 0) continue;
+            const mapped = mapping.get(pixels[i4] << 16 | pixels[i4 + 1] << 8 | pixels[i4 + 2]);
+            if (mapped === void 0) continue;
+            output.set(permutation2.subarray(mapped, mapped + 3), i4);
+            output[i4 + 3] = Math.floor(pixels[i4 + 3] * permutation2[mapped + 3] / 255);
+          }
+          return output;
+        }
+      };
+    }
+  });
+
   // src/entity/scene/EntityObject.ts
   var EntityObject_exports = {};
   __export(EntityObject_exports, {
@@ -85009,7 +85428,7 @@ ${key}` : key, async () => {
   function isEntityObject(obj) {
     return obj.isEntityObject;
   }
-  var _EntityObject, EntityObject;
+  var ItemGlintClass, PalettedTexturesClass, _EntityObject, EntityObject;
   var init_EntityObject = __esm({
     "src/entity/scene/EntityObject.ts"() {
       init_dirname();
@@ -85043,8 +85462,14 @@ ${key}` : key, async () => {
           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);
+          });
         }
         /** An optional shared material replaces texture loading for every selected draw; its owner retains disposal. */
         async init(material) {
@@ -85055,12 +85480,26 @@ ${key}` : key, async () => {
               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 [name2] of layers) this.getLayerGroup(name2)?.traverse((object4) => {
+              if (isMesh(object4)) meshes.push(object4);
+            });
+            if (meshes.length) {
+              const ItemGlint2 = ItemGlintClass ?? (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();
@@ -85219,6 +85658,10 @@ ${key}` : key, async () => {
           );
         }
         async loadTextures(layer = this.entity) {
+          if (layer.palette) {
+            const PalettedTextures2 = PalettedTexturesClass ?? (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) {
@@ -85291,10 +85734,10 @@ ${key}` : key, async () => {
           this.clearScrollMaterials();
           const results = await Promise.allSettled(Object.entries(this.entityLayers).map(async ([name2, layer]) => {
             const mode2 = 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(mode2);
             const assetKeyStr = this.getTextureKey(layer).serialize();
-            const keyStr = `entity:${mode2}:${tint === void 0 ? "" : new Color(tint).getHexString()}:${assetKeyStr}`;
+            const keyStr = `entity:${mode2}:${tint === void 0 ? "" : new Color(tint).getHexString()}:${assetKeyStr}` + (layer.palette ? `:${layer.palette.key.serialize()}:${layer.palette.permutation.serialize()}` : "");
             let mat = scroll ? void 0 : Caching.materialCache.getIfPresent(keyStr);
             if (!mat) {
               const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
@@ -88206,7 +88649,7 @@ ${key}` : key, async () => {
   });
 
   // src/skin/Skins.ts
-  var log14, Skins;
+  var log15, Skins;
   var init_Skins = __esm({
     "src/skin/Skins.ts"() {
       init_dirname();
@@ -88215,7 +88658,7 @@ ${key}` : key, async () => {
       init_Requests();
       init_Caching();
       init_log();
-      log14 = logger("Skins");
+      log15 = logger("Skins");
       Skins = class {
         //<editor-fold desc="Skins">
         /** Returns a skin URL for {@link MineRenderScene.addSkin}, or `undefined` if name lookup fails. */
@@ -88287,7 +88730,7 @@ ${key}` : key, async () => {
             }
             return void 0;
           }).catch((err2) => {
-            log14.warn(err2);
+            log15.warn(err2);
             return void 0;
           });
         }
@@ -88302,7 +88745,7 @@ ${key}` : key, async () => {
             }
             return void 0;
           }).catch((err2) => {
-            log14.warn(err2);
+            log15.warn(err2);
             return void 0;
           });
         }
@@ -88316,7 +88759,7 @@ ${key}` : key, async () => {
             }
             return void 0;
           }).catch((err2) => {
-            log14.warn(err2);
+            log15.warn(err2);
             return void 0;
           });
         }
@@ -88340,7 +88783,7 @@ ${key}` : key, async () => {
             }
             return void 0;
           }).catch((err2) => {
-            log14.warn(err2);
+            log15.warn(err2);
             return void 0;
           });
         }
@@ -91276,7 +91719,7 @@ ${key}` : key, async () => {
           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 y5 = y0 * scale; y5 < y1 * scale; y5++) {
               for (let x4 = x0 * scale; x4 < x1 * scale; x4++) pixels[(y5 * width + x4) * 4 + 3] = 255;
             }
@@ -91287,6 +91730,10 @@ ${key}` : key, async () => {
   });
 
   // src/skin/PlayerHeadTextures.ts
+  var PlayerHeadTextures_exports = {};
+  __export(PlayerHeadTextures_exports, {
+    PlayerHeadTextures: () => PlayerHeadTextures
+  });
   var PlayerHeadTextures;
   var init_PlayerHeadTextures = __esm({
     "src/skin/PlayerHeadTextures.ts"() {
@@ -91679,212 +92126,6 @@ ${shader.fragmentShader}`.replace(
     }
   });
 
-  // src/model/ItemGlint.ts
-  var ItemGlint;
-  var init_ItemGlint = __esm({
-    "src/model/ItemGlint.ts"() {
-      init_dirname();
-      init_buffer2();
-      init_process2();
-      init_three_module();
-      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 ? ClampToEdgeWrapping : RepeatWrapping;
-              if (metadata?.texture?.blur) texture2.magFilter = texture2.minFilter = LinearFilter;
-              return texture2;
-            });
-          }
-          const material = new ShaderMaterial({
-            name: "item-glint",
-            transparent: true,
-            depthWrite: false,
-            depthFunc: EqualDepth,
-            side: DoubleSide,
-            forceSinglePass: true,
-            blending: CustomBlending,
-            blendSrc: SrcColorFactor,
-            blendDst: OneFactor,
-            blendSrcAlpha: ZeroFactor,
-            blendDstAlpha: OneFactor,
-            toneMapped: false,
-            defines: entityMeshes ? { ENTITY_GLINT: true } : {},
-            uniforms: {
-              ...!entityMeshes && { baseMap: { value: baseMap } },
-              glintMap: { value: texture },
-              glintOffset: { value: new Vector2() },
-              glintAlpha: { value: 0.75 }
-            },
-            vertexShader: `
-                uniform vec2 glintOffset;
-                #ifndef ENTITY_GLINT
-                attribute vec4 uvBounds;
-                attribute vec2 glintUv;
-                flat out vec4 vUvBounds;
-                centroid out vec2 vUv;
-                #endif
-                varying vec2 vGlintUv;
-                void main() {
-                    #ifdef ENTITY_GLINT
-                    vec2 p = vec2(uv.x, 1.0 - uv.y) * 0.5;
-                    #else
-                    vUv = uv;
-                    vUvBounds = uvBounds;
-                    vec2 p = glintUv * 8.0;
-                    #endif
-                    float angle = radians(10.0);
-                    vGlintUv = vec2(cos(angle) * p.x - sin(angle) * p.y, sin(angle) * p.x + cos(angle) * p.y) + glintOffset;
-                    vec4 mvPosition = vec4(position, 1.0);
-                    mvPosition = modelViewMatrix * mvPosition;
-                    gl_Position = projectionMatrix * mvPosition;
-                }
-            `,
-            fragmentShader: `
-                #ifndef ENTITY_GLINT
-                uniform sampler2D baseMap;
-                flat in vec4 vUvBounds;
-                centroid in vec2 vUv;
-                #endif
-                uniform sampler2D glintMap;
-                uniform float glintAlpha;
-                varying vec2 vGlintUv;
-                void main() {
-                    #ifndef ENTITY_GLINT
-                    vec2 mapUv = clamp(vUv, vUvBounds.xy, vUvBounds.zw);
-                    if (texture2D(baseMap, mapUv).a < 0.01) discard;
-                    #endif
-                    vec4 color = texture2D(glintMap, vec2(vGlintUv.x, 1.0 - vGlintUv.y));
-                    if (color.a < 0.1) discard;
-                    gl_FragColor = color;
-                    #include <colorspace_fragment>
-                    gl_FragColor.rgb *= glintAlpha;
-                }
-            `
-          });
-          if (!entityMeshes) Object.assign(material.defaultAttributeValues, { uvBounds: [0, 0, 1, 1] });
-          const targets = entityMeshes ? [...entityMeshes] : [];
-          if (!entityMeshes) owner.iterateAllMeshes((mesh) => targets.push({ mesh }));
-          for (const { mesh: base, parent = base } of targets) {
-            const pass = new Mesh(base.geometry, material);
-            pass.name = `${base.name}:glint`;
-            pass.userData.minerenderItemGlint = true;
-            pass.raycast = () => {
-            };
-            pass.renderOrder = parent.renderOrder + 0.5;
-            parent.add(pass);
-          }
-          return new _ItemGlint(owner, material);
-        }
-        /**
-         * Maps glint before model centering and display transforms. Ordinary sprites approximate Minecraft's shared atlas density.
-         * @internal
-         */
-        static mapUvs(geometry, faces, atlas, itemId, display) {
-          const uv = geometry.getAttribute("uv");
-          const mapped = new Float32Array(uv.count * 2);
-          if (itemId === "minecraft:compass" || itemId === "minecraft:recovery_compass" || itemId === "minecraft:clock") {
-            const positions = geometry.getAttribute("position"), normals = geometry.getAttribute("normal");
-            const scale = display === "gui" /* GUI */ ? 0.5 : display === "firstperson_lefthand" /* FIRSTPERSON_LEFTHAND */ || display === "firstperson_righthand" /* FIRSTPERSON_RIGHTHAND */ ? 0.75 : 1;
-            const factor = 1 / (16 * 128 * scale);
-            for (let index = 0; index < positions.count; index++) {
-              const x4 = positions.getX(index), y5 = positions.getY(index), z4 = 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 u4, v5;
-              if (ay >= az && ay >= ax) {
-                u4 = x4;
-                v5 = ny < 0 ? -z4 : z4;
-              } else if (az >= ax) {
-                u4 = nz < 0 ? -x4 : x4;
-                v5 = -y5;
-              } else {
-                u4 = nx < 0 ? -z4 : z4;
-                v5 = -y5;
-              }
-              mapped[index * 2] = u4 * factor;
-              mapped[index * 2 + 1] = v5 * factor;
-            }
-            geometry.setAttribute("glintUv", new Float32BufferAttribute(mapped, 2));
-            return;
-          }
-          for (const [faceIndex, face] of CUBE_FACES.entries()) {
-            const texture = faces[face]?.texture?.substring(1);
-            const position = texture && atlas.positions[texture] || [0, 0];
-            const size = texture && atlas.sizes[texture] || [atlas.image.width, atlas.image.height];
-            for (let corner = 0; corner < 4; corner++) {
-              const index = faceIndex * 4 + corner;
-              mapped[index * 2] = (uv.getX(index) * atlas.image.width - position[0]) / size[0] / 32;
-              mapped[index * 2 + 1] = ((1 - uv.getY(index)) * atlas.image.height - position[1]) / size[1] / 32;
-            }
-          }
-          geometry.setAttribute("glintUv", new Float32BufferAttribute(mapped, 2));
-        }
-        updateTime() {
-          const time = Math.trunc(Date.now() * 4);
-          this.material.uniforms.glintOffset.value.set(-(time % 11e4) / 11e4, time % 3e4 / 3e4);
-        }
-        /** @internal */
-        updateSubscription(active) {
-          if (active && this.ticker === void 0) {
-            this.updateTime();
-            this.ticker = Ticker.add(() => {
-              this.updateTime();
-              this.owner.notifyDirty();
-            });
-          } else if (!active) {
-            Ticker.remove(this.ticker);
-            this.ticker = void 0;
-          }
-        }
-        dispose() {
-          Ticker.remove(this.ticker);
-          this.ticker = void 0;
-          this.material.dispose();
-        }
-      };
-    }
-  });
-
   // src/model/scene/ModelObject.ts
   var ModelObject_exports = {};
   __export(ModelObject_exports, {
@@ -91894,7 +92135,7 @@ ${shader.fragmentShader}`.replace(
   function isModelObject(obj) {
     return obj.isModelObject;
   }
-  var log15, _ModelObject, ModelObject;
+  var log16, _ModelObject, ModelObject;
   var init_ModelObject = __esm({
     "src/model/scene/ModelObject.ts"() {
       init_dirname();
@@ -91917,7 +92158,7 @@ ${shader.fragmentShader}`.replace(
       init_GuiLight();
       init_ItemTints();
       init_ItemGlint();
-      log15 = logger("ModelObject");
+      log16 = logger("ModelObject");
       _ModelObject = class _ModelObject extends SceneObject {
         constructor(originalModel, options) {
           super(options);
@@ -92099,10 +92340,10 @@ ${shader.fragmentShader}`.replace(
                 }
               });
             } else {
-              log15.debug(this.atlas.model, "has no elements");
+              log16.debug(this.atlas.model, "has no elements");
             }
           } else {
-            log15.debug("Missing atlas for", this);
+            log16.debug("Missing atlas for", this);
           }
           if (this.options.mergeMeshes) {
             let combinedGeo;
@@ -92932,7 +93173,7 @@ ${shader.fragmentShader}`.replace(
   function isBlockObject(obj) {
     return obj.isBlockObject;
   }
-  var log18, _BlockObject, BlockObject;
+  var log19, _BlockObject, BlockObject;
   var init_BlockObject = __esm({
     "src/model/block/scene/BlockObject.ts"() {
       init_dirname();
@@ -92955,7 +93196,7 @@ ${shader.fragmentShader}`.replace(
       init_Entities();
       init_Biomes();
       init_log();
-      log18 = logger("BlockObject");
+      log19 = logger("BlockObject");
       _BlockObject = class _BlockObject extends SceneObject {
         constructor(blockState3, options) {
           super(options);
@@ -93047,20 +93288,28 @@ ${shader.fragmentShader}`.replace(
           if (!key || this.options.displayPosition) return false;
           const generation = this._entityGeneration;
           const created = [];
+          const placement = new Matrix4();
           let resolved;
           try {
             resolved = BlockEntities.resolve(await BlockEntities.getIndex(key.root), key.toNamespacedString(), this.state);
             if (!resolved) return false;
+            BlockEntities.matrix(resolved, placement);
             for (const part of resolved.parts) {
               const [namespace, path] = part.model.includes(":") ? part.model.split(":") : [key.namespace, part.model];
-              const texture = part.textureLocation === void 0 ? void 0 : AssetKey.parse("textures", part.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+              let texture = part.textureLocation === void 0 ? void 0 : AssetKey.parse("textures", part.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+              if (part.textureLocation === void 0 && namespace === "minecraft" && path === "player_head") {
+                const { PlayerHeadTextures: PlayerHeadTextures2 } = await Promise.resolve().then(() => (init_PlayerHeadTextures(), PlayerHeadTextures_exports));
+                texture = (await PlayerHeadTextures2.get(void 0, key.root)).texture;
+              }
               if (texture) texture.root = key.root;
               const entity = await Entities.getEntity(new BasicAssetKey(namespace, path), texture, { layer: part.layer });
               if (!entity) throw new MineRenderError(`Missing entity model ${part.model}`);
-              created.push(await this.scene.addEntity(entity, { wireframe: this.options.wireframe }));
+              const object4 = await this.scene.addEntity(entity, { wireframe: this.options.wireframe });
+              this.placeEntity(object4, placement);
+              created.push(object4);
             }
           } catch (error2) {
-            log18.warn(`Could not draw block entity ${key.toNamespacedString()}, using its block model`, error2);
+            log19.warn(`Could not draw block entity ${key.toNamespacedString()}, using its block model`, error2);
             this.removeEntities(created);
             return false;
           }
@@ -93068,18 +93317,21 @@ ${shader.fragmentShader}`.replace(
             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 Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
           for (const entity of this._entities) {
-            matrix.decompose(entity.position, entity.quaternion, entity.scale);
+            this.placeEntity(entity, this._entityPlacement);
           }
         }
+        placeEntity(entity, placement) {
+          const matrix = new Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(placement);
+          matrix.decompose(entity.position, entity.quaternion, entity.scale);
+        }
         get isOccluding() {
           if (!this.visible) {
             return false;
@@ -94214,6 +94466,7 @@ ${shader.fragmentShader}`.replace(
     AnvilParser: () => AnvilParser,
     AnvilWorldSource: () => AnvilWorldSource,
     ArchiveAssetSource: () => ArchiveAssetSource,
+    Armor: () => Armor,
     AssetKey: () => AssetKey,
     AssetLoadError: () => AssetLoadError,
     AssetLoader: () => AssetLoader,
@@ -94296,6 +94549,7 @@ ${shader.fragmentShader}`.replace(
     OrbitControls: () => OrbitControls,
     PackFormats: () => PackFormats,
     PackMetadata: () => PackMetadata,
+    PalettedTextures: () => PalettedTextures,
     PersistentCache: () => PersistentCache,
     PlayerHeadTextures: () => PlayerHeadTextures,
     Renames: () => Renames,
@@ -94440,6 +94694,7 @@ ${shader.fragmentShader}`.replace(
   init_buffer2();
   init_process2();
   init_Env();
+  init_log();
 
   // src/env/browser/BrowserCache.ts
   init_dirname();
@@ -94546,6 +94801,7 @@ ${shader.fragmentShader}`.replace(
 
   // src/env/browser/BrowserEnv.ts
   var import_meta = {};
+  var log2 = logger("BrowserEnv");
   function lazyLocalForage(options) {
     let instance;
     const store = () => instance ?? (instance = Promise.resolve().then(() => __toESM(require_localforage())).then((module2) => module2.default.createInstance(options)));
@@ -94561,7 +94817,8 @@ ${shader.fragmentShader}`.replace(
     };
   }
   var BrowserEnv = class {
-    constructor() {
+    constructor(options = {}) {
+      this.options = options;
       this.name = "browser";
     }
     createCanvas(width, height) {
@@ -94590,14 +94847,18 @@ ${shader.fragmentShader}`.replace(
     createWorker(name2) {
       if (name2 !== "section" || typeof Worker === "undefined") return void 0;
       try {
+        const sectionWorker = this.options.sectionWorker;
+        if (typeof sectionWorker === "function") return sectionWorker();
+        if (sectionWorker !== void 0) return new Worker(sectionWorker, { type: "module" });
         return new Worker(new URL("./section.worker.mjs", import_meta.url), { type: "module" });
-      } catch {
+      } catch (error2) {
+        log2.warn("Could not start the section worker, so sections build on the main thread. Pass sectionWorker to registerBrowserEnv to load it from another URL.", error2);
         return void 0;
       }
     }
   };
-  function registerBrowserEnv() {
-    const env3 = new BrowserEnv();
+  function registerBrowserEnv(options) {
+    const env3 = new BrowserEnv(options);
     Env.register(env3);
     return env3;
   }
@@ -94723,6 +94984,12 @@ ${shader.fragmentShader}`.replace(
     Caching.end();
   }
 
+  // src/armor/index.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_Armor();
+
   // src/assets/index.ts
   init_dirname();
   init_buffer2();
@@ -96092,7 +96359,7 @@ property list uchar int vertex_index
   init_util();
   init_log();
   init_three();
-  var log16 = logger("SceneInspector");
+  var log17 = logger("SceneInspector");
   var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
   var SceneInspector = class {
     constructor(renderer) {
@@ -96186,7 +96453,7 @@ property list uchar int vertex_index
     }
     selectObject(targetObject, targetIntersection, instance = this.getIntersectionInstance(targetIntersection)) {
       this.selectedObject = targetObject;
-      log16.debug("selected", targetObject);
+      log17.debug("selected", targetObject);
       this.redraw(targetObject, targetIntersection, instance);
     }
     redraw(targetObject, targetIntersection, instance) {
@@ -96457,7 +96724,7 @@ property list uchar int vertex_index
   init_buffer2();
   init_process2();
   init_log();
-  var log17 = logger("InstanceManager");
+  var log18 = logger("InstanceManager");
   var InstanceManager = class {
     constructor() {
       this.isInstanceManager = true;
@@ -96466,7 +96733,7 @@ property list uchar int vertex_index
     /** Allocates a new placement of a cached model, or returns `undefined` if the key is unknown. */
     async get(key) {
       if (key in this.instanceCache) {
-        log17.debug("key in cache", key);
+        log18.debug("key in cache", key);
         return (await this.instanceCache[key]).nextInstance();
       }
       return void 0;
@@ -96476,7 +96743,7 @@ property list uchar int vertex_index
       if (key in this.instanceCache) {
         return await this.get(key);
       }
-      log17.debug("key not in cache", key);
+      log18.debug("key not in cache", key);
       const pending = Promise.resolve().then(supplier).then((obj) => obj.nextInstance());
       this.instanceCache[key] = pending;
       try {
@@ -97444,6 +97711,7 @@ property list uchar int vertex_index
   init_buffer2();
   init_process2();
   init_SceneObject();
+  init_three_module();
 
   // src/skin/SkinPart.ts
   init_dirname();
@@ -97463,6 +97731,8 @@ property list uchar int vertex_index
     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);
@@ -97471,6 +97741,14 @@ property list uchar int vertex_index
   init_dirname();
   init_buffer2();
   init_process2();
+  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: {
@@ -98091,7 +98369,9 @@ property list uchar int vertex_index
       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
@@ -98145,6 +98425,7 @@ property list uchar int vertex_index
   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,
@@ -98158,7 +98439,9 @@ property list uchar int vertex_index
     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 = {
@@ -98190,6 +98473,12 @@ property list uchar int vertex_index
   };
 
   // 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();
@@ -98197,27 +98486,42 @@ property list uchar int vertex_index
       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 Object3D();
+      this.add(model);
       {
-        const headGroup = this.createAndAddGroup("head", 0, 28, 0, "y" /* Y */, -4);
+        const headGroup = this.createGroup("head", 0, 28, 0, "y" /* Y */, -4);
+        model.add(headGroup);
         const headGeo = this.getBoxGeometry("head" /* HEAD */);
         const head = this.createAndAddMesh("head", headGroup, headGeo, mat, "y" /* Y */, 4);
         const hatGeo = this.getBoxGeometry("hat" /* HAT */);
         const hat = this.createAndAddMesh("hat", headGroup, hatGeo, mat, "y" /* Y */, 4);
       }
       {
-        const bodyGroup = this.createAndAddGroup("body", 0, 24, 0);
+        const bodyGroup = this.createGroup("body", 0, 24, 0);
+        model.add(bodyGroup);
         const bodyGeo = this.getBoxGeometry("body" /* BODY */);
         const body = this.createAndAddMesh("body", bodyGroup, bodyGeo, mat, "y" /* Y */, -6);
         const jacketGeo = this.getBoxGeometry("jacket" /* JACKET */);
@@ -98225,7 +98529,8 @@ property list uchar int vertex_index
       }
       {
         {
-          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;
@@ -98234,7 +98539,8 @@ property list uchar int vertex_index
           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;
@@ -98245,14 +98551,16 @@ property list uchar int vertex_index
       }
       {
         {
-          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 */);
@@ -98319,6 +98627,54 @@ property list uchar int vertex_index
       }
       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 ?? (ArmorClass = (await Promise.resolve().then(() => (init_Armor(), Armor_exports))).Armor);
+        const EntityObject2 = EntityObjectClass ?? (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 [name2, part] of Object.entries(parts)) {
+            const layers = {};
+            for (const [draw, layer] of Object.entries(model.layers)) {
+              const child = layer.layer.root.children[name2];
+              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: { [name2]: { ...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;
@@ -98337,6 +98693,39 @@ property list uchar int vertex_index
       }
       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, x4] 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(x4, 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;
@@ -98346,6 +98735,11 @@ property list uchar int vertex_index
     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
@@ -98365,7 +98759,7 @@ property list uchar int vertex_index
   }
   var ModelObjectClass;
   var BlockObjectClass;
-  var EntityObjectClass;
+  var EntityObjectClass2;
   var GuiObjectClass;
   var ItemTintsClass;
   var _MineRenderScene = class _MineRenderScene extends Scene {
@@ -98506,7 +98900,7 @@ property list uchar int vertex_index
     }
     /** Adds an entity loaded with {@link Entities.getEntity}, using its selected layers and textures. */
     async addEntity(entity, options, parent = this) {
-      const EntityObject2 = EntityObjectClass ?? (EntityObjectClass = (await Promise.resolve().then(() => (init_EntityObject(), EntityObject_exports))).EntityObject);
+      const EntityObject2 = EntityObjectClass2 ?? (EntityObjectClass2 = (await Promise.resolve().then(() => (init_EntityObject(), EntityObject_exports))).EntityObject);
       return this.addSceneObject(entity, () => new EntityObject2(entity, options), options, parent);
     }
     /**
@@ -101167,7 +101561,7 @@ gl_FragDepth=readDepth(vUv);
 
   // src/renderer/Renderer.ts
   init_log();
-  var log19 = logger("Renderer");
+  var log20 = logger("Renderer");
   var _Renderer = class _Renderer {
     constructor(options, surface) {
       this._width = 0;
@@ -101412,10 +101806,10 @@ gl_FragDepth=readDepth(vUv);
       this._element = element;
       this._element.appendChild(this.renderer.domElement);
       if (this.viewWidth == 0) {
-        log19.warn("0 element width");
+        log20.warn("0 element width");
       }
       if (this.viewHeight == 0) {
-        log19.warn("0 element height");
+        log20.warn("0 element height");
       }
       this.resize(this.viewWidth, this.viewHeight);
     }
@@ -101852,6 +102246,23 @@ gl_FragDepth=readDepth(vUv);
       }
     });
   };
+  function entityAnimation(value, path) {
+    const animation = object3(value, path);
+    if (["name", "clips"].filter((key) => animation[key] !== void 0).length !== 1) {
+      fail2(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) fail2(path2, "expected at least one clip");
+      const names = /* @__PURE__ */ new Set();
+      for (const [index, clip] of value2.entries()) {
+        if (names.has(clip.name)) fail2(`${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) {
@@ -101892,13 +102303,27 @@ gl_FragDepth=readDepth(vUv);
     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: color2,
+            glint: boolean,
+            trim: (value3, path3) => {
+              fields(value3, path3, { pattern: asset, material: asset }, ["pattern", "material"]);
+            }
+          }, ["asset"]);
+        };
         fields(value, path, {
           ...common2,
           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, {
@@ -101912,10 +102337,11 @@ gl_FragDepth=readDepth(vUv);
             });
           },
           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, {
           ...common2,
@@ -101954,9 +102380,7 @@ gl_FragDepth=readDepth(vUv);
               })
             });
           },
-          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) fail2(`${path}.layers`, "expected at least one layer");
         break;
@@ -102191,6 +102615,7 @@ gl_FragDepth=readDepth(vUv);
             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");
             }
@@ -102229,10 +102654,20 @@ gl_FragDepth=readDepth(vUv);
             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: name2 }) => {
+                  const clip = animations && Object.prototype.hasOwnProperty.call(animations, name2) ? animations[name2] : void 0;
+                  if (!clip) throw new Error(`Entity ${definition.asset} has no animation "${name2}"`);
+                  return clip;
+                });
+                entity.playAnimations(clips, { ...animation, weights: animation.clips.map((clip) => clip.weight ?? 1) });
+              }
             }
             break;
           }
@@ -102292,6 +102727,7 @@ gl_FragDepth=readDepth(vUv);
   init_buffer2();
   init_process2();
   init_Colormaps();
+  init_PalettedTextures();
   init_TextureAtlas();
   init_TextureLoader();
   init_Textures();
@@ -103115,7 +103551,7 @@ gl_FragDepth=readDepth(vUv);
       read.waiters++;
       return new Promise((resolve, reject) => {
         let finished = false;
-        const release3 = () => {
+        const release2 = () => {
           if (finished) return false;
           finished = true;
           signal?.removeEventListener("abort", abort2);
@@ -103123,7 +103559,7 @@ gl_FragDepth=readDepth(vUv);
           return true;
         };
         const abort2 = () => {
-          if (!release3()) return;
+          if (!release2()) return;
           if (!read.waiters && !read.settled) {
             if (this.pending.get(key) === read) this.pending.delete(key);
             read.controller.abort(signal.reason);
@@ -103133,10 +103569,10 @@ gl_FragDepth=readDepth(vUv);
         signal?.addEventListener("abort", abort2, { once: true });
         read.promise.then(
           (data) => {
-            if (release3()) resolve(data);
+            if (release2()) resolve(data);
           },
           (error2) => {
-            if (release3()) reject(error2);
+            if (release2()) reject(error2);
           }
         );
         if (signal?.aborted) abort2();
@@ -103166,6 +103602,7 @@ gl_FragDepth=readDepth(vUv);
   init_dirname();
   init_buffer2();
   init_process2();
+  init_BlockObject();
   init_three_module();
   init_BlockStates();
   init_AssetKey();
@@ -103179,6 +103616,7 @@ gl_FragDepth=readDepth(vUv);
   init_util();
   init_AssetKey();
   init_BlockStates();
+  init_BlockEntities();
   init_CubeFace();
 
   // src/world/SectionModels.ts
@@ -103279,6 +103717,10 @@ gl_FragDepth=readDepth(vUv);
         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());
@@ -103301,22 +103743,24 @@ gl_FragDepth=readDepth(vUv);
     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 [i4, result] of settled.entries()) {
+        if (result.status === "rejected") throw result.reason;
+        if (!result.value) return void 0;
+        prepared.set(variants[i4], result.value);
       }
       return { state, groups, choices: prepared };
     }
@@ -103502,7 +103946,7 @@ gl_FragDepth=readDepth(vUv);
 
   // src/world/_entities/WorldEntities.ts
   init_log();
-  var log20 = logger("WorldEntities");
+  var log21 = logger("WorldEntities");
   var WorldEntities = class {
     constructor(scene) {
       this.scene = scene;
@@ -103571,7 +104015,7 @@ gl_FragDepth=readDepth(vUv);
             placement.owner.set(object4, { type: key.toNamespacedString(), position: placement.position });
             this.scene.add(object4);
           } catch (error2) {
-            log20.warn(`Could not draw saved entity ${placement.key.toNamespacedString()}, skipping it`, error2);
+            log21.warn(`Could not draw saved entity ${placement.key.toNamespacedString()}, skipping it`, error2);
           } finally {
             if (object4 && !placement.owner.has(object4)) object4.dispose();
           }
@@ -103793,7 +104237,8 @@ gl_FragDepth=readDepth(vUv);
 
   // src/world/MineRenderWorld.ts
   init_log();
-  var log21 = logger("MineRenderWorld");
+  var log22 = logger("MineRenderWorld");
+  var YIELD_INTERVAL_MS = 8;
   var MineRenderWorld = class {
     constructor(scene, options = {}) {
       this._chunks = /* @__PURE__ */ new Map();
@@ -103907,7 +104352,7 @@ gl_FragDepth=readDepth(vUv);
               failures.set(chunk, error2);
               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();
             }
@@ -104008,15 +104453,18 @@ gl_FragDepth=readDepth(vUv);
         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, i4) => [key, loaded[i4]]));
       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 Vector3();
         for (const block of multiblock.blocks) {
+          if (this.sectionModels && !Chunk.isAir(block)) distinct.set(ChunkData.paletteKey(block), block);
           const [x4, y5, z4] = block.position;
           this.validatePosBounds(position.set(x4, y5, z4));
           const cx = Math.floor(x4 / 16), cy = Math.floor(y5 / 16), cz = Math.floor(z4 / 16);
@@ -104027,6 +104475,16 @@ gl_FragDepth=readDepth(vUv);
           if (!group) groups2.set(chunk, group = []);
           group.push({ index: (y5 - cy * 16) * 256 + (z4 - cz * 16) * 16 + x4 - 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;
       }
@@ -104062,7 +104520,7 @@ gl_FragDepth=readDepth(vUv);
           )));
           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();
         }
@@ -104070,6 +104528,62 @@ gl_FragDepth=readDepth(vUv);
     }
     /** 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: x4, z: z4 } = chunk ?? {};
+        if (![x4, z4].every(Number.isSafeInteger)) {
+          throw new RangeError("Chunk column coordinates must be safe integers");
+        }
+        const sections = Array.from(chunk.sections, (section) => {
+          const { y: y5 } = section ?? {};
+          if (!Number.isSafeInteger(y5)) throw new RangeError("Chunk section coordinates must be safe integers");
+          return { ...section, y: y5 };
+        });
+        columns.push({ ...chunk, x: x4, z: z4, 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 (error2) {
+        failed = true;
+        failure = error2;
+      } finally {
+        try {
+          const failures = await this.refreshBiomes(true);
+          if (failures.size) log22.warn("Failed to refresh biome colors", failures.values().next().value);
+        } catch (error2) {
+          if (!failed) {
+            failed = true;
+            failure = error2;
+          }
+        }
+        try {
+          await this.updateCulling([]);
+        } catch (error2) {
+          if (!failed) {
+            failed = true;
+            failure = error2;
+          }
+        }
+      }
+      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");
       }
@@ -104131,7 +104645,7 @@ gl_FragDepth=readDepth(vUv);
             } finally {
               this.markSectionChanged(target);
             }
-            if (performance.now() - sliceStart > 8) {
+            if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
               await yieldToEventLoop();
               sliceStart = performance.now();
             }
@@ -104154,9 +104668,12 @@ gl_FragDepth=readDepth(vUv);
         await placeEntities?.();
       } finally {
         this.markBiomesChanged(chunk.x, chunk.z, void 0, false);
-        const failures = await this.refreshBiomes();
-        if (failures.size) log21.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) log22.warn("Failed to refresh biome colors", failures.values().next().value);
+          await this.updateCulling([...changes.values()]);
+        }
       }
     }
     /**
@@ -104186,14 +104703,14 @@ gl_FragDepth=readDepth(vUv);
         for (const { x: x4, z: z4 } of columns.values()) {
           this.entities?.clearColumn(x4, z4);
           await this.clearChunkColumn(x4, z4);
-          if (performance.now() - sliceStart > 8) {
+          if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
             await yieldToEventLoop();
             sliceStart = performance.now();
           }
         }
       } finally {
         const failures = await this.refreshBiomes(true);
-        if (failures.size) log21.warn("Failed to refresh biome colors", failures.values().next().value);
+        if (failures.size) log22.warn("Failed to refresh biome colors", failures.values().next().value);
         await this.updateCulling([]);
       }
     }
@@ -104325,15 +104842,25 @@ gl_FragDepth=readDepth(vUv);
                 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 (error2) {
@@ -104740,6 +105267,8 @@ gl_FragDepth=readDepth(vUv);
   init_buffer2();
   init_process2();
   init_Env();
+  init_log();
+  var log23 = logger("SectionWorker");
   var _SectionWorker = class _SectionWorker {
     constructor(worker) {
       this.worker = worker;
@@ -104753,8 +105282,12 @@ gl_FragDepth=readDepth(vUv);
         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) => {
+        log23.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"));
     }
     /** The shared worker, or undefined when the environment has none or a previous worker failed. */
     static shared() {
@@ -104791,6 +105324,9 @@ gl_FragDepth=readDepth(vUv);
   var SectionWorker = _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 Color(4159204).toArray();
   function toInput(entries, maxAtlasSize, fluids, lighting) {
@@ -104827,8 +105363,8 @@ gl_FragDepth=readDepth(vUv);
         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 = {
@@ -104838,8 +105374,8 @@ gl_FragDepth=readDepth(vUv);
             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,
@@ -104851,7 +105387,7 @@ gl_FragDepth=readDepth(vUv);
           const bounds = template.geometry.getAttribute("uvBounds");
           const color3 = template.geometry.getAttribute("color");
           const shade = template.geometry.getAttribute("shade");
-          for (let vertex2 = 0; vertex2 < quads * 4; vertex2++) {
+          for (let vertex2 = 0; vertex2 < quads * QUAD_VERTICES; vertex2++) {
             data.positions.set([position.getX(vertex2), position.getY(vertex2), position.getZ(vertex2)], vertex2 * 3);
             data.normals.set([normal.getX(vertex2), normal.getY(vertex2), normal.getZ(vertex2)], vertex2 * 3);
             data.uvs.set([uv.getX(vertex2), uv.getY(vertex2)], vertex2 * 2);
@@ -104864,7 +105400,7 @@ gl_FragDepth=readDepth(vUv);
             data.colors.set([color3?.getX(vertex2) ?? 1, color3?.getY(vertex2) ?? 1, color3?.getZ(vertex2) ?? 1], vertex2 * 3);
             data.shade[vertex2] = shade?.getX(vertex2) ?? 1;
           }
-          for (let i5 = 0; i5 < data.indices.length; i5++) data.indices[i5] = indices.getX(i5) - 4 * Math.floor(i5 / 6);
+          for (let i5 = 0; i5 < data.indices.length; i5++) data.indices[i5] = indices.getX(i5) - QUAD_VERTICES * Math.floor(i5 / QUAD_INDICES);
           templateCache.set(template, data);
         }
         id = input.templateData.length;
@@ -104897,6 +105433,54 @@ gl_FragDepth=readDepth(vUv);
     }
     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 Matrix4(), localCamera = new Vector3(), key = new Vector3(), previous = new Vector3();
+    let previousOrthographic;
+    mesh.onBeforeRender = (_renderer, _scene, camera) => {
+      localCamera.setFromMatrixPosition(camera.matrixWorld).applyMatrix4(view.copy(mesh.matrixWorld).invert());
+      const orthographic = !!camera.isOrthographicCamera;
+      if (orthographic) {
+        view.multiplyMatrices(camera.matrixWorldInverse, mesh.matrixWorld);
+        key.set(view.elements[2], view.elements[6], view.elements[10]);
+      } else {
+        key.copy(localCamera).divideScalar(BLOCK_SIZE).floor();
+      }
+      if (orthographic === previousOrthographic && key.equals(previous)) return;
+      previous.copy(key);
+      previousOrthographic = orthographic;
+      if (!centers) {
+        source = new Uint32Array(index.array);
+        centers = new Float32Array(count * 3);
+        depths = new Float32Array(count);
+        order = Uint32Array.from({ length: count }, (_4, 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 x4 = centers[quad * 3], y5 = centers[quad * 3 + 1], z4 = centers[quad * 3 + 2];
+        depths[quad] = orthographic ? key.x * x4 + key.y * y5 + key.z * z4 : -((x4 - localCamera.x) ** 2 + (y5 - localCamera.y) ** 2 + (z4 - localCamera.z) ** 2);
+      }
+      order.sort((a4, b4) => depths[a4] - depths[b4] || a4 - b4);
+      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 Group {
     constructor() {
       super(...arguments);
@@ -104906,7 +105490,11 @@ gl_FragDepth=readDepth(vUv);
     /** 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 vertex2 = mesh.geometry.getIndex().getX(hit.faceIndex * 3);
+      return owners[Math.floor(vertex2 / QUAD_VERTICES)];
     }
     /** Builds section-local meshes from visible quads. `maxAtlasSize` limits each atlas dimension in pixels. */
     static build(entries, maxAtlasSize = 2048, fluids, lighting) {
@@ -104942,13 +105530,14 @@ gl_FragDepth=readDepth(vUv);
         const material = Materials.createShadedCanvasMaterial(canvas, transparent, false, true);
         material.side = FrontSide;
         if (page.layer === 2) {
+          material.depthWrite = !material.transparent;
           material.side = DoubleSide;
           material.forceSinglePass = true;
-          material.depthWrite = !material.transparent;
         }
         material.vertexColors = true;
         const texture = material.uniforms?.map?.value ?? material.map;
         const mesh = new Mesh(geometry, material);
+        if (transparent) sortTransparentQuads(mesh);
         section.add(mesh);
         section.blockIndices.set(mesh, page.blockIndices);
         const unsubscribe = [];
@@ -105243,8 +105832,10 @@ gl_FragDepth=readDepth(vUv);
         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);
@@ -105260,7 +105851,6 @@ gl_FragDepth=readDepth(vUv);
           this.z * 16 + Math.floor(index / 16) % 16
         );
         positions.push(worldPos);
-        let object4;
         try {
           if (!readBlock) continue;
           const resolved = resolutions.get(key);
@@ -105282,7 +105872,7 @@ gl_FragDepth=readDepth(vUv);
             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,
@@ -105290,13 +105880,12 @@ gl_FragDepth=readDepth(vUv);
               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 (error2) {
           if (preserveDataOnFailure && readBlock) {
             this.renderedBlocks.set(index, { get block() {
@@ -105304,12 +105893,35 @@ gl_FragDepth=readDepth(vUv);
             }, object: void 0 });
           } else this.data.assign(index, 0);
           this.fluidCells[index] = 0;
-          object4?.removeFromScene();
-          if (!failed) failure = error2;
-          failed = true;
+          if (order < failureOrder) {
+            failureOrder = order;
+            failure = error2;
+          }
         }
       }
-      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 [i4, [index, { order, readBlock }]] of pending.entries()) {
+        const result = objects[i4];
+        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. */
@@ -105380,37 +105992,42 @@ gl_FragDepth=readDepth(vUv);
           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 Vector3(
-            this.x * 256 + index % 16 * 16,
-            this.y * 256 + Math.floor(index / 256) * 16,
-            this.z * 256 + Math.floor(index / 16) % 16 * 16
-          ));
-          this.renderedBlocks.get(index).object = object4;
+      const objects = await Promise.allSettled(perBlocks.map(({ index, blockState: blockState3, biome }) => this.createBlockObject(blockState3, new Vector3(
+        this.x * 256 + index % 16 * 16,
+        this.y * 256 + Math.floor(index / 256) * 16,
+        this.z * 256 + Math.floor(index / 16) % 16 * 16
+      ), {
+        mergeMeshes: true,
+        instanceMeshes: true,
+        maxInstanceCount: 2e3,
+        initialState: this.data.stateAt(this.data.idAt(index)).properties,
+        variantPosition: this.positionAt(index),
+        biome,
+        biomePosition: this.biomePosition(index, blockState3, this.data.stateAt(this.data.idAt(index)))
+      })));
+      for (const [i4, { index }] of perBlocks.entries()) {
+        const result = objects[i4];
+        if (result.status === "fulfilled") {
+          this.renderedBlocks.get(index).object = result.value;
           this.objectBlocks.add(index);
-        } catch (error2) {
+        } else {
           this.data.assign(index, 0);
           this.fluidCells[index] = 0;
           this.renderedBlocks.delete(index);
           this.objectBlocks.delete(index);
-          object4?.removeFromScene();
-          if (!failed) failure = error2;
+          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];
     }
@@ -105769,6 +106386,7 @@ gl_FragDepth=readDepth(vUv);
   init_dirname();
   init_buffer2();
   init_process2();
+  var MAX_PREFETCHED_COLUMNS = 4;
   var WorldStreamer = class {
     constructor(world, source, options = {}) {
       this.world = world;
@@ -105778,6 +106396,7 @@ gl_FragDepth=readDepth(vUv);
       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);
@@ -105822,6 +106441,12 @@ gl_FragDepth=readDepth(vUv);
         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 ?? (this.running = Promise.resolve().then(() => this.drain()));
     }
@@ -105842,8 +106467,11 @@ gl_FragDepth=readDepth(vUv);
       this.desired = [];
       this.center = void 0;
       this.loading?.controller.abort();
+      for (const read of this.reads.values()) read.controller.abort();
       return this.disposal ?? (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 {
@@ -105869,6 +106497,10 @@ gl_FragDepth=readDepth(vUv);
             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;
@@ -105891,26 +106523,105 @@ gl_FragDepth=readDepth(vUv);
             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 (error2) {
-            try {
-              await this.unloadMany([position]);
-            } catch (cleanupError) {
-              const failure = error2 instanceof Error ? error2 : new Error(String(error2));
-              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 = error2;
+          } finally {
+            read.ready = true;
+            if (read.controller.signal.aborted || this.disposed || !this.within(position, this.loadRadius)) {
+              this.reads.delete(key);
             }
-            throw error2;
+          }
+        })();
+      }
+    }
+    /** 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 (error2) {
+        try {
+          await this.unloadMany(positions);
+        } catch (cleanupError) {
+          const failure = error2 instanceof Error ? error2 : new Error(String(error2));
+          try {
+            Object.defineProperty(failure, "cause", { value: cleanupError, configurable: true });
+          } catch {
+            throw Object.assign(new Error(failure.message), { cause: cleanupError });
+          }
+          throw failure;
+        }
+        throw error2;
       }
     }
     needsLoad(position) {